cc-claw 0.29.2 → 0.30.0

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.29.2" : (() => {
+    VERSION = true ? "0.30.0" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -806,6 +806,7 @@ __export(store_exports4, {
   getRejectedInsights: () => getRejectedInsights,
   getReviewSession: () => getReviewSession,
   getSignalCountForChat: () => getSignalCountForChat,
+  getSkillCorrections: () => getSkillCorrections,
   getUnprocessedSignalCount: () => getUnprocessedSignalCount,
   getUnprocessedSignals: () => getUnprocessedSignals,
   initReflectionTables: () => initReflectionTables,
@@ -872,11 +873,13 @@ function initReflectionTables(db3) {
       backend TEXT,
       model TEXT,
       thinkingLevel TEXT,
+      skill_name TEXT,
       processedAt TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
     CREATE INDEX IF NOT EXISTS idx_signals_chat_time ON feedback_signals (chatId, created_at DESC);
     CREATE INDEX IF NOT EXISTS idx_signals_unprocessed ON feedback_signals (processedAt) WHERE processedAt IS NULL;
+    CREATE INDEX IF NOT EXISTS idx_signals_skill ON feedback_signals (skill_name) WHERE skill_name IS NOT NULL;
 
     CREATE TABLE IF NOT EXISTS insights (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -949,11 +952,17 @@ function initReflectionTables(db3) {
   cleanupReflectionData(db3);
   const settings = getReflectionSettings(db3, "global");
   cleanupBackupFiles(CC_CLAW_HOME, settings.backupRetentionDays);
+  try {
+    db3.prepare("SELECT skill_name FROM feedback_signals LIMIT 0").get();
+  } catch {
+    db3.exec("ALTER TABLE feedback_signals ADD COLUMN skill_name TEXT");
+    db3.exec("CREATE INDEX IF NOT EXISTS idx_signals_skill ON feedback_signals (skill_name) WHERE skill_name IS NOT NULL");
+  }
 }
 function logSignal(db3, params) {
   const result = db3.prepare(`
-    INSERT INTO feedback_signals (chatId, signalType, trigger, context, source, confidence, backend, model, thinkingLevel)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO feedback_signals (chatId, signalType, trigger, context, source, confidence, backend, model, thinkingLevel, skill_name)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     params.chatId,
     params.signalType,
@@ -963,7 +972,8 @@ function logSignal(db3, params) {
     params.confidence,
     params.backend ?? null,
     params.model ?? null,
-    params.thinkingLevel ?? null
+    params.thinkingLevel ?? null,
+    params.skillName ?? null
   );
   return Number(result.lastInsertRowid);
 }
@@ -1004,6 +1014,56 @@ function getLastAnalysisTime(db3, chatId) {
   `).get(chatId);
   return row.lastTime;
 }
+function getSkillCorrections(db3, windowDays = 30, minCorrections = 3) {
+  const skillRows = db3.prepare(`
+    SELECT
+      skill_name,
+      COUNT(*) AS cnt,
+      GROUP_CONCAT(context, '|||') AS contexts_raw
+    FROM feedback_signals
+    WHERE
+      signalType = 'correction'
+      AND skill_name IS NOT NULL
+      AND created_at >= datetime('now', '-' || ? || ' days')
+    GROUP BY skill_name
+    HAVING cnt >= ?
+    ORDER BY cnt DESC
+  `).all(windowDays, minCorrections);
+  if (skillRows.length === 0) return [];
+  const skillNames = skillRows.map((r) => r.skill_name);
+  const placeholders = skillNames.map(() => "?").join(", ");
+  const breakdownRows = db3.prepare(`
+    SELECT
+      skill_name,
+      model,
+      COUNT(*) AS cnt
+    FROM feedback_signals
+    WHERE
+      signalType = 'correction'
+      AND skill_name IN (${placeholders})
+      AND model IS NOT NULL
+      AND created_at >= datetime('now', '-' || ? || ' days')
+    GROUP BY skill_name, model
+    ORDER BY skill_name, cnt DESC
+  `).all(...skillNames, windowDays);
+  const breakdownMap = /* @__PURE__ */ new Map();
+  for (const row of breakdownRows) {
+    if (!breakdownMap.has(row.skill_name)) {
+      breakdownMap.set(row.skill_name, []);
+    }
+    breakdownMap.get(row.skill_name).push({ model: row.model, count: row.cnt });
+  }
+  return skillRows.map((row) => {
+    const rawContexts = row.contexts_raw ? row.contexts_raw.split("|||") : [];
+    const contexts = rawContexts.filter((c) => c && c.trim().length > 0);
+    return {
+      skillName: row.skill_name,
+      correctionCount: row.cnt,
+      contexts,
+      modelBreakdown: breakdownMap.get(row.skill_name) ?? []
+    };
+  });
+}
 function getReflectionStatus(db3, chatId) {
   const row = db3.prepare("SELECT status FROM chat_reflection WHERE chatId = ?").get(chatId);
   return row?.status ?? "frozen";
@@ -2009,6 +2069,12 @@ function initSchema(db3) {
       value INTEGER NOT NULL DEFAULT 0
     );
   `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS chat_pinned_skills (
+      chat_id TEXT PRIMARY KEY,
+      skills TEXT NOT NULL DEFAULT '[]'
+    );
+  `);
   db3.exec(`
     CREATE TABLE IF NOT EXISTS backend_credentials (
       id                 INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -2091,17 +2157,48 @@ function applySalienceDecay(db3) {
   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 _setSchemaDbGetter(getter) {
+  _getDb = getter;
+}
 function getMetaValue(key) {
-  const { getDb: getDb2 } = (init_store5(), __toCommonJS(store_exports5));
-  const db3 = getDb2();
+  if (!_getDb) throw new Error("[schema] DB getter not initialized \u2014 was _setSchemaDbGetter() called?");
+  const db3 = _getDb();
   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();
+  if (!_getDb) throw new Error("[schema] DB getter not initialized \u2014 was _setSchemaDbGetter() called?");
+  const db3 = _getDb();
   db3.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(key, value);
 }
+function getDisabledBackends() {
+  if (_disabledCache) return _disabledCache;
+  const json = getMetaValue(DISABLED_BACKENDS_KEY);
+  if (!json) {
+    _disabledCache = [];
+    return _disabledCache;
+  }
+  try {
+    _disabledCache = JSON.parse(json);
+    return _disabledCache;
+  } catch {
+    _disabledCache = [];
+    return _disabledCache;
+  }
+}
+function setBackendDisabled(backendId, disabled) {
+  const current = [...getDisabledBackends()];
+  if (disabled) {
+    if (!current.includes(backendId)) {
+      current.push(backendId);
+    }
+  } else {
+    const idx = current.indexOf(backendId);
+    if (idx !== -1) current.splice(idx, 1);
+  }
+  setMetaValue(DISABLED_BACKENDS_KEY, JSON.stringify(current));
+  _disabledCache = current;
+}
 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%')"
@@ -2125,6 +2222,7 @@ function backfillJobTitles(database) {
     database.prepare("UPDATE jobs SET title = ? WHERE id = ?").run(title, row.id);
   }
 }
+var _getDb, DISABLED_BACKENDS_KEY, _disabledCache;
 var init_schema = __esm({
   "src/memory/schema.ts"() {
     "use strict";
@@ -2135,6 +2233,9 @@ var init_schema = __esm({
     init_store4();
     init_log();
     init_classify();
+    _getDb = null;
+    DISABLED_BACKENDS_KEY = "disabled_backends";
+    _disabledCache = null;
   }
 });
 
@@ -2813,13 +2914,16 @@ __export(chat_settings_exports, {
   GLOBAL_SUMMARIZER_SENTINEL: () => GLOBAL_SUMMARIZER_SENTINEL,
   clearAgentMode: () => clearAgentMode,
   clearAllPaidSlots: () => clearAllPaidSlots,
+  clearAllSummarizerOverrides: () => clearAllSummarizerOverrides,
   clearChatPaidSlots: () => clearChatPaidSlots,
   clearCwd: () => clearCwd,
   clearExecMode: () => clearExecMode,
   clearModel: () => clearModel,
   clearModelMap: () => clearModelMap,
+  clearPinnedSkills: () => clearPinnedSkills,
   clearSummarizer: () => clearSummarizer,
   clearThinkingLevel: () => clearThinkingLevel,
+  countSummarizerOverrides: () => countSummarizerOverrides,
   deleteBookmark: () => deleteBookmark,
   determineEscalationTarget: () => determineEscalationTarget,
   findBookmarksByPrefix: () => findBookmarksByPrefix,
@@ -2835,11 +2939,13 @@ __export(chat_settings_exports, {
   getMode: () => getMode,
   getModel: () => getModel,
   getPendingEscalation: () => getPendingEscalation,
+  getPinnedSkills: () => getPinnedSkills,
   getRecentBookmarks: () => getRecentBookmarks,
   getSessionLogEnabled: () => getSessionLogEnabled,
   getShowThinkingUi: () => getShowThinkingUi,
   getSkillSuggestionsEnabled: () => getSkillSuggestionsEnabled,
   getSummarizer: () => getSummarizer,
+  getSummarizerWithSource: () => getSummarizerWithSource,
   getThinkingLevel: () => getThinkingLevel,
   getToolsMap: () => getToolsMap,
   getVerboseLevel: () => getVerboseLevel,
@@ -2853,6 +2959,7 @@ __export(chat_settings_exports, {
   setGlobalSummarizer: () => setGlobalSummarizer,
   setMode: () => setMode,
   setModel: () => setModel,
+  setPinnedSkills: () => setPinnedSkills,
   setSessionLogEnabled: () => setSessionLogEnabled,
   setShowThinkingUi: () => setShowThinkingUi,
   setSkillSuggestionsEnabled: () => setSkillSuggestionsEnabled,
@@ -3184,6 +3291,35 @@ function setSummarizer(chatId, backend2, model2) {
 function clearSummarizer(chatId) {
   getDb().prepare("DELETE FROM chat_summarizer WHERE chat_id = ?").run(chatId);
 }
+function clearAllSummarizerOverrides() {
+  const result = getDb().prepare(
+    "DELETE FROM chat_summarizer WHERE chat_id != ?"
+  ).run(GLOBAL_SUMMARIZER_SENTINEL);
+  return result.changes;
+}
+function getSummarizerWithSource(chatId) {
+  const perChat = getDb().prepare(
+    "SELECT backend, model FROM chat_summarizer WHERE chat_id = ?"
+  ).get(chatId);
+  const globalRow = getDb().prepare(
+    "SELECT backend, model FROM chat_summarizer WHERE chat_id = ?"
+  ).get(GLOBAL_SUMMARIZER_SENTINEL);
+  const hasPerChat = perChat && (perChat.backend || perChat.model);
+  const globalConfig = globalRow && (globalRow.backend || globalRow.model) ? globalRow : { backend: null, model: null };
+  if (hasPerChat) {
+    return { config: perChat, source: "per-chat", globalConfig };
+  }
+  if (globalConfig.backend || globalConfig.model) {
+    return { config: globalConfig, source: "global", globalConfig };
+  }
+  return { config: { backend: null, model: null }, source: "auto", globalConfig };
+}
+function countSummarizerOverrides() {
+  const row = getDb().prepare(
+    "SELECT COUNT(*) as cnt FROM chat_summarizer WHERE chat_id != ?"
+  ).get(GLOBAL_SUMMARIZER_SENTINEL);
+  return row.cnt;
+}
 function getAgentMode(chatId) {
   const row = getDb().prepare("SELECT mode FROM chat_agent_mode WHERE chat_id = ?").get(chatId);
   return row?.mode ?? "auto";
@@ -3233,6 +3369,27 @@ function toggleSessionLogEnabled(chatId) {
   setSessionLogEnabled(chatId, next);
   return next;
 }
+function getPinnedSkills(chatId) {
+  const row = getDb().prepare(
+    "SELECT skills FROM chat_pinned_skills WHERE chat_id = ?"
+  ).get(chatId);
+  if (!row?.skills) return [];
+  try {
+    return JSON.parse(row.skills);
+  } catch {
+    return [];
+  }
+}
+function setPinnedSkills(chatId, skills2) {
+  getDb().prepare(`
+    INSERT INTO chat_pinned_skills (chat_id, skills)
+    VALUES (?, ?)
+    ON CONFLICT(chat_id) DO UPDATE SET skills = ?
+  `).run(chatId, JSON.stringify(skills2), JSON.stringify(skills2));
+}
+function clearPinnedSkills(chatId) {
+  getDb().prepare("DELETE FROM chat_pinned_skills WHERE chat_id = ?").run(chatId);
+}
 function getAllowPaidSlots(chatId, backend2) {
   const row = getDb().prepare(
     "SELECT 1 FROM chat_allow_paid_slots WHERE chat_id = ? AND backend = ?"
@@ -3325,7 +3482,7 @@ function getUsage(chatId) {
 }
 function addUsage(chatId, input, output2, cacheRead, model2, backend2, contextSize) {
   const db3 = getDb();
-  const finalContextSize = contextSize ?? input + cacheRead;
+  const finalContextSize = contextSize === null ? 0 : contextSize ?? input + cacheRead;
   db3.prepare(`
     INSERT INTO chat_usage (chat_id, input_tokens, output_tokens, cache_read_tokens, request_count, last_input_tokens, last_cache_read_tokens, context_size, updated_at)
     VALUES (?, ?, ?, ?, 1, ?, ?, ?, datetime('now'))
@@ -3616,6 +3773,7 @@ __export(jobs_exports, {
   cancelJobById: () => cancelJobById,
   completeJobRun: () => completeJobRun,
   getActiveJobs: () => getActiveJobs,
+  getActiveJobsByBackend: () => getActiveJobsByBackend,
   getAllJobs: () => getAllJobs,
   getJobById: () => getJobById,
   getJobRuns: () => getJobRuns,
@@ -3623,6 +3781,7 @@ __export(jobs_exports, {
   insertJob: () => insertJob,
   insertJobRun: () => insertJobRun,
   pruneJobRuns: () => pruneJobRuns,
+  reassignJobsBackend: () => reassignJobsBackend,
   resetJobFailures: () => resetJobFailures,
   updateJob: () => updateJob,
   updateJobEnabled: () => updateJobEnabled,
@@ -3679,6 +3838,15 @@ function getActiveJobs() {
 function getAllJobs() {
   return getDb().prepare(`${JOB_SELECT} WHERE active = 1 ORDER BY id`).all().map((r) => mapJobRow(r));
 }
+function getActiveJobsByBackend(backendId) {
+  return getDb().prepare(`${JOB_SELECT} WHERE active = 1 AND enabled = 1 AND backend = ?`).all(backendId).map((r) => mapJobRow(r));
+}
+function reassignJobsBackend(fromBackend, toBackend) {
+  const result = getDb().prepare(
+    "UPDATE jobs SET backend = ? WHERE active = 1 AND enabled = 1 AND backend = ?"
+  ).run(toBackend, fromBackend);
+  return result.changes;
+}
 function updateJobEnabled(id, enabled) {
   const result = getDb().prepare("UPDATE jobs SET enabled = ? WHERE id = ?").run(enabled ? 1 : 0, id);
   return result.changes > 0;
@@ -4593,6 +4761,12 @@ var init_session_log = __esm({
 });
 
 // src/memory/api-context.ts
+var api_context_exports = {};
+__export(api_context_exports, {
+  buildApiMessages: () => buildApiMessages,
+  estimateContextUsage: () => estimateContextUsage,
+  estimateTokens: () => estimateTokens
+});
 import { getEncoding } from "js-tiktoken";
 function estimateTokens(text) {
   return enc.encode(text).length;
@@ -4621,7 +4795,7 @@ async function buildApiMessages(chatId, userMessage, systemPrompt, contextWindow
     return { role: "assistant", content: entry.text };
   });
   const currentUserMessage = { role: "user", content: userMessage };
-  const tokenBudget = Math.floor(contextWindow * 0.85);
+  const tokenBudget = Math.floor(contextWindow * 0.95);
   const fixedMessages = [systemMessage, currentUserMessage];
   const fixedTokens = fixedMessages.reduce((sum, m) => sum + enc.encode(typeof m.content === "string" ? m.content : JSON.stringify(m.content)).length, 0);
   const historyBudget = tokenBudget - fixedTokens;
@@ -4637,12 +4811,30 @@ async function buildApiMessages(chatId, userMessage, systemPrompt, contextWindow
   }
   return [systemMessage, ...truncatedHistory, currentUserMessage];
 }
-var enc;
+function estimateContextUsage(chatId, contextWindow) {
+  const logEntries = getLog(chatId);
+  if (logEntries.length === 0) {
+    estimateCache.delete(chatId);
+    return { estimatedTokens: 0, contextWindow, percentage: 0 };
+  }
+  const cached = estimateCache.get(chatId);
+  if (cached && cached.logSize === logEntries.length) {
+    const percentage2 = contextWindow > 0 ? cached.tokens / contextWindow * 100 : 0;
+    return { estimatedTokens: cached.tokens, contextWindow, percentage: percentage2 };
+  }
+  const text = logEntries.map((e) => e.text).join("\n");
+  const estimatedTokens = estimateTokens(text);
+  estimateCache.set(chatId, { logSize: logEntries.length, tokens: estimatedTokens });
+  const percentage = contextWindow > 0 ? estimatedTokens / contextWindow * 100 : 0;
+  return { estimatedTokens, contextWindow, percentage };
+}
+var enc, estimateCache;
 var init_api_context = __esm({
   "src/memory/api-context.ts"() {
     "use strict";
     init_session_log();
     enc = getEncoding("cl100k_base");
+    estimateCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -4838,6 +5030,7 @@ __export(store_exports5, {
   clearAgentMode: () => clearAgentMode,
   clearAllPaidSlots: () => clearAllPaidSlots,
   clearAllSessions: () => clearAllSessions,
+  clearAllSummarizerOverrides: () => clearAllSummarizerOverrides,
   clearBackendLimit: () => clearBackendLimit,
   clearChatBackendSlot: () => clearChatBackendSlot,
   clearChatGeminiSlot: () => clearChatGeminiSlot,
@@ -4847,11 +5040,13 @@ __export(store_exports5, {
   clearMessageLog: () => clearMessageLog,
   clearModel: () => clearModel,
   clearModelMap: () => clearModelMap,
+  clearPinnedSkills: () => clearPinnedSkills,
   clearSession: () => clearSession,
   clearSummarizer: () => clearSummarizer,
   clearThinkingLevel: () => clearThinkingLevel,
   clearUsage: () => clearUsage,
   completeJobRun: () => completeJobRun,
+  countSummarizerOverrides: () => countSummarizerOverrides,
   deleteBookmark: () => deleteBookmark,
   deleteMemoryById: () => deleteMemoryById,
   deleteSessionSummary: () => deleteSessionSummary,
@@ -4864,6 +5059,7 @@ __export(store_exports5, {
   forget: () => forget,
   forgetMemory: () => forgetMemory,
   getActiveJobs: () => getActiveJobs,
+  getActiveJobsByBackend: () => getActiveJobsByBackend,
   getActiveWatches: () => getActiveWatches,
   getAgentMode: () => getAgentMode,
   getAllBackendLimits: () => getAllBackendLimits,
@@ -4890,6 +5086,7 @@ __export(store_exports5, {
   getChatUsageByModel: () => getChatUsageByModel,
   getCwd: () => getCwd,
   getDb: () => getDb,
+  getDisabledBackends: () => getDisabledBackends,
   getEligibleBackendSlots: () => getEligibleBackendSlots,
   getEligibleGeminiSlots: () => getEligibleGeminiSlots,
   getEnabledTools: () => getEnabledTools,
@@ -4911,6 +5108,7 @@ __export(store_exports5, {
   getNextBackendSlot: () => getNextBackendSlot,
   getNextGeminiSlot: () => getNextGeminiSlot,
   getPendingEscalation: () => getPendingEscalation,
+  getPinnedSkills: () => getPinnedSkills,
   getRecentBookmarks: () => getRecentBookmarks,
   getRecentMemories: () => getRecentMemories,
   getRecentMessageLog: () => getRecentMessageLog,
@@ -4923,6 +5121,7 @@ __export(store_exports5, {
   getShowThinkingUi: () => getShowThinkingUi,
   getSkillSuggestionsEnabled: () => getSkillSuggestionsEnabled,
   getSummarizer: () => getSummarizer,
+  getSummarizerWithSource: () => getSummarizerWithSource,
   getThinkingLevel: () => getThinkingLevel,
   getToolsMap: () => getToolsMap,
   getUnsummarizedChatIds: () => getUnsummarizedChatIds,
@@ -4951,6 +5150,7 @@ __export(store_exports5, {
   pruneJobRuns: () => pruneJobRuns,
   pruneMessageLog: () => pruneMessageLog,
   queueHalfLifeExtension: () => queueHalfLifeExtension,
+  reassignJobsBackend: () => reassignJobsBackend,
   recall: () => recall,
   reenableBackendSlot: () => reenableBackendSlot,
   reenableSlot: () => reenableSlot,
@@ -4982,6 +5182,7 @@ __export(store_exports5, {
   setAgentMode: () => setAgentMode,
   setAllowPaidSlots: () => setAllowPaidSlots,
   setBackend: () => setBackend,
+  setBackendDisabled: () => setBackendDisabled,
   setBackendLimit: () => setBackendLimit,
   setBackendRotationMode: () => setBackendRotationMode,
   setBackendSlotEnabled: () => setBackendSlotEnabled,
@@ -4997,6 +5198,7 @@ __export(store_exports5, {
   setMode: () => setMode,
   setModel: () => setModel,
   setModelSignature: () => setModelSignature,
+  setPinnedSkills: () => setPinnedSkills,
   setResponseStyle: () => setResponseStyle,
   setSessionId: () => setSessionId,
   setSessionLogEnabled: () => setSessionLogEnabled,
@@ -5028,6 +5230,7 @@ function initDatabase() {
   db = new Database(DB_PATH);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
+  _setSchemaDbGetter(() => db);
   initSchema(db);
   startMaintenanceTimers(db);
 }
@@ -5043,6 +5246,7 @@ function getDb() {
 function _setDbForTesting(testDb) {
   db = testDb;
   _testDbPath = testDb.name;
+  _setSchemaDbGetter(() => db);
 }
 var db, _testDbPath;
 var init_store5 = __esm({
@@ -7559,6 +7763,52 @@ var init_html = __esm({
   }
 });
 
+// src/format-time.ts
+function formatLocalDate(utcDatetime) {
+  const d = parseUtcDatetime(utcDatetime);
+  if (!d) return utcDatetime.split("T")[0] ?? utcDatetime.split(" ")[0];
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function formatLocalDateTime(utcDatetime) {
+  const d = parseUtcDatetime(utcDatetime);
+  if (!d) return utcDatetime;
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const tzAbbr = getTimezoneAbbr(d);
+  return `${year}-${month}-${day} ${hours}:${minutes} ${tzAbbr}`;
+}
+function parseUtcDatetime(utcDatetime) {
+  if (!utcDatetime) return null;
+  const normalized = utcDatetime.includes("T") ? utcDatetime : utcDatetime.replace(" ", "T");
+  const withZ = normalized.endsWith("Z") ? normalized : normalized + "Z";
+  const d = new Date(withZ);
+  return isNaN(d.getTime()) ? null : d;
+}
+function getTimezoneAbbr(date) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: systemTimezone,
+      timeZoneName: "short"
+    }).formatToParts(date);
+    return parts.find((p) => p.type === "timeZoneName")?.value ?? "";
+  } catch {
+    return "";
+  }
+}
+var systemTimezone;
+var init_format_time = __esm({
+  "src/format-time.ts"() {
+    "use strict";
+    systemTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  }
+});
+
 // src/channels/telegram-throttle.ts
 var telegram_throttle_exports = {};
 __export(telegram_throttle_exports, {
@@ -7581,13 +7831,15 @@ function is429(err) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var PER_DM_INTERVAL_MS, PER_GROUP_INTERVAL_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES2, RETRY_DELAY_MS, MAX_QUEUE_SIZE, EDIT_PRESSURE_THRESHOLD, MAX_PER_CHAT_QUEUE, MAX_TOTAL_PAUSE_MS, CIRCUIT_TRIP_THRESHOLD, CIRCUIT_TRIP_WINDOW_MS, CIRCUIT_COOLDOWN_STEP_SEC, CIRCUIT_RESET_WINDOW_MS, CircuitState, Priority, _activeThrottle, TelegramThrottle;
+var PER_DM_INTERVAL_MS, PER_GROUP_INTERVAL_MS, P0_PACING_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES2, RETRY_DELAY_MS, MAX_QUEUE_SIZE, EDIT_PRESSURE_THRESHOLD, MAX_PER_CHAT_QUEUE, MAX_TOTAL_PAUSE_MS, CIRCUIT_TRIP_THRESHOLD, CIRCUIT_TRIP_WINDOW_MS, CIRCUIT_COOLDOWN_STEP_SEC, CIRCUIT_RESET_WINDOW_MS, CircuitState, Priority, _activeThrottle, TelegramThrottle;
 var init_telegram_throttle = __esm({
   "src/channels/telegram-throttle.ts"() {
     "use strict";
     init_log();
+    init_format_time();
     PER_DM_INTERVAL_MS = 1e3;
     PER_GROUP_INTERVAL_MS = 3500;
+    P0_PACING_MS = 150;
     GLOBAL_INTERVAL_MS = 100;
     MAX_RETRIES2 = 2;
     RETRY_DELAY_MS = 1e3;
@@ -7766,16 +8018,17 @@ var init_telegram_throttle = __esm({
           while (this.queue.length > 0) {
             while (this.isPaused()) {
               if (this.pauseStartedAt > 0 && Date.now() - this.pauseStartedAt > MAX_TOTAL_PAUSE_MS) {
-                warn(`[throttle] Max pause duration exceeded (${MAX_TOTAL_PAUSE_MS / 6e4}min), dropping ${this.queue.length} items`);
+                warn(`[throttle] Max pause duration exceeded (${MAX_TOTAL_PAUSE_MS / 6e4}min), dropping ${this.queue.length} items (pause remains until ${formatLocalDateTime(new Date(this.pausedUntil).toISOString())})`);
                 this.flushQueueWithError("Telegram rate limit exceeded max wait time");
-                this.pausedUntil = 0;
-                this.pauseStartedAt = 0;
                 break;
               }
               const waitMs = Math.min(this.pausedUntil - Date.now(), 5e3);
               if (waitMs > 0) await sleep(waitMs);
             }
             if (this.queue.length === 0) break;
+            if (!this.isPaused() && this.pauseStartedAt > 0) {
+              this.pauseStartedAt = 0;
+            }
             this.updateCircuitState();
             const item = this.selectNextItem();
             if (!item) {
@@ -7783,7 +8036,8 @@ var init_telegram_throttle = __esm({
               continue;
             }
             const lastChat = this.lastSendPerChat.get(item.chatId) ?? 0;
-            const chatWait = perChatInterval(item.chatId) - (Date.now() - lastChat);
+            const interval = item.priority === 0 /* P0_CRITICAL */ ? P0_PACING_MS : perChatInterval(item.chatId);
+            const chatWait = interval - (Date.now() - lastChat);
             if (chatWait > 0) await sleep(chatWait);
             const globalWait = GLOBAL_INTERVAL_MS - (Date.now() - this.lastGlobalSend);
             if (globalWait > 0) await sleep(globalWait);
@@ -7865,6 +8119,7 @@ var init_telegram_throttle = __esm({
             return await fn();
           } catch (err) {
             if (is429(err)) throw err;
+            if (err instanceof GrammyError && err.error_code >= 400 && err.error_code < 500) throw err;
             if (attempt < MAX_RETRIES2 && err instanceof GrammyError) {
               warn(`[throttle] ${label2} attempt ${attempt + 1}/${MAX_RETRIES2} failed (${err.error_code}), retrying`);
               await sleep(RETRY_DELAY_MS);
@@ -8606,6 +8861,70 @@ function buildHandoffContract() {
     "**Open questions:** Anything unresolved or needing the main agent's attention."
   ].join("\n");
 }
+function buildAgenticCore() {
+  return `## Task Execution
+
+- Implement rather than suggest unless the request is clearly read-only.
+- Read relevant files before answering questions about code or proposing changes. Do not propose changes to code you have not read.
+- Do not add features, refactor code, or make improvements beyond what was asked. A bug fix does not need surrounding code cleaned up. A simple feature does not need extra configurability.
+- Do not create helpers, utilities, or abstractions for one-time operations. Do not design for hypothetical future requirements. Three similar lines of code is better than a premature abstraction.
+- Do not add error handling, fallbacks, or validation for scenarios that cannot happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs).
+- Do not create files unless absolutely necessary. Prefer editing existing files over creating new ones.
+- Avoid backwards-compatibility hacks. If something is unused, delete it completely.
+- Be careful not to introduce security vulnerabilities (injection, XSS, SQL injection, OWASP top 10). If you write insecure code, fix it immediately.
+- You are highly capable. Defer to user judgement about whether a task is too large to attempt.
+
+## Action Safety
+
+Take local, reversible actions freely (editing files, running tests). For actions that are hard to reverse, affect shared systems, or could be destructive, confirm with the user before proceeding.
+
+Actions that require confirmation:
+- Destructive: deleting files/branches, dropping tables, rm -rf, overwriting uncommitted changes
+- Hard to reverse: force-pushing, git reset --hard, amending published commits, removing dependencies
+- Visible to others: pushing code, creating/commenting on PRs/issues, sending messages, posting to external services
+
+When encountering an obstacle, investigate root causes rather than using destructive actions as shortcuts. If you discover unexpected state (unfamiliar files, branches, configuration), investigate before deleting or overwriting \u2014 it may be the user's in-progress work.
+
+## Tool Usage
+
+- Call multiple tools in parallel when they have no dependencies between them. Maximize parallel tool calls for efficiency. Only use sequential calls when outputs feed inputs.
+- Never use placeholders or guess missing parameters.
+- For git operations: never amend published commits or force-push without explicit instruction.
+
+## Communication
+
+- Before your first tool call, state in one sentence what you are about to do.
+- While working, give short updates at key moments: when you find something, change direction, or hit a blocker. One sentence per update is enough.
+- End-of-turn summary: one or two sentences \u2014 what changed and what is next. Nothing else.
+- Match responses to the task: a simple question gets a direct answer, not headers and sections.
+- Do not narrate your internal reasoning, tool selection logic, or thought process. Only output the final answer.
+
+## Grounding
+
+- Never invent library APIs, file paths, CLI commands, or documentation you are not certain exist.
+- If uncertain, say so. Label inferences clearly: "Based on X, I expect Y" \u2014 not stated as fact.
+- Verify paths before acting. User paths are often approximate.`;
+}
+function buildFollowThrough() {
+  return `PERSISTENCE RULES:
+- Persist through the full lifecycle: gather context \u2192 plan \u2192 implement \u2192 verify \u2192 report.
+- Do not stop at analysis, partial fixes, or drafts.
+- Do not output a plan, status update, or progress summary as your final message.
+  If there is more work to do, do the work. A status message without a following
+  tool call will terminate your turn prematurely.
+- Only terminate your turn when you are sure the problem is fully solved.
+
+TOOL PERSISTENCE:
+- Do not stop early when another tool call would materially improve correctness or completeness.
+- Keep calling tools until: (1) the task is complete, and (2) verification passes.
+- If a tool returns empty, errors, or partial results \u2014 retry with a different strategy. Tool errors are not stop conditions.
+
+BIAS TO ACTION:
+- Default to implementing with reasonable assumptions rather than asking clarifying questions,
+  unless truly blocked on a detail that would change correctness or safety, or involves an
+  irreversible action.
+- Never stop after completing only part of the request.`;
+}
 var REAL_HOME, TASK_WORKER_SKILL_BUDGET;
 var init_shared = __esm({
   "src/bootstrap/templates/shared.ts"() {
@@ -8621,6 +8940,7 @@ var discover_exports = {};
 __export(discover_exports, {
   discoverAllSkills: () => discoverAllSkills,
   invalidateSkillCache: () => invalidateSkillCache,
+  parseFrontmatter: () => parseFrontmatter,
   resolveSkillForTask: () => resolveSkillForTask,
   stripFrontmatter: () => stripFrontmatter
 });
@@ -8693,7 +9013,8 @@ async function scanSkillDir(skillsDir, source) {
       contentHash: hash,
       type: frontmatter.type,
       status: frontmatter.status,
-      requires: frontmatter.requires
+      requires: frontmatter.requires,
+      triggers: frontmatter.triggers
     });
   }
   return results;
@@ -8725,7 +9046,8 @@ function mergeAndDeduplicate(raw) {
         contentHash: primary.contentHash,
         type: primary.type,
         status: primary.status,
-        requires: primary.requires
+        requires: primary.requires,
+        triggers: primary.triggers
       });
     } else {
       for (const [hash, copies] of byHash) {
@@ -8740,7 +9062,8 @@ function mergeAndDeduplicate(raw) {
           contentHash: hash,
           type: primary.type,
           status: primary.status,
-          requires: primary.requires
+          requires: primary.requires,
+          triggers: primary.triggers
         });
       }
     }
@@ -8760,7 +9083,8 @@ function parseFrontmatter(content, fallbackName, source) {
       description: "",
       type: "tool",
       status: source === "cc-claw" ? "imported" : "external",
-      requires: []
+      requires: [],
+      triggers: []
     };
   }
   const fm = fmMatch[1];
@@ -8786,12 +9110,21 @@ function parseFrontmatter(content, fallbackName, source) {
       if (cleaned2) requires.push(cleaned2);
     }
   }
+  const triggersMatch = fm.match(/^triggers:\s*\[([^\]]*)\]/m);
+  const triggers = [];
+  if (triggersMatch?.[1]) {
+    for (const item of triggersMatch[1].split(",")) {
+      const cleaned2 = strip(item);
+      if (cleaned2) triggers.push(cleaned2);
+    }
+  }
   return {
     name: nameMatch?.[1] ? strip(nameMatch[1]) : fallbackName,
     description: descMatch?.[1] ? strip(descMatch[1]) : "",
     type,
     status,
-    requires
+    requires,
+    triggers
   };
 }
 function stripFrontmatter(content) {
@@ -8802,9 +9135,9 @@ function resolveSkillForTask(skillName) {
   for (const candidate of SKILL_FILE_CANDIDATES3) {
     const skillPath = join9(SKILLS_PATH, skillName, candidate);
     try {
-      const { readFileSync: readFileSync35, existsSync: existsSync62 } = __require("fs");
+      const { readFileSync: readFileSync36, existsSync: existsSync62 } = __require("fs");
       if (!existsSync62(skillPath)) continue;
-      const raw = readFileSync35(skillPath, "utf-8");
+      const raw = readFileSync36(skillPath, "utf-8");
       const fm = parseFrontmatter(raw, skillName, "cc-claw");
       if (fm.status !== "approved") {
         log(`[skills] Skill "${skillName}" has status "${fm.status}" \u2014 only approved skills can be used as task worker identity`);
@@ -11267,6 +11600,12 @@ ${buildPlatformQuickReference()}
 
 ${buildToolUsageRules()}
 
+## Agentic Discipline
+${buildAgenticCore()}
+
+## Follow-Through
+${buildFollowThrough()}
+
 ## CC-Claw Constraints
 ${buildDatabaseSafetyBoundary()}
 - Do not invent library APIs or documentation you are not certain exists.
@@ -11298,28 +11637,13 @@ ${user}
 You are an autonomous agent \u2014 keep going until the user's request is completely
 resolved before ending your turn and yielding back to the user.
 
-PERSISTENCE RULES:
-- Persist through the full lifecycle: gather context \u2192 plan \u2192 implement \u2192 verify
-  \u2192 report. Do not stop at analysis, partial fixes, or drafts.
-- Do not output a plan, status update, or progress summary as your final message.
-  If there is more work to do, do the work. A status message without a following
-  tool call will terminate your turn prematurely.
-- Only terminate your turn when you are sure the problem is fully solved.
-
-TOOL PERSISTENCE:
-- Do not stop early when another tool call would materially improve correctness
-  or completeness.
-- Keep calling tools until: (1) the task is complete, and (2) verification passes.
-- If a tool returns empty, errors, or partial results \u2014 retry with a different
-  strategy. Tool errors are not stop conditions.
-
-BIAS TO ACTION:
-- Default to implementing with reasonable assumptions rather than asking
-  clarifying questions, unless truly blocked on a detail that would change
-  correctness or safety, or involves an irreversible action.
-- Never stop after completing only part of the request.
+${buildFollowThrough()}
 </default_follow_through_policy>
 
+<agentic_framework>
+${buildAgenticCore()}
+</agentic_framework>
+
 <output_contract>
 - Simple answers: 1-4 sentences in Telegram HTML, no preamble
 - Code tasks: show the change, explain what changed and why in 1-2 sentences
@@ -11384,18 +11708,15 @@ ${soul}
 ${user}
 </user_profile>
 
-<instructions>
-1. Implement rather than suggest unless the request is clearly read-only.
-2. Read relevant files before answering questions about code.
-3. Keep casual responses concise. Reserve detail for research, code, and complex tasks.
-4. Confirm before destructive actions (file deletion, force operations, external sends).
-5. Use cc-claw CLI or daemon HTTP API for state. Run \`cc-claw --ai\` when unsure.
-6. Verify paths before acting. User paths are often approximate.
-</instructions>
+<agentic_framework>
+${buildAgenticCore()}
+</agentic_framework>
+
+<follow_through_policy>
+${buildFollowThrough()}
+</follow_through_policy>
 
 <tool_guidance>
-Call multiple tools in parallel when they have no dependencies.
-Only make changes directly requested. Do not add features or refactor beyond what was asked.
 ${buildToolUsageRules()}
 </tool_guidance>
 
@@ -11423,6 +11744,138 @@ var init_cursor2 = __esm({
   }
 });
 
+// src/bootstrap/templates/api.ts
+function buildApiTemplate(soul, user) {
+  const date = getCurrentDate();
+  return `<role>
+You are the agent described below, operating via Telegram. Current date: ${date}.
+You are running as a direct API model \u2014 not a CLI tool like Claude Code or Gemini CLI.
+CC-Claw is your agentic harness: it provides your tools, memory, identity, and orchestration layer.
+Follow these system instructions precisely. They define how you operate.
+</role>
+
+<identity>
+${soul}
+</identity>
+
+<user_profile>
+${user}
+</user_profile>
+
+<agentic_framework>
+${buildAgenticCore()}
+</agentic_framework>
+
+<follow_through_policy>
+${buildFollowThrough()}
+</follow_through_policy>
+
+<tool_routing>
+## API Backend Tool Routing
+
+You have access to tools provided by CC-Claw via function calling. Use them directly by name.
+
+External CLI tools (gsearch, pwm, gws, gemcli, nlm, curl, python3, git, npm, cc-claw, etc.)
+are accessed ONLY via the \`restrictedBash\` tool. NEVER call external CLIs as direct tool
+names \u2014 they are not registered as native tools and will fail silently.
+
+Correct:   restrictedBash({"command": "gsearch \\"query\\" --type news"})
+Incorrect: gsearch({"query": "..."})  \u2190 this WILL FAIL
+
+If a skill or instruction says to use a CLI tool, always route it through restrictedBash.
+When unsure about available commands, run: restrictedBash({"command": "cc-claw --ai"})
+
+${buildCliEnvironment()}
+</tool_routing>
+
+<verification_loop>
+Before finalizing any response, silently check:
+1. Is this correct and complete?
+2. Is every factual claim grounded in something verified?
+3. Does the format match the output contract below?
+4. Are there any safety concerns with the actions taken?
+</verification_loop>
+
+<safety_boundary>
+${buildDatabaseSafetyBoundary()}
+${buildToolUsageRules()}
+</safety_boundary>
+
+<platform_reference>
+${buildSystemCapabilities()}
+${buildPlatformQuickReference()}
+</platform_reference>
+
+<output_format>
+Respond in Telegram HTML: <b>bold</b>, <code>inline</code>, <pre>blocks</pre>.
+No markdown formatting. No flattery openers. No pleasantries.
+Prose for conversation, structure only when the content requires it.
+Keep casual responses concise. Reserve detail for research, code, and complex tasks.
+</output_format>`;
+}
+var init_api = __esm({
+  "src/bootstrap/templates/api.ts"() {
+    "use strict";
+    init_shared();
+  }
+});
+
+// src/bootstrap/templates/api-task.ts
+function buildApiTaskTemplate() {
+  const date = getCurrentDate();
+  return `<role>
+You are a specialist task worker operating via CC-Claw. Current date: ${date}.
+Your identity and expertise are defined by the skill injected into your prompt.
+You are a direct API model \u2014 use restrictedBash for all external CLI tools.
+</role>
+
+<follow_through_policy>
+${buildFollowThrough()}
+</follow_through_policy>
+
+<operating_rules>
+${buildTaskWorkerRules()}
+</operating_rules>
+
+<tool_routing>
+External CLI tools are accessed ONLY via the restrictedBash tool.
+NEVER call external CLIs as direct tool names \u2014 they will fail silently.
+Correct:   restrictedBash({"command": "command here"})
+Incorrect: command({"arg": "..."})  \u2190 this WILL FAIL
+</tool_routing>
+
+<cli_environment>
+${buildCliEnvironment()}
+</cli_environment>
+
+<verification_loop>
+Before finalizing any response, silently check:
+1. Is this correct and complete?
+2. Is every factual claim grounded in something verified?
+3. Does the output match the task requirements?
+</verification_loop>
+
+<grounding_rules>
+Never invent library APIs, file paths, or documentation. If uncertain, say so.
+Verify paths before acting. User paths are often approximate.
+</grounding_rules>
+
+<safety_boundary>
+Confirm before: deleting files, posting to external services, database schema changes.
+Do not access ~/.cc-claw/data/cc-claw.db directly.
+</safety_boundary>
+
+<output_contract>
+${buildHandoffContract()}
+</output_contract>`;
+}
+var init_api_task = __esm({
+  "src/bootstrap/templates/api-task.ts"() {
+    "use strict";
+    init_shared();
+  }
+});
+
 // src/bootstrap/templates/claude-task.ts
 function buildClaudeTaskTemplate() {
   const date = getCurrentDate();
@@ -11481,26 +11934,7 @@ Your identity and expertise are defined by the skill injected into your prompt.
 You are an autonomous agent \u2014 keep going until the task is completely resolved
 before ending your turn and yielding back to the user.
 
-PERSISTENCE RULES:
-- Persist through the full lifecycle: gather context \u2192 plan \u2192 implement \u2192 verify
-  \u2192 report. Do not stop at analysis, partial fixes, or drafts.
-- Do not output a plan, status update, or progress summary as your final message.
-  If there is more work to do, do the work. A status message without a following
-  tool call will terminate your turn prematurely.
-- Only terminate your turn when you are sure the task is fully solved.
-
-TOOL PERSISTENCE:
-- Do not stop early when another tool call would materially improve correctness
-  or completeness.
-- Keep calling tools until: (1) the task is complete, and (2) verification passes.
-- If a tool returns empty, errors, or partial results \u2014 retry with a different
-  strategy. Tool errors are not stop conditions.
-
-BIAS TO ACTION:
-- Default to implementing with reasonable assumptions rather than asking
-  clarifying questions, unless truly blocked on a detail that would change
-  correctness or safety.
-- Never stop after completing only part of the task.
+${buildFollowThrough()}
 </default_follow_through_policy>
 
 <operating_rules>
@@ -11664,6 +12098,10 @@ function syncNativeCliFiles() {
   writeFileSync6(join14(IDENTITY_PATH, "CC-CLAW-codex.md"), codexContent, "utf-8");
   writeFileSync6(join14(WORKSPACE_PATH, "AGENTS.md"), codexContent, "utf-8");
   writeFileSync6(join14(IDENTITY_PATH, "CC-CLAW-cursor.md"), cursorContent, "utf-8");
+  const apiContent = buildApiTemplate(soul, user);
+  writeFileSync6(join14(IDENTITY_PATH, "CC-CLAW-api.md"), apiContent, "utf-8");
+  const apiTaskContent = buildApiTaskTemplate();
+  writeFileSync6(join14(IDENTITY_PATH, "CC-CLAW-api-task.md"), apiTaskContent, "utf-8");
   const fallbackContent = [
     "# CC-Claw System Instructions",
     "",
@@ -11686,7 +12124,7 @@ function syncNativeCliFiles() {
   const codexTaskContent = buildCodexTaskTemplate();
   writeFileSync6(join14(IDENTITY_PATH, "CC-CLAW-claude-task.md"), claudeTaskContent, "utf-8");
   writeFileSync6(join14(IDENTITY_PATH, "CC-CLAW-codex-task.md"), codexTaskContent, "utf-8");
-  log("[bootstrap] Synced identity files: CC-CLAW-claude.md, GEMINI.md, CC-CLAW-codex.md, CC-CLAW-cursor.md, CC-CLAW.md (fallback), CC-CLAW-claude-task.md, CC-CLAW-codex-task.md");
+  log("[bootstrap] Synced identity files: CC-CLAW-claude.md, GEMINI.md, CC-CLAW-codex.md, CC-CLAW-cursor.md, CC-CLAW-api.md, CC-CLAW-api-task.md, CC-CLAW.md (fallback), CC-CLAW-claude-task.md, CC-CLAW-codex-task.md");
 }
 var SOUL_PATH, USER_PATH, CONTEXT_DIR, LEGACY_SOUL_PATH, LEGACY_USER_PATH, LEGACY_CLAUDE_MD, LEGACY_GEMINI_MD;
 var init_init = __esm({
@@ -11698,6 +12136,8 @@ var init_init = __esm({
     init_gemini2();
     init_codex2();
     init_cursor2();
+    init_api();
+    init_api_task();
     init_claude_task();
     init_codex_task();
     init_shared();
@@ -11712,19 +12152,333 @@ var init_init = __esm({
   }
 });
 
-// src/bootstrap/loader.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync6 } from "fs";
-import { join as join15 } from "path";
-function tokenize(text) {
-  return new Set(
-    text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3)
-  );
+// src/intent/complexity.ts
+var complexity_exports = {};
+__export(complexity_exports, {
+  classifyComplexity: () => classifyComplexity
+});
+function wordCount(text) {
+  return text.trim().split(/\s+/).filter(Boolean).length;
+}
+function classifyComplexity(text) {
+  const trimmed = text.trim();
+  const lower = trimmed.toLowerCase();
+  const words = wordCount(trimmed);
+  if (TRIVIAL_EXACT.has(lower)) {
+    log(`[complexity] "${lower}" -> trivial (exact match)`);
+    return "trivial";
+  }
+  if (trimmed.length <= 4 && /^[\p{Emoji}\s]+$/u.test(trimmed)) {
+    log(`[complexity] "${trimmed}" -> trivial (emoji-only)`);
+    return "trivial";
+  }
+  if (COMPLEX_SIGNALS.test(trimmed) && (words > 15 || trimmed.length > 200)) {
+    log(`[complexity] "${trimmed.slice(0, 40)}..." -> complex (signal words + length)`);
+    return "complex";
+  }
+  if (MUTATION_VERBS.test(trimmed)) {
+    const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
+    log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (mutation verb)`);
+    return tier;
+  }
+  for (const pattern of CODE_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
+      log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (code pattern)`);
+      return tier;
+    }
+  }
+  if (trimmed.length > 200 || words > 25) {
+    const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
+    log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (long message)`);
+    return tier;
+  }
+  for (const pattern of QUESTION_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      log(`[complexity] "${trimmed.slice(0, 40)}..." -> simple (question)`);
+      return "simple";
+    }
+  }
+  log(`[complexity] "${trimmed.slice(0, 40)}..." -> moderate (default)`);
+  return "moderate";
+}
+var TRIVIAL_EXACT, COMPLEX_SIGNALS, MUTATION_VERBS, CODE_PATTERNS, QUESTION_PATTERNS;
+var init_complexity = __esm({
+  "src/intent/complexity.ts"() {
+    "use strict";
+    init_log();
+    TRIVIAL_EXACT = /* @__PURE__ */ new Set([
+      "hey",
+      "hi",
+      "hello",
+      "yo",
+      "sup",
+      "howdy",
+      "hiya",
+      "thanks",
+      "thank you",
+      "thx",
+      "ty",
+      "thank u",
+      "ok",
+      "okay",
+      "k",
+      "kk",
+      "cool",
+      "nice",
+      "great",
+      "awesome",
+      "perfect",
+      "good morning",
+      "good night",
+      "good evening",
+      "gm",
+      "gn",
+      "bye",
+      "goodbye",
+      "later",
+      "see ya",
+      "cya",
+      "lol",
+      "lmao",
+      "haha",
+      "heh",
+      "np",
+      "no problem",
+      "no worries",
+      "nw",
+      "got it",
+      "understood",
+      "roger",
+      "copy",
+      "good",
+      "fine",
+      "alright",
+      "sure",
+      "yes",
+      "no",
+      "yep",
+      "nope",
+      "yeah",
+      "nah"
+    ]);
+    COMPLEX_SIGNALS = /\b(architect|design|research|plan|strategy|migration|microservice|distributed|end-to-end|trade-offs|pros\s+and\s+cons)\b/i;
+    MUTATION_VERBS = /\b(fix|create|build|deploy|refactor|implement|write|add|update|edit|test|debug)\b/i;
+    CODE_PATTERNS = [
+      /```/,
+      // code blocks
+      /\.[a-z]{1,5}\b/,
+      // file extensions (.ts, .py, .json)
+      /[/\\][\w.-]+/
+      // file paths (/src/foo, .\bar)
+    ];
+    QUESTION_PATTERNS = [
+      /^(?:what|which|where|when|why|how)\b/i,
+      /^(?:show|tell|list|explain)\b/i,
+      /^(?:is|are)\b/i
+    ];
+  }
+});
+
+// src/skills/inject.ts
+import { readFileSync as readFileSync10 } from "fs";
+function setInjectedSkills(chatId, skillNames) {
+  injectedSkillsMap.set(chatId, skillNames);
+}
+function getAndClearInjectedSkills(chatId) {
+  const skills2 = injectedSkillsMap.get(chatId) ?? [];
+  injectedSkillsMap.delete(chatId);
+  return skills2;
 }
-function stripFrontmatter3(content) {
-  if (!content.startsWith("---")) return content;
-  const end = content.indexOf("---", 3);
-  return end === -1 ? content : content.slice(end + 3).trim();
+function shouldSkipInjection(userMessage, profile, userExplicitNative) {
+  if (userExplicitNative) return true;
+  if (profile === "minimal") return true;
+  const complexity = classifyComplexity(userMessage);
+  return SKIP_COMPLEXITY.has(complexity);
+}
+function scoreSkills(userMessage, skills2) {
+  const msgWords = tokenize(userMessage);
+  const msgWordsAll = tokenizeAll(userMessage);
+  if (msgWordsAll.size === 0) return [];
+  const results = [];
+  for (const skill of skills2) {
+    if (skill.status !== "approved" && skill.status !== "imported") continue;
+    let score = 0;
+    const triggerWords = new Set(skill.triggers.map((t) => t.toLowerCase()));
+    for (const word of msgWordsAll) {
+      if (triggerWords.has(word)) score += 2;
+    }
+    const metaWords = tokenize([skill.name, skill.description].join(" "));
+    for (const word of msgWords) {
+      if (metaWords.has(word) && !STOPWORDS.has(word)) score++;
+    }
+    if (score >= MIN_SCORE) {
+      results.push({ name: skill.name, score, filePath: skill.filePath, requires: skill.requires });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+function formatSkillBlock(skills2, budgetChars = TOTAL_BUDGET_CHARS) {
+  if (skills2.length === 0) return null;
+  const lines = ["[Skill context]"];
+  let totalChars = 0;
+  for (const skill of skills2) {
+    let content = skill.content;
+    const remaining = budgetChars - totalChars;
+    if (remaining <= 0) break;
+    if (content.length > remaining) {
+      content = content.slice(0, remaining) + "\n\u2026(truncated)";
+    }
+    lines.push(`## ${skill.name}`);
+    lines.push(content);
+    lines.push("");
+    totalChars += content.length;
+  }
+  lines.push("[End skill context]");
+  return lines.join("\n");
 }
+function loadWithDeps(skill, allSkills, usedNames, entries, charsSoFar, charCap) {
+  const content = readSkillContent(skill.filePath);
+  if (!content) return charsSoFar;
+  if (charsSoFar + content.length > charCap) return charsSoFar;
+  entries.push({ name: skill.name, content });
+  usedNames.add(skill.name);
+  let chars = charsSoFar + content.length;
+  for (const dep of skill.requires) {
+    if (usedNames.has(dep)) continue;
+    const depSkill = allSkills.find((s) => s.name === dep);
+    if (!depSkill) continue;
+    const depContent = readSkillContent(depSkill.filePath);
+    if (!depContent) continue;
+    if (chars + depContent.length > charCap) continue;
+    entries.push({ name: depSkill.name, content: depContent });
+    usedNames.add(depSkill.name);
+    chars += depContent.length;
+  }
+  return chars;
+}
+function injectSkillContext(userMessage, allSkills, pinnedSkillNames, profile, userExplicitNative, chatId) {
+  const hasPins = pinnedSkillNames.length > 0;
+  const skipAuto = shouldSkipInjection(userMessage, profile, userExplicitNative);
+  if (!hasPins && skipAuto) return null;
+  const entries = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  let pinnedChars = 0;
+  for (const name of pinnedSkillNames) {
+    if (usedNames.has(name)) continue;
+    const skill = allSkills.find((s) => s.name === name);
+    if (!skill) continue;
+    pinnedChars = loadWithDeps(skill, allSkills, usedNames, entries, pinnedChars, PINNED_BUDGET_CHARS);
+  }
+  if (!skipAuto) {
+    const scored = scoreSkills(userMessage, allSkills);
+    let autoChars = 0;
+    for (const match of scored) {
+      if (usedNames.has(match.name)) continue;
+      const skill = allSkills.find((s) => s.name === match.name);
+      if (!skill) continue;
+      autoChars = loadWithDeps(skill, allSkills, usedNames, entries, autoChars, AUTO_BUDGET_CHARS);
+    }
+  }
+  if (entries.length === 0) return null;
+  const injectedNames = entries.map((e) => e.name);
+  if (chatId) {
+    setInjectedSkills(chatId, injectedNames);
+  }
+  log(`[skills] Injected ${injectedNames.length} skill(s): ${injectedNames.join(", ")}`);
+  return formatSkillBlock(entries);
+}
+function readSkillContent(filePath) {
+  try {
+    const raw = readFileSync10(filePath, "utf-8");
+    return stripFrontmatter(raw);
+  } catch {
+    return null;
+  }
+}
+var AUTO_BUDGET_CHARS, PINNED_BUDGET_CHARS, TOTAL_BUDGET_CHARS, MIN_SCORE, injectedSkillsMap, SKIP_COMPLEXITY, STOPWORDS, tokenize, tokenizeAll;
+var init_inject2 = __esm({
+  "src/skills/inject.ts"() {
+    "use strict";
+    init_complexity();
+    init_discover();
+    init_text_utils();
+    init_log();
+    AUTO_BUDGET_CHARS = 3e3;
+    PINNED_BUDGET_CHARS = 5e3;
+    TOTAL_BUDGET_CHARS = 8e3;
+    MIN_SCORE = 2;
+    injectedSkillsMap = /* @__PURE__ */ new Map();
+    SKIP_COMPLEXITY = /* @__PURE__ */ new Set(["trivial", "simple"]);
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "about",
+      "after",
+      "also",
+      "been",
+      "before",
+      "being",
+      "between",
+      "both",
+      "could",
+      "does",
+      "doing",
+      "done",
+      "down",
+      "during",
+      "each",
+      "even",
+      "every",
+      "from",
+      "have",
+      "having",
+      "help",
+      "here",
+      "into",
+      "just",
+      "know",
+      "like",
+      "make",
+      "more",
+      "most",
+      "much",
+      "need",
+      "only",
+      "other",
+      "over",
+      "some",
+      "such",
+      "than",
+      "that",
+      "their",
+      "them",
+      "then",
+      "there",
+      "these",
+      "they",
+      "this",
+      "through",
+      "very",
+      "want",
+      "well",
+      "were",
+      "what",
+      "when",
+      "where",
+      "which",
+      "while",
+      "will",
+      "with",
+      "would",
+      "your"
+    ]);
+    tokenize = (text) => tokenizeText(text, 4);
+    tokenizeAll = (text) => tokenizeText(text, 1);
+  }
+});
+
+// src/bootstrap/loader.ts
+import { readFileSync as readFileSync11, readdirSync as readdirSync6 } from "fs";
+import { join as join15 } from "path";
 function loadMarkdownDir(dir, cacheRef, wordSource = (c) => c) {
   if (cacheRef.v && Date.now() - cacheRef.v.timestamp < CACHE_TTL_MS4) {
     return cacheRef.v.files;
@@ -11734,8 +12488,8 @@ function loadMarkdownDir(dir, cacheRef, wordSource = (c) => c) {
     for (const entry of readdirSync6(dir)) {
       if (!entry.endsWith(".md")) continue;
       try {
-        const content = readFileSync10(join15(dir, entry), "utf-8").trim();
-        if (content) files.set(entry, { content, words: tokenize(wordSource(content)) });
+        const content = readFileSync11(join15(dir, entry), "utf-8").trim();
+        if (content) files.set(entry, { content, words: tokenize2(wordSource(content)) });
       } catch {
         continue;
       }
@@ -11746,7 +12500,7 @@ function loadMarkdownDir(dir, cacheRef, wordSource = (c) => c) {
   return files;
 }
 function findBestMatch(userMessage, files, opts) {
-  const msgWords = tokenize(userMessage);
+  const msgWords = tokenize2(userMessage);
   if (msgWords.size === 0) return null;
   let best = null;
   for (const entry of files.values()) {
@@ -11769,16 +12523,6 @@ function searchContext(userMessage) {
     { maxChars: MAX_CONTEXT_CHARS }
   );
 }
-function searchSkill(userMessage) {
-  return findBestMatch(
-    userMessage,
-    loadMarkdownDir(SKILLS_DIR, skillCacheRef, stripFrontmatter3),
-    {
-      maxChars: MAX_SKILL_CHARS,
-      filter: ({ content }) => content.includes("status: approved") || content.includes("status: imported")
-    }
-  );
-}
 async function assembleBootstrapPrompt(userMessage, entityType = "main", profile = "interactive", chatId, permMode, responseStyle, agentMode, sideQuestContext, planningDirective, chatContext, backendType) {
   const sections = [];
   if (planningDirective) {
@@ -11792,15 +12536,24 @@ async function assembleBootstrapPrompt(userMessage, entityType = "main", profile
     sections.push(buildPermissionNotice(permMode));
   }
   if (backendType === "api") {
-    sections.push(`[API Backend \u2014 Tool Usage]
+    if (!apiHarnessCache.main || Date.now() - apiHarnessCache.cachedMs > 5e3) {
+      try {
+        apiHarnessCache.main = readFileSync11(join15(IDENTITY_PATH, "CC-CLAW-api.md"), "utf-8");
+        apiHarnessCache.task = readFileSync11(join15(IDENTITY_PATH, "CC-CLAW-api-task.md"), "utf-8");
+        apiHarnessCache.cachedMs = Date.now();
+      } catch {
+      }
+    }
+    const harness = entityType === "task" ? apiHarnessCache.task : apiHarnessCache.main;
+    if (harness) {
+      sections.push(harness);
+    } else {
+      warn("[bootstrap] API harness files not yet generated, using fallback");
+      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.
-
+External tools are accessed ONLY via the \`restrictedBash\` tool. NEVER call external CLIs as direct tool names.
 ${buildCliEnvironment()}`);
+    }
   }
   if (responseStyle) {
     if (responseStyle === "concise") {
@@ -11830,10 +12583,23 @@ ${ctx}`);
     }
   }
   if (profile === "interactive" || profile === "chat") {
-    const skill = searchSkill(userMessage);
-    if (skill) {
-      sections.push(`[Relevant skill]
-${skill}`);
+    const pinnedSkills = chatId ? getPinnedSkills(chatId) : [];
+    const userExplicitNative = agentMode === "native" && !sideQuestContext;
+    try {
+      const allSkills = await discoverAllSkills();
+      const skillBlock = injectSkillContext(
+        userMessage,
+        allSkills,
+        pinnedSkills,
+        profile,
+        userExplicitNative,
+        chatId
+      );
+      if (skillBlock) {
+        sections.push(skillBlock);
+      }
+    } catch (err) {
+      warn(`[bootstrap] Skill injection failed: ${err instanceof Error ? err.message : err}`);
     }
   }
   if (chatId && profile !== "minimal" && profile !== "chat") {
@@ -12001,7 +12767,7 @@ ${parts.join("\n")}${MEMORY_DISCIPLINE}`;
   }
   return null;
 }
-var lastSyncMs, CONTEXT_DIR2, SKILLS_DIR, MAX_CONTEXT_CHARS, MAX_SKILL_CHARS, CACHE_TTL_MS4, contextCacheRef, skillCacheRef, ACTIVITY_TOKEN_BUDGET, INBOX_TOKEN_BUDGET, WHITEBOARD_TOKEN_BUDGET;
+var lastSyncMs, apiHarnessCache, CONTEXT_DIR2, SKILLS_DIR, MAX_CONTEXT_CHARS, CACHE_TTL_MS4, tokenize2, contextCacheRef, ACTIVITY_TOKEN_BUDGET, INBOX_TOKEN_BUDGET, WHITEBOARD_TOKEN_BUDGET;
 var init_loader2 = __esm({
   "src/bootstrap/loader.ts"() {
     "use strict";
@@ -12014,14 +12780,22 @@ var init_loader2 = __esm({
     init_store5();
     init_store();
     init_backends();
+    init_inject2();
+    init_discover();
+    init_chat_settings();
+    init_text_utils();
     lastSyncMs = 0;
+    apiHarnessCache = {
+      main: null,
+      task: null,
+      cachedMs: 0
+    };
     CONTEXT_DIR2 = join15(WORKSPACE_PATH, "context");
     SKILLS_DIR = join15(WORKSPACE_PATH, "skills");
     MAX_CONTEXT_CHARS = 4e3;
-    MAX_SKILL_CHARS = 6e3;
     CACHE_TTL_MS4 = 3e4;
+    tokenize2 = (text) => tokenizeText(text, 4);
     contextCacheRef = { v: null };
-    skillCacheRef = { v: null };
     ACTIVITY_TOKEN_BUDGET = 1500;
     INBOX_TOKEN_BUDGET = 2e3;
     WHITEBOARD_TOKEN_BUDGET = 500;
@@ -12056,7 +12830,8 @@ __export(client_exports, {
   listModels: () => listModels,
   ping: () => ping,
   runningModels: () => runningModels,
-  showModel: () => showModel
+  showModel: () => showModel,
+  unloadModel: () => unloadModel
 });
 function buildHeaders(apiKey) {
   const headers = {
@@ -12142,6 +12917,30 @@ async function deleteModel(baseUrl, modelName, opts) {
     clearTimeout(timeout);
   }
 }
+async function unloadModel(baseUrl, modelName, opts) {
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    opts?.timeoutMs ?? 5e3
+    // short timeout — unload is best-effort
+  );
+  try {
+    const res = await fetch(`${baseUrl}/api/generate`, {
+      method: "POST",
+      headers: buildHeaders(opts?.apiKey),
+      body: JSON.stringify({ model: modelName, keep_alive: 0 }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Ollama unload failed (${res.status}): ${body}`);
+    }
+    await res.text().catch(() => {
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 async function listModels(baseUrl, opts) {
   const res = await fetch(`${baseUrl}/api/tags`, {
     signal: opts?.signal,
@@ -12829,7 +13628,9 @@ __export(service_exports, {
   isAnyServerOnline: () => isAnyServerOnline,
   listServers: () => listServers2,
   removeServer: () => removeServer2,
-  runQualityGateTest: () => runQualityGateTest
+  runQualityGateTest: () => runQualityGateTest,
+  tryUnloadModel: () => tryUnloadModel,
+  unloadModel: () => unloadModel2
 });
 function addServer2(name, host, port = 11434, apiKey) {
   const existing = getServer(name);
@@ -13019,6 +13820,17 @@ function getServerForModel(modelName) {
     apiKey: server.apiKey
   };
 }
+async function unloadModel2(modelName) {
+  const serverInfo = getServerForModel(modelName);
+  if (!serverInfo) return;
+  await unloadModel(serverInfo.baseUrl, modelName, { apiKey: serverInfo.apiKey });
+  log(`[ollama] Unloaded model: ${modelName}`);
+}
+function tryUnloadModel(modelName) {
+  unloadModel2(modelName).catch((err) => {
+    warn(`[ollama] Model unload failed for ${modelName}: ${err}`);
+  });
+}
 function extractContextWindow(show) {
   const info = show.model_info ?? {};
   for (const key of Object.keys(info)) {
@@ -13382,7 +14194,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
           const cap = getOllamaTranscriptCap(ollamaModel);
           const key = `${ollamaAdapter.id}:${ollamaModel}`;
           tried.add(key);
-          const directFn = (prompt) => ollamaAdapter.streamDirect(prompt, ollamaModel);
+          const directFn = (prompt) => ollamaAdapter.streamDirect(prompt, ollamaModel, { thinkingLevel: "off" });
           const result = await attemptSummarizeDirect(chatId, directFn, "ollama", ollamaModel, entries, cap);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, "ollama", ollamaModel);
@@ -13400,7 +14212,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         const key = `${targetAdapter.id}:${model2}`;
         if (!tried.has(key)) {
           tried.add(key);
-          const result = targetAdapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => targetAdapter.streamDirect(p, model2), targetAdapter.id, model2, entries, getTranscriptCap(model2)) : await attemptSummarize(chatId, targetAdapter, model2, entries);
+          const result = targetAdapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => targetAdapter.streamDirect(p, model2, { thinkingLevel: "off" }), targetAdapter.id, model2, entries, getTranscriptCap(model2)) : await attemptSummarize(chatId, targetAdapter, model2, entries);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, targetAdapter.id, model2);
             if (clearLogAfter) clearLog(chatId);
@@ -13418,7 +14230,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         const key = `${adapter.id}:${model2}`;
         if (!tried.has(key)) {
           tried.add(key);
-          const result = adapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => adapter.streamDirect(p, model2), adapter.id, model2, entries, adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2)) : await attemptSummarize(chatId, adapter, model2, entries);
+          const result = adapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => adapter.streamDirect(p, model2, { thinkingLevel: "off" }), adapter.id, model2, entries, adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2)) : await attemptSummarize(chatId, adapter, model2, entries);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, adapter.id, model2);
             if (clearLogAfter) clearLog(chatId);
@@ -13440,7 +14252,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         let result;
         if (adapter.streamDirect) {
           const cap = adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2);
-          const directFn = (prompt) => adapter.streamDirect(prompt, model2);
+          const directFn = (prompt) => adapter.streamDirect(prompt, model2, { thinkingLevel: "off" });
           result = await attemptSummarizeDirect(chatId, directFn, adapter.id, model2, entries, cap);
         } else {
           result = await attemptSummarize(chatId, adapter, model2, entries);
@@ -13817,6 +14629,7 @@ function classifyReaction(emoji) {
   return null;
 }
 async function detectAndLogSignals(chatId, userMessage, agentResponse, ctx = {}) {
+  const injectedSkills = getAndClearInjectedSkills(chatId);
   const db3 = getDb();
   const status = getReflectionStatus(db3, chatId);
   if (status === "frozen") return;
@@ -13824,18 +14637,29 @@ async function detectAndLogSignals(chatId, userMessage, agentResponse, ctx = {})
   if (recentCount >= RATE_LIMIT_MAX_SIGNALS) return;
   const signals = classifySignals(userMessage, agentResponse);
   const context = agentResponse.slice(0, 500) || null;
+  const uniqueByType = /* @__PURE__ */ new Map();
   for (const signal of signals) {
-    logSignal(db3, {
-      chatId,
-      signalType: signal.signalType,
-      trigger: signal.trigger,
-      context,
-      source: signal.source,
-      confidence: signal.confidence,
-      backend: ctx.backendId ?? null,
-      model: ctx.model ?? null,
-      thinkingLevel: ctx.thinkingLevel ?? null
-    });
+    const existing = uniqueByType.get(signal.signalType);
+    if (!existing || signal.confidence > existing.confidence) {
+      uniqueByType.set(signal.signalType, signal);
+    }
+  }
+  const skillList = injectedSkills.length > 0 ? injectedSkills : [void 0];
+  for (const signal of uniqueByType.values()) {
+    for (const skillName of skillList) {
+      logSignal(db3, {
+        chatId,
+        signalType: signal.signalType,
+        trigger: signal.trigger,
+        context,
+        source: signal.source,
+        confidence: signal.confidence,
+        backend: ctx.backendId ?? null,
+        model: ctx.model ?? null,
+        thinkingLevel: ctx.thinkingLevel ?? null,
+        skillName
+      });
+    }
   }
 }
 function logReactionSignal(chatId, emoji) {
@@ -13878,6 +14702,7 @@ var init_detect = __esm({
     "use strict";
     init_store4();
     init_store5();
+    init_inject2();
     CORRECTION_PATTERNS = [
       // Audit O36: Tightened — require "no" followed by correction context (not "No problem", "No worries")
       /^no[,.\s!]+\s*(that'?s|it'?s|i\s|you|this|the|not|don'?t|stop|wrong)/i,
@@ -13953,6 +14778,19 @@ function killProcessGroup(proc, signal = "SIGTERM") {
     }
   }
 }
+function runCompaction(chatId, reason, onCompaction) {
+  return summarizeWithFallbackChain(chatId).then((saved) => {
+    if (saved) {
+      return withChatLock(chatId, async () => {
+        clearSession(chatId);
+        clearUsage(chatId);
+        onCompaction?.(chatId);
+      });
+    }
+  }).catch((err) => {
+    warn(`[agent] Compaction failed for ${chatId} (${reason}): ${err}`);
+  });
+}
 function sweepStaleChatEntries() {
   for (const [chatId, state] of activeChats) {
     if (state.process && state.process.exitCode !== null) {
@@ -14010,6 +14848,13 @@ function stopAgent(chatId) {
       if (state.process) killProcessGroup(state.process, "SIGKILL");
     }, 2e3);
   }
+  const modelToUnload = state.model;
+  if (state.backendId === "ollama" && modelToUnload) {
+    Promise.resolve().then(() => (init_ollama(), ollama_exports)).then(({ OllamaService }) => {
+      OllamaService.tryUnloadModel(modelToUnload);
+    }).catch(() => {
+    });
+  }
   return true;
 }
 function getGeminiFallback(model2) {
@@ -14021,7 +14866,8 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     const thinkingConfig = thinkingLevel && thinkingLevel !== "auto" ? adapter.applyThinkingConfig(thinkingLevel, model2) : void 0;
     const env = opts?.envOverride ? thinkingConfig?.envOverrides ? { ...opts.envOverride, ...thinkingConfig.envOverrides } : opts.envOverride : adapter.getEnv(thinkingConfig?.envOverrides);
     const finalArgs = thinkingConfig?.extraArgs ? [...config2.args, ...thinkingConfig.extraArgs] : config2.args;
-    log(`[agent:spawn] backend=${adapter.id} exe=${config2.executable} model=${model2} timeout=${effectiveTimeout / 1e3}s cwd=${config2.cwd ?? "(inherited)"}`);
+    const hasResume = finalArgs.includes("--resume");
+    log(`[agent:spawn] backend=${adapter.id} exe=${config2.executable} model=${model2} timeout=${effectiveTimeout / 1e3}s resume=${hasResume} cwd=${config2.cwd ?? "(inherited)"}`);
     const stdinMode = adapter.id === "codex" ? "pipe" : "ignore";
     const proc = spawn4(config2.executable, finalArgs, {
       env,
@@ -14130,7 +14976,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
       for (const ev of events) {
         switch (ev.type) {
           case "init":
-            log(`[agent] Session init at ${elapsed()}`);
+            log(`[agent] Session init at ${elapsed()} sessionId=${ev.sessionId ?? "(none)"}`);
             if (ev.sessionId) sessionId = ev.sessionId;
             resetContentSilenceTimer();
             break;
@@ -14228,7 +15074,6 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
               input += ev.usage.input;
               output2 += ev.usage.output;
               cacheRead += ev.usage.cacheRead;
-              contextSize = ev.usage.input + (ev.usage.cacheRead ?? 0);
             }
             break;
           case "result":
@@ -14246,7 +15091,6 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
               input = ev.usage.input;
               output2 = ev.usage.output;
               cacheRead = ev.usage.cacheRead;
-              contextSize = ev.usage.input + (ev.usage.cacheRead ?? 0);
             }
             if (adapter.shouldKillOnResult()) {
               try {
@@ -14329,7 +15173,8 @@ Partial output: ${accumulatedText.slice(-500)}`;
         return;
       }
       const cleanedResult = stripThinkingContent(resultText || accumulatedText);
-      resolve3({ resultText: cleanedResult, thinkingText: accumulatedThinking, sessionId, input, output: output2, cacheRead, contextSize, sawToolEvents, sawResultEvent });
+      log(`[agent:spawn] Resolving: sessionId=${sessionId ?? "(none)"} hasText=${!!cleanedResult} code=${code}`);
+      resolve3({ resultText: cleanedResult, thinkingText: accumulatedThinking, sessionId, input, output: output2, cacheRead, contextSize: null, sawToolEvents, sawResultEvent });
     });
   });
 }
@@ -14537,20 +15382,23 @@ async function askAgentImpl(chatId, userMessage, opts) {
   const responseStyle = getResponseStyle(settingsChat);
   const thinkingLevel = opts?.thinkingLevel ?? getThinkingLevel(settingsChat);
   const resolvedCwd = cwd ?? WORKSPACE_PATH;
-  const { entityType, bootstrapProfile: profile } = optsEntityType && optsProfile ? { entityType: optsEntityType, bootstrapProfile: optsProfile } : resolveFromLegacyTier(bootstrapTier ?? "full");
+  const { entityType, bootstrapProfile: profile } = optsEntityType && optsProfile ? { entityType: optsEntityType, bootstrapProfile: optsProfile } : optsProfile ? { entityType: "main", bootstrapProfile: optsProfile } : resolveFromLegacyTier(bootstrapTier ?? "full");
   const effectiveAgentMode = optsAgentMode ?? getAgentMode(settingsChat);
   const sideQuestCtx = settingsSourceChatId ? { parentChatId: settingsSourceChatId, actualChatId: chatId } : void 0;
   const fullPrompt = await assembleBootstrapPrompt(userMessage, entityType, profile, settingsChat, mode, responseStyle, effectiveAgentMode, sideQuestCtx, planningDirective, opts?.chatContext, adapter.type);
   if (adapter.streamDirect) {
     const resolvedModel2 = model2 ?? adapter.defaultModel;
     const abortController = new AbortController();
-    const cancelState2 = { cancelled: false, userMessage, abortController };
+    const cancelState2 = { cancelled: false, userMessage, abortController, backendId: adapter.id, model: resolvedModel2 };
     activeChats.set(chatId, cancelState2);
     try {
       let messageHistory;
+      let apiContextSize;
       if (adapter.type === "api") {
         const contextWindow = adapter.contextWindow[resolvedModel2] ?? 8192;
-        messageHistory = await buildApiMessages(chatId, userMessage, fullPrompt, contextWindow);
+        const { buildApiMessages: buildMsgs, estimateContextUsage: estimateContextUsage2 } = await Promise.resolve().then(() => (init_api_context(), api_context_exports));
+        messageHistory = await buildMsgs(chatId, userMessage, fullPrompt, contextWindow);
+        apiContextSize = estimateContextUsage2(chatId, contextWindow).estimatedTokens;
       }
       const sdResult = await adapter.streamDirect(fullPrompt, resolvedModel2, {
         timeoutMs: timeoutMs ?? 3e5,
@@ -14566,23 +15414,29 @@ async function askAgentImpl(chatId, userMessage, opts) {
       });
       if (!isSyntheticChatId(chatId)) {
         appendToLog(chatId, userMessage, sdResult.text, adapter.id, resolvedModel2, null);
-        const AUTO_SUMMARIZE_THRESHOLD = 30;
-        const pairCount = profile !== "chat" ? getMessagePairCount(chatId) : 0;
-        if (pairCount >= AUTO_SUMMARIZE_THRESHOLD) {
-          log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
-          summarizeWithFallbackChain(chatId).then((saved) => {
-            if (saved) {
-              clearSession(chatId);
-              opts?.onCompaction?.(chatId);
-            }
-          }).catch((err) => {
-            warn(`[agent] Auto-summarize failed for chat ${chatId}: ${err}`);
-          });
+        if (apiContextSize && adapter.type === "api" && !compactionInFlight.has(chatId)) {
+          const contextWindow = adapter.contextWindow[resolvedModel2] ?? 8192;
+          const contextPct = apiContextSize / contextWindow * 100;
+          if (contextPct >= 85) {
+            compactionInFlight.add(chatId);
+            log(`[agent] Context at ${contextPct.toFixed(0)}% for ${chatId} \u2014 triggering background compaction`);
+            opts?.onCompaction?.(chatId, "triggered");
+            runCompaction(chatId, "context-85%", opts?.onCompaction).finally(() => {
+              compactionInFlight.delete(chatId);
+            });
+          }
+        }
+        if (adapter.type !== "api" || !compactionInFlight.has(chatId)) {
+          const pairCount = profile !== "chat" ? getMessagePairCount(chatId) : 0;
+          if (pairCount >= 30) {
+            log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
+            runCompaction(chatId, "30-pair-threshold", opts?.onCompaction);
+          }
         }
       }
       const sdUsage = sdResult.usage ?? { input: 0, output: 0 };
       if (sdUsage.input + sdUsage.output > 0) {
-        addUsage(chatId, sdUsage.input, sdUsage.output, 0, resolvedModel2);
+        addUsage(chatId, sdUsage.input, sdUsage.output, 0, resolvedModel2, adapter.id, apiContextSize);
       }
       if (cancelState2.cancelled) {
         return { text: "Stopped.", usage: { input: sdUsage.input, output: sdUsage.output, cacheRead: 0 } };
@@ -14595,9 +15449,16 @@ async function askAgentImpl(chatId, userMessage, opts) {
       };
     } finally {
       activeChats.delete(chatId);
+      if (adapter.id === "ollama" && !cancelState2.cancelled) {
+        Promise.resolve().then(() => (init_ollama(), ollama_exports)).then(({ OllamaService }) => {
+          OllamaService.tryUnloadModel(resolvedModel2);
+        }).catch(() => {
+        });
+      }
     }
   }
   const existingSessionId = settingsSourceChatId ? null : getSessionId(settingsChat);
+  log(`[agent:session] chatId=${chatId} settingsChat=${settingsChat} existingSessionId=${existingSessionId ?? "(none)"} backend=${adapter.id}`);
   const allowedTools = getEnabledTools(settingsChat);
   const mcpConfigPath = profile !== "minimal" && effectiveAgentMode !== "native" && MCP_CONFIG_FLAG[adapter.id] ? getMcpConfigPath(chatId) : null;
   const baseConfig = adapter.buildSpawnConfig({
@@ -14836,7 +15697,10 @@ async function askAgentImpl(chatId, userMessage, opts) {
     return { text: "Stopped.", usage: { input: result.input, output: result.output, cacheRead: result.cacheRead, contextSize: result.contextSize } };
   }
   if (result.sessionId && !isSyntheticChatId(chatId)) {
+    log(`[agent:session] Persisting session for chatId=${chatId}: ${result.sessionId}`);
     setSessionId(chatId, result.sessionId);
+  } else if (!result.sessionId) {
+    log(`[agent:session] No sessionId in result for chatId=${chatId} \u2014 session will not resume`);
   }
   if (adapter.id === BACKEND.CLAUDE && result.resultText && result.sessionId && /InputValidationError/i.test(result.resultText) && /missing|required parameter/i.test(result.resultText)) {
     const toolMatch = result.resultText.match(/(?:parameter\s+'|required parameter\s+['"]?)([\w-]+)/i);
@@ -14884,17 +15748,12 @@ async function askAgentImpl(chatId, userMessage, opts) {
   }
   if (result.resultText && !isSyntheticChatId(chatId)) {
     appendToLog(chatId, userMessage, result.resultText, adapter.id, model2 ?? null, result.sessionId ?? null);
-    const AUTO_SUMMARIZE_THRESHOLD = 30;
     const pairCount = profile !== "chat" ? getMessagePairCount(chatId) : 0;
-    if (pairCount >= AUTO_SUMMARIZE_THRESHOLD) {
+    if (pairCount >= 30 && !compactionInFlight.has(chatId)) {
+      compactionInFlight.add(chatId);
       log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
-      summarizeWithFallbackChain(chatId).then((saved) => {
-        if (saved) {
-          clearSession(chatId);
-          opts?.onCompaction?.(chatId);
-        }
-      }).catch((err) => {
-        warn(`[agent] Auto-summarize failed for chat ${chatId}: ${err}`);
+      runCompaction(chatId, "30-pair-threshold", opts?.onCompaction).finally(() => {
+        compactionInFlight.delete(chatId);
       });
     }
   }
@@ -14923,7 +15782,7 @@ function injectMcpConfig(adapterId, args, mcpConfigPath) {
   if (!flag) return args;
   return [...args, ...flag, mcpConfigPath, "--strict-mcp-config"];
 }
-var activeChats, staleSweepTimer, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
+var activeChats, compactionInFlight, staleSweepTimer, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
 var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
@@ -14940,7 +15799,6 @@ var init_agent = __esm({
     init_strip_thinking();
     init_text_utils();
     init_session_log();
-    init_api_context();
     init_summarize();
     init_quota();
     init_store5();
@@ -14951,6 +15809,7 @@ var init_agent = __esm({
     init_unified_config();
     init_mcp_config();
     activeChats = /* @__PURE__ */ new Map();
+    compactionInFlight = /* @__PURE__ */ new Set();
     chatLocks = /* @__PURE__ */ new Map();
     SPAWN_TIMEOUT_MS = 10 * 60 * 1e3;
     FIRST_RESPONSE_TIMEOUT_MS = parseInt(process.env.GEMINI_FIRST_RESPONSE_TIMEOUT_MS ?? "30000", 10);
@@ -15118,7 +15977,9 @@ async function runWeeklySweep(chatId, channel, backendId, model2) {
       buttons.push([{ label: "Review Now", data: "mem:opt:start", style: "success" }]);
     }
     buttons.push([{ label: "Dismiss", data: "mem:sweep:dismiss" }]);
-    await sendOrEditKeyboard(chatId, channel, void 0, lines.join("\n"), buttons);
+    if (channel) {
+      await sendOrEditKeyboard(chatId, channel, void 0, lines.join("\n"), buttons);
+    }
     return { suggestionsCount, cleanedUp };
   } catch (err) {
     const msg = errorMessage(err);
@@ -15438,52 +16299,6 @@ var init_pagination = __esm({
   }
 });
 
-// src/format-time.ts
-function formatLocalDate(utcDatetime) {
-  const d = parseUtcDatetime(utcDatetime);
-  if (!d) return utcDatetime.split("T")[0] ?? utcDatetime.split(" ")[0];
-  const year = d.getFullYear();
-  const month = String(d.getMonth() + 1).padStart(2, "0");
-  const day = String(d.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-function formatLocalDateTime(utcDatetime) {
-  const d = parseUtcDatetime(utcDatetime);
-  if (!d) return utcDatetime;
-  const year = d.getFullYear();
-  const month = String(d.getMonth() + 1).padStart(2, "0");
-  const day = String(d.getDate()).padStart(2, "0");
-  const hours = String(d.getHours()).padStart(2, "0");
-  const minutes = String(d.getMinutes()).padStart(2, "0");
-  const tzAbbr = getTimezoneAbbr(d);
-  return `${year}-${month}-${day} ${hours}:${minutes} ${tzAbbr}`;
-}
-function parseUtcDatetime(utcDatetime) {
-  if (!utcDatetime) return null;
-  const normalized = utcDatetime.includes("T") ? utcDatetime : utcDatetime.replace(" ", "T");
-  const withZ = normalized.endsWith("Z") ? normalized : normalized + "Z";
-  const d = new Date(withZ);
-  return isNaN(d.getTime()) ? null : d;
-}
-function getTimezoneAbbr(date) {
-  try {
-    const parts = new Intl.DateTimeFormat("en-US", {
-      timeZone: systemTimezone,
-      timeZoneName: "short"
-    }).formatToParts(date);
-    return parts.find((p) => p.type === "timeZoneName")?.value ?? "";
-  } catch {
-    return "";
-  }
-}
-var systemTimezone;
-var init_format_time = __esm({
-  "src/format-time.ts"() {
-    "use strict";
-    systemTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  }
-});
-
 // src/scheduler/humanize.ts
 function formatTime(hour, minute) {
   const h = hour % 12 || 12;
@@ -16776,11 +17591,11 @@ var init_health2 = __esm({
 });
 
 // src/health/checks.ts
-import { existsSync as existsSync16, statSync as statSync5, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync16, statSync as statSync5, readFileSync as readFileSync12 } from "fs";
 import { execFileSync as execFileSync2, execSync as execSync2 } from "child_process";
 function getRecentErrors() {
   if (!existsSync16(ERROR_LOG_PATH)) return null;
-  const logContent = readFileSync11(ERROR_LOG_PATH, "utf-8");
+  const logContent = readFileSync12(ERROR_LOG_PATH, "utf-8");
   const allLines = logContent.split("\n").filter(Boolean).slice(-500);
   const last24h = Date.now() - 864e5;
   const lines = allLines.filter((line) => {
@@ -17009,7 +17824,7 @@ __export(heartbeat_exports, {
   stopHeartbeatForChat: () => stopHeartbeatForChat,
   updateHeartbeatConfig: () => updateHeartbeatConfig
 });
-import { readFileSync as readFileSync12, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync13, existsSync as existsSync17 } from "fs";
 import { join as join17 } from "path";
 function findHeartbeatJob() {
   try {
@@ -17191,7 +18006,7 @@ ${watchLines.join("\n")}`);
   }
   if (existsSync17(HEARTBEAT_MD_PATH)) {
     try {
-      const custom = readFileSync12(HEARTBEAT_MD_PATH, "utf-8").trim();
+      const custom = readFileSync13(HEARTBEAT_MD_PATH, "utf-8").trim();
       if (custom) {
         sections.push(`[Custom checks from HEARTBEAT.md]
 ${custom}`);
@@ -17440,6 +18255,7 @@ __export(ui_exports, {
   ROTATION_MODE_LABELS: () => ROTATION_MODE_LABELS,
   buildAccountSlotKeyboard: () => buildAccountSlotKeyboard,
   doBackendSwitch: () => doBackendSwitch,
+  executeBackendDisable: () => executeBackendDisable,
   getJobScheduleText: () => getJobScheduleText,
   getJobStatusEmoji: () => getJobStatusEmoji,
   getJobStatusLabel: () => getJobStatusLabel,
@@ -17447,6 +18263,7 @@ __export(ui_exports, {
   sendApiToolsKeyboard: () => sendApiToolsKeyboard,
   sendBackendAccountPicker: () => sendBackendAccountPicker,
   sendBackendConfigPanel: () => sendBackendConfigPanel,
+  sendBackendDisableFlow: () => sendBackendDisableFlow,
   sendBackendModelPicker: () => sendBackendModelPicker,
   sendBackendPicker: () => sendBackendPicker,
   sendBackendSwitchConfirmation: () => sendBackendSwitchConfirmation,
@@ -18190,9 +19007,24 @@ ${unapproved.length} CC-Claw skill${unapproved.length !== 1 ? "s" : ""} need rev
   const safePage = Math.max(1, Math.min(page, totalPages));
   const start = (safePage - 1) * SKILLS_PER_PAGE;
   const pageSkills = approved.slice(start, start + SKILLS_PER_PAGE);
+  const { getPinnedSkills: getPinnedSkills2 } = await Promise.resolve().then(() => (init_chat_settings(), chat_settings_exports));
+  const pinned = getPinnedSkills2(chatId);
+  let correctedSkills = /* @__PURE__ */ new Set();
+  try {
+    const { getSkillCorrections: getSkillCorrections2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
+    const db3 = (await Promise.resolve().then(() => (init_store5(), store_exports5))).getDb();
+    const corrections = getSkillCorrections2(db3, 30, 3);
+    correctedSkills = new Set(corrections.map((c) => c.skillName));
+  } catch {
+  }
   const typeIcon = (s) => s.type === "specialist" ? "\u{1F3AF}" : "\u{1F527}";
   const buttons = pageSkills.map((s) => {
-    return [{ label: `${typeIcon(s)} ${s.name}`, data: `skill:${s.source}:${s.name}`, style: "success" }];
+    const isPinned = pinned.includes(s.name);
+    const correctionBadge = correctedSkills.has(s.name) ? " \u26A0\uFE0F" : "";
+    return [
+      { label: `${typeIcon(s)} ${s.name}${correctionBadge}`, data: `skill:${s.source}:${s.name}`, style: "success" },
+      { label: isPinned ? "\u{1F4CC}" : "\u25CB Pin", data: `pin:${s.name}` }
+    ];
   });
   if (totalPages > 1) {
     const navRow = [];
@@ -18924,6 +19756,17 @@ async function sendBackendPicker(chatId, channel, messageId) {
 }
 async function sendBackendConfigPanel(chatId, backendId, channel, messageId, switched = false) {
   if (typeof channel.sendKeyboard !== "function") return;
+  const disabled = getDisabledBackends().includes(backendId);
+  if (disabled) {
+    const adapter = getAdapter(backendId);
+    const text = `\u{1F534} ${adapter.displayName} is disabled`;
+    const buttons2 = [
+      [{ label: "Enable", data: `bconf:enable:${backendId}`, style: "success" }],
+      [{ label: "\u2190 Back to Backends", data: "bconf:back" }]
+    ];
+    await sendOrEditKeyboard(chatId, channel, messageId, text, buttons2);
+    return;
+  }
   const summary = backendConfigSummary(chatId, backendId, switched);
   const buttons = [
     [
@@ -18931,10 +19774,80 @@ async function sendBackendConfigPanel(chatId, backendId, channel, messageId, swi
       { label: "Thinking", data: `bconf:thinking:${backendId}` },
       { label: "Account", data: `bconf:account:${backendId}` }
     ],
+    [{ label: "Disable", data: `bconf:disable:${backendId}`, style: "danger" }],
     [{ label: "\u2190 Back to Backends", data: "bconf:back" }]
   ];
   await sendOrEditKeyboard(chatId, channel, messageId, summary, buttons);
 }
+async function sendBackendDisableFlow(chatId, backendId, channel, messageId) {
+  if (typeof channel.sendKeyboard !== "function") return;
+  const { getActiveJobsByBackend: getActiveJobsByBackend2 } = await Promise.resolve().then(() => (init_jobs(), jobs_exports));
+  const affectedJobs = getActiveJobsByBackend2(backendId);
+  if (affectedJobs.length > 0) {
+    await sendDisableJobReassign(chatId, backendId, affectedJobs, channel, messageId);
+    return;
+  }
+  const current = getBackend(chatId);
+  if (current === backendId) {
+    await sendDisableBackendSwitch(chatId, backendId, channel, messageId);
+    return;
+  }
+  await executeBackendDisable(chatId, backendId, channel, messageId);
+}
+async function sendDisableJobReassign(chatId, backendId, jobs, channel, messageId) {
+  const adapter = getAdapter(backendId);
+  const jobList = jobs.slice(0, 5).map((j) => `  \u2022 ${j.title ?? j.description}`).join("\n");
+  const extra = jobs.length > 5 ? `
+  \u2026and ${jobs.length - 5} more` : "";
+  const text = [
+    `\u26A0\uFE0F ${jobs.length} cron job(s) use ${adapter.displayName}:`,
+    "",
+    jobList + extra,
+    "",
+    "Reassign these jobs to:"
+  ].join("\n");
+  const ids = getAvailableChatBackendIds().filter((id) => id !== backendId);
+  const buttons = ids.map((id) => [{
+    label: getAdapter(id).displayName,
+    data: `bconf:reassign:${backendId}:${id}`
+  }]);
+  buttons.push([{ label: "Cancel", data: `bconf:panel:${backendId}` }]);
+  await sendOrEditKeyboard(chatId, channel, messageId, text, buttons);
+}
+async function sendDisableBackendSwitch(chatId, backendId, channel, messageId) {
+  const adapter = getAdapter(backendId);
+  const text = `${adapter.displayName} is your active backend.
+
+Switch to:`;
+  const ids = getAvailableChatBackendIds().filter((id) => id !== backendId);
+  const buttons = ids.map((id) => [{
+    label: getAdapter(id).displayName,
+    data: `bconf:disableswitch:${backendId}:${id}`
+  }]);
+  buttons.push([{ label: "Cancel", data: `bconf:panel:${backendId}` }]);
+  await sendOrEditKeyboard(chatId, channel, messageId, text, buttons);
+}
+async function executeBackendDisable(chatId, backendId, channel, messageId, opts) {
+  const adapter = getAdapter(backendId);
+  const parts = [];
+  if (opts?.reassignTo) {
+    const { reassignJobsBackend: reassignJobsBackend2 } = await Promise.resolve().then(() => (init_jobs(), jobs_exports));
+    const count = reassignJobsBackend2(backendId, opts.reassignTo);
+    const targetName = getAdapter(opts.reassignTo).displayName;
+    if (count > 0) parts.push(`${count} job(s) reassigned to ${targetName}`);
+  }
+  if (opts?.switchTo) {
+    await doBackendSwitch(chatId, opts.switchTo, channel, { skipContext: true });
+    parts.push(`Switched to ${getAdapter(opts.switchTo).displayName}`);
+  }
+  setBackendDisabled(backendId, true);
+  const detail = parts.length > 0 ? `
+${parts.join(". ")}.` : "";
+  const text = `\u2705 ${adapter.displayName} disabled.${detail}`;
+  await sendOrEditKeyboard(chatId, channel, messageId, text, [
+    [{ label: "\u2190 Back to Backends", data: "bconf:back" }]
+  ]);
+}
 async function sendBackendModelPicker(chatId, backendId, channel, messageId) {
   if (typeof channel.sendKeyboard !== "function") return;
   const adapter = getAdapter(backendId);
@@ -19008,7 +19921,15 @@ async function sendBackendThinkingPicker(chatId, backendId, channel, messageId)
     return;
   }
   const current = getThinkingLevel(chatId) ?? "auto";
-  const levels = [
+  const LEVEL_LABELS = {
+    auto: "Auto",
+    off: "Off",
+    low: "Low",
+    medium: "Medium",
+    high: backendId === "ollama" ? "On" : "High",
+    extra_high: "Extra High"
+  };
+  const defaultLevels = [
     ["auto", "Auto"],
     ["off", "Off"],
     ["low", "Low"],
@@ -19016,6 +19937,7 @@ async function sendBackendThinkingPicker(chatId, backendId, channel, messageId)
     ["high", "High"],
     ["extra_high", "Extra High"]
   ];
+  const levels = modelInfo?.thinkingLevels ? modelInfo.thinkingLevels.map((l) => [l, LEVEL_LABELS[l] ?? capitalize(l.replace("_", " "))]) : defaultLevels;
   const buttons = levels.map(([val, label2]) => [{
     label: `${val === current ? "\u2713 " : ""}${label2}`,
     data: `bconf:setthinking:${backendId}:${val}`,
@@ -19076,6 +19998,16 @@ async function doBackendSwitch(chatId, backendId, channel, opts) {
     const bridge = buildContextBridge(chatId, 15, interrupted);
     if (bridge) setPendingContextBridge(chatId, bridge);
   }
+  const previousBackend = getBackend(chatId);
+  if (previousBackend === "ollama") {
+    const previousModel = getModel(chatId);
+    if (previousModel) {
+      Promise.resolve().then(() => (init_ollama(), ollama_exports)).then(({ OllamaService }) => {
+        OllamaService.tryUnloadModel(previousModel);
+      }).catch(() => {
+      });
+    }
+  }
   clearSession(chatId);
   clearModel(chatId);
   clearThinkingLevel(chatId);
@@ -20566,7 +21498,7 @@ __export(analyze_exports, {
 });
 import { spawn as spawn5 } from "child_process";
 import { createInterface as createInterface4 } from "readline";
-import { readFileSync as readFileSync13, existsSync as existsSync18, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync18, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
 import { join as join18 } from "path";
 import { homedir as homedir6 } from "os";
 function applySignalDecay(confidence, createdAt) {
@@ -20588,7 +21520,7 @@ function discoverReflectionTargets() {
         if (!existsSync18(skillFile)) continue;
         let desc = "skill";
         try {
-          const content = readFileSync13(skillFile, "utf-8");
+          const content = readFileSync14(skillFile, "utf-8");
           const descMatch = content.match(/description:\s*["']?([^"'\n]+)/);
           if (descMatch) desc = descMatch[1].trim().slice(0, 80);
         } catch {
@@ -20663,6 +21595,21 @@ ${categoryList}`);
       sections.push(skill.content);
     }
   }
+  if (params.skillCorrections && params.skillCorrections.length > 0) {
+    sections.push("[Underperforming Skills]");
+    sections.push(
+      "These skills have received repeated corrections. The per-model breakdown helps distinguish skill quality issues from model capability limits. If corrections concentrate on weaker models (Flash, Haiku, Lite) while stronger models (Opus, Pro) handle the skill correctly, this likely reflects model capability rather than skill quality \u2014 consider adding a simplified-instructions section for weaker models rather than a full rewrite."
+    );
+    for (const sc of params.skillCorrections) {
+      const modelSummary = sc.modelBreakdown.map((m) => `${m.model}: ${m.count}`).join(", ");
+      sections.push(`- **${sc.skillName}** \u2014 ${sc.correctionCount} corrections in last 30 days`);
+      sections.push(`  Models: ${modelSummary || "unknown"}`);
+      const uniqueContexts = [...new Set(sc.contexts)].slice(0, 5);
+      for (const ctx of uniqueContexts) {
+        sections.push(`  Correction: "${ctx}"`);
+      }
+    }
+  }
   sections.push("[Previously Applied Insights]");
   if (appliedInsights.length === 0) {
     sections.push("(none)");
@@ -20797,7 +21744,7 @@ function resolveReflectionAdapter(chatId) {
 }
 function readIdentityFile(filename) {
   try {
-    return readFileSync13(join18(IDENTITY_PATH, filename), "utf-8");
+    return readFileSync14(join18(IDENTITY_PATH, filename), "utf-8");
   } catch {
     return "";
   }
@@ -20956,7 +21903,7 @@ async function runAnalysisImpl(chatId, opts) {
     try {
       const fullPath = join18(ccClawHome, target.path);
       if (existsSync18(fullPath)) {
-        const content = readFileSync13(fullPath, "utf-8");
+        const content = readFileSync14(fullPath, "utf-8");
         if (totalSkillChars + content.length > SKILL_CONTENT_CAP) break;
         skillContents.push({ path: target.path, content });
         totalSkillChars += content.length;
@@ -20964,6 +21911,7 @@ async function runAnalysisImpl(chatId, opts) {
     } catch {
     }
   }
+  const skillCorrections = getSkillCorrections(db3, 30, 3);
   const prompt = buildAnalysisPrompt({
     signals: signals.map((s) => {
       const decayedConfidence = applySignalDecay(s.confidence, s.created_at);
@@ -20986,7 +21934,8 @@ async function runAnalysisImpl(chatId, opts) {
     })),
     codebaseEnabled,
     availableTargets,
-    skillContents
+    skillContents,
+    skillCorrections
   });
   const resolved = resolveReflectionAdapter(chatId);
   if (!resolved) {
@@ -21336,7 +22285,7 @@ __export(apply_exports, {
   isTargetAllowed: () => isTargetAllowed,
   rollbackInsight: () => rollbackInsight
 });
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync7, existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync8, unlinkSync as unlinkSync5 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync7, existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync8, unlinkSync as unlinkSync5 } from "fs";
 import { join as join19, dirname as dirname4 } from "path";
 function isTargetAllowed(relativePath) {
   if (relativePath.includes("..")) return false;
@@ -21424,7 +22373,7 @@ async function applyInsight(insightId) {
   const absolutePath = join19(CC_CLAW_HOME, insight.targetFile);
   if (insight.proposedAction === "append" && insight.targetFile === "identity/SOUL.md") {
     if (existsSync19(absolutePath)) {
-      const currentContent = readFileSync14(absolutePath, "utf-8");
+      const currentContent = readFileSync15(absolutePath, "utf-8");
       const lineCount = currentContent.split("\n").length;
       if (lineCount >= SOUL_LINE_CAP) {
         return {
@@ -21446,7 +22395,7 @@ async function applyInsight(insightId) {
   }
   let original = "";
   if (existsSync19(absolutePath)) {
-    original = readFileSync14(absolutePath, "utf-8");
+    original = readFileSync15(absolutePath, "utf-8");
   } else if (insight.proposedAction !== "create") {
     return { success: false, message: `Target file "${insight.targetFile}" does not exist` };
   }
@@ -21587,7 +22536,7 @@ function computeLineDrift(baseline, absolutePath) {
   let current = "";
   try {
     if (existsSync19(absolutePath)) {
-      current = readFileSync14(absolutePath, "utf-8");
+      current = readFileSync15(absolutePath, "utf-8");
     }
   } catch {
     return 1;
@@ -22319,6 +23268,14 @@ var init_api_mcp = __esm({
 
 // src/backends/api-common.ts
 import { streamText, stepCountIs, NoOutputGeneratedError, APICallError } from "ai";
+function mapToolActionToApiFormat(cb) {
+  if (!cb) return void 0;
+  return (event) => {
+    const input = event.input ?? {};
+    const result = event.type === "tool_end" ? typeof event.output === "string" ? event.output : event.output != null ? JSON.stringify(event.output) : "" : void 0;
+    cb(event.toolName, input, result);
+  };
+}
 function toModelMessage(msg) {
   switch (msg.role) {
     case "system":
@@ -22515,6 +23472,7 @@ var init_ollama2 = __esm({
   "src/backends/ollama.ts"() {
     "use strict";
     init_api_common();
+    init_api_common();
     init_ollama();
     init_prompt();
     OLLAMA_HTTP_SENTINEL = "__ollama_http__";
@@ -22602,26 +23560,35 @@ var init_ollama2 = __esm({
        */
       async streamDirect(prompt, model2, opts) {
         const cleanPrompt = stripForLocalModel(prompt);
-        let disableThinking = false;
+        let modelContextWindow;
+        const ollamaProviderOpts = {};
         try {
           const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
           const modelRecord = OllamaStore.getModelByName(model2);
-          if (modelRecord?.forceThinkOff) {
-            disableThinking = true;
-          } else if (opts?.thinkingLevel === "off") {
-            disableThinking = true;
+          const chatLevel = opts?.thinkingLevel;
+          if (chatLevel === "off") {
+            ollamaProviderOpts.think = false;
+          } else if (chatLevel && chatLevel !== "auto") {
+            ollamaProviderOpts.think = true;
+          } else if (modelRecord?.forceThinkOff) {
+            ollamaProviderOpts.think = false;
+          }
+          if (modelRecord?.contextWindow && modelRecord.contextWindow > 4096) {
+            modelContextWindow = modelRecord.contextWindow;
           }
         } catch {
         }
+        if (modelContextWindow) ollamaProviderOpts.num_ctx = modelContextWindow;
         const apiOpts = {
           timeoutMs: opts?.timeoutMs,
           onStream: opts?.onStream,
           signal: opts?.signal,
           messageHistory: opts?.messageHistory,
+          onToolAction: mapToolActionToApiFormat(opts?.onToolAction),
           permMode: opts?.permMode,
           thinkingLevel: opts?.thinkingLevel,
           onThinking: opts?.onThinking,
-          ...disableThinking ? { providerOptions: { ollama: { think: false } } } : {}
+          ...Object.keys(ollamaProviderOpts).length > 0 ? { providerOptions: { ollama: ollamaProviderOpts } } : {}
         };
         const result = await this.streamDirectWithHistory(
           cleanPrompt,
@@ -22646,10 +23613,11 @@ 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: isThinkingCapable ? "adjustable" : "none"
+            thinking: "adjustable",
+            // all Ollama models support think: true/false toggle
+            thinkingLevels: ["auto", "off", "high"]
           };
           this.pricing[m.name] = { in: 0, out: 0, cache: 0 };
           this.contextWindow[m.name] = m.contextWindow ?? 4096;
@@ -22666,6 +23634,7 @@ var init_openrouter = __esm({
   "src/backends/openrouter.ts"() {
     "use strict";
     init_api_common();
+    init_api_common();
     OPENROUTER_HTTP_SENTINEL = "__openrouter_api__";
     DEFAULT_FREE_MODEL = "qwen/qwen3.6-plus:free";
     OpenRouterAdapter = class extends ApiBackendBase {
@@ -22707,7 +23676,28 @@ var init_openrouter = __esm({
       }
       summarizerModel = DEFAULT_FREE_MODEL;
       pricing = {};
-      contextWindow = {};
+      _contextWindowCache = null;
+      _contextWindowCacheSize = 0;
+      get contextWindow() {
+        try {
+          const { getApiModels: getApiModels2 } = (init_api_models(), __toCommonJS(api_models_exports));
+          const models = getApiModels2("openrouter");
+          if (this._contextWindowCache && models.length === this._contextWindowCacheSize) {
+            return this._contextWindowCache;
+          }
+          const result = {};
+          for (const m of models) {
+            if (m.contextWindow) {
+              result[m.modelId] = m.contextWindow;
+            }
+          }
+          this._contextWindowCache = result;
+          this._contextWindowCacheSize = models.length;
+          return result;
+        } catch {
+          return {};
+        }
+      }
       // ── Vercel AI SDK provider ────────────────────────────────────────
       /**
        * Create the Vercel AI SDK LanguageModel for a given model ID.
@@ -22734,17 +23724,12 @@ var init_openrouter = __esm({
        * including tool actions, permission mode, thinking tokens, and conversation history.
        */
       async streamDirect(prompt, model2, opts) {
-        const onToolAction = opts?.onToolAction ? (event) => {
-          const input = event.input ?? {};
-          const result2 = event.type === "tool_end" ? typeof event.output === "string" ? event.output : JSON.stringify(event.output ?? "") : void 0;
-          opts.onToolAction(event.toolName, input, result2);
-        } : void 0;
         const apiOpts = {
           timeoutMs: opts?.timeoutMs,
           onStream: opts?.onStream,
           signal: opts?.signal,
           messageHistory: opts?.messageHistory,
-          onToolAction,
+          onToolAction: mapToolActionToApiFormat(opts?.onToolAction),
           permMode: opts?.permMode,
           thinkingLevel: opts?.thinkingLevel,
           onThinking: opts?.onThinking
@@ -22920,7 +23905,10 @@ function getAvailableBackendIds() {
   return [...availableSet];
 }
 function getAvailableChatBackendIds() {
-  return CHAT_BACKEND_IDS.filter((id) => availableSet.size === 0 || availableSet.has(id));
+  const disabled = getDisabledBackends();
+  return CHAT_BACKEND_IDS.filter(
+    (id) => (availableSet.size === 0 || availableSet.has(id)) && !disabled.includes(id)
+  );
 }
 var openRouterAdapter, adapters, CHAT_BACKEND_IDS, availableSet;
 var init_backends = __esm({
@@ -22933,6 +23921,7 @@ var init_backends = __esm({
     init_ollama2();
     init_openrouter();
     init_store5();
+    init_schema();
     init_log();
     init_types();
     openRouterAdapter = new OpenRouterAdapter();
@@ -23222,7 +24211,7 @@ var init_retry = __esm({
 });
 
 // src/bootstrap/profile.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, existsSync as existsSync22 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync8, existsSync as existsSync22 } from "fs";
 import { join as join21 } from "path";
 function hasActiveProfile(chatId) {
   return activeProfiles.has(chatId);
@@ -23353,7 +24342,7 @@ function extractUserUpdates(text) {
 }
 function appendToUserProfile(key, value) {
   if (!existsSync22(USER_PATH2)) return;
-  const content = readFileSync15(USER_PATH2, "utf-8");
+  const content = readFileSync16(USER_PATH2, "utf-8");
   const line = `- **${key}**: ${value}`;
   if (content.includes(line)) return;
   const updated = content.trimEnd() + `
@@ -24806,6 +25795,7 @@ var init_live_status = __esm({
       /** Spinner frame counter — advances on each flush for animation. */
       spinnerFrame = 0;
       /** Timestamp of last successful edit — used for heartbeat force-through. */
+      lastSuccessfulFlushAt = 0;
       /** Callback to restart typing indicator as fallback. */
       onTypingFallback;
       /** Set a callback that restarts the typing indicator loop as a fallback. */
@@ -26655,12 +27645,12 @@ async function handleEvolveCallback(chatId, data, channel, messageId) {
         );
         break;
       }
-      const { readFileSync: readFileSync35, existsSync: existsSync62 } = await import("fs");
+      const { readFileSync: readFileSync36, existsSync: existsSync62 } = await import("fs");
       const { join: join42 } = await import("path");
       const targetPath = join42(homedir7(), ".cc-claw", insight.targetFile);
       let previewText;
       if (existsSync62(targetPath)) {
-        const current = readFileSync35(targetPath, "utf-8");
+        const current = readFileSync36(targetPath, "utf-8");
         const diffLines = insight.proposedDiff.split("\n");
         const additions = diffLines.filter((l) => l.startsWith("+")).map((l) => `  + ${l.slice(1).trim()}`);
         const removals = diffLines.filter((l) => l.startsWith("-")).map((l) => `  - ${l.slice(1).trim()}`);
@@ -26732,13 +27722,13 @@ async function handleEvolveCallback(chatId, data, channel, messageId) {
       const { logActivity: logActivity2 } = await Promise.resolve().then(() => (init_store3(), store_exports3));
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
-        const { readFileSync: readFileSync35, existsSync: existsSync62 } = await import("fs");
+        const { readFileSync: readFileSync36, existsSync: existsSync62 } = await import("fs");
         const { join: join42 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const soulPath = join42(CC_CLAW_HOME3, "identity/SOUL.md");
         const userPath = join42(CC_CLAW_HOME3, "identity/USER.md");
-        const soul = existsSync62(soulPath) ? readFileSync35(soulPath, "utf-8") : "";
-        const user = existsSync62(userPath) ? readFileSync35(userPath, "utf-8") : "";
+        const soul = existsSync62(soulPath) ? readFileSync36(soulPath, "utf-8") : "";
+        const user = existsSync62(userPath) ? readFileSync36(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
         logActivity2(getDb(), { chatId, source: "telegram", eventType: "reflection_unfrozen", summary: "Reflection enabled" });
         await sendEvolveDashboard(chatId, reflChatId, channel, messageId);
@@ -26877,11 +27867,11 @@ var init_evolve2 = __esm({
 });
 
 // src/optimizer/identity-audit.ts
-import { readFileSync as readFileSync16, existsSync as existsSync26, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync26, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
 import { join as join26 } from "path";
 function readIdentityFile2(filename) {
   try {
-    return readFileSync16(join26(IDENTITY_PATH, filename), "utf-8");
+    return readFileSync17(join26(IDENTITY_PATH, filename), "utf-8");
   } catch {
     return "";
   }
@@ -27034,7 +28024,7 @@ var init_identity_audit = __esm({
 });
 
 // src/optimizer/skill-audit.ts
-import { readFileSync as readFileSync17, existsSync as existsSync27 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync27 } from "fs";
 import { join as join27, basename as basename3 } from "path";
 function parseFrontmatter3(content) {
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
@@ -27080,7 +28070,7 @@ function detectDependentSkills(content) {
   return Array.from(deps);
 }
 function computeSkillStats(skillPath) {
-  const content = readFileSync17(skillPath, "utf-8");
+  const content = readFileSync18(skillPath, "utf-8");
   const lines = content.split("\n");
   return {
     skillName: basename3(skillPath, ".md") === "SKILL" ? basename3(join27(skillPath, "..")) : basename3(skillPath, ".md"),
@@ -27109,7 +28099,7 @@ function loadDependentSkillContents(depNames, ccClawSkillsDir) {
     for (const candidate of candidates) {
       if (existsSync27(candidate)) {
         try {
-          const content = readFileSync17(candidate, "utf-8");
+          const content = readFileSync18(candidate, "utf-8");
           results.push({
             name,
             content: content.length > 3e3 ? content.slice(0, 3e3) + "\n[...truncated]" : content
@@ -27253,7 +28243,7 @@ __export(analyze_exports2, {
 });
 import { spawn as spawn7 } from "child_process";
 import { createInterface as createInterface7 } from "readline";
-import { readFileSync as readFileSync18, existsSync as existsSync28, readdirSync as readdirSync12 } from "fs";
+import { readFileSync as readFileSync19, existsSync as existsSync28, readdirSync as readdirSync12 } from "fs";
 import { join as join28 } from "path";
 import { homedir as homedir8 } from "os";
 function parseOptimizeOutput(raw, validAreas) {
@@ -27384,7 +28374,7 @@ function getModelDisplayInfo(chatId) {
 }
 function readIdentityFile3(filename) {
   try {
-    return readFileSync18(join28(IDENTITY_PATH, filename), "utf-8");
+    return readFileSync19(join28(IDENTITY_PATH, filename), "utf-8");
   } catch {
     return "";
   }
@@ -27397,7 +28387,7 @@ function loadContextFiles() {
     for (const entry of readdirSync12(contextDir)) {
       if (!entry.endsWith(".md")) continue;
       try {
-        const content = readFileSync18(join28(contextDir, entry), "utf-8");
+        const content = readFileSync19(join28(contextDir, entry), "utf-8");
         results.push({ name: entry, content });
       } catch {
       }
@@ -27449,7 +28439,7 @@ async function runSkillAudit(chatId, skillPath) {
   log(`[optimizer] Running skill audit on ${stats.skillName} with ${adapter.id}:${model2}`);
   const soulMd = readIdentityFile3("SOUL.md");
   const ccClawSkillsDir = join28(homedir8(), ".cc-claw", "workspace", "skills");
-  const skillContent = readFileSync18(skillPath, "utf-8");
+  const skillContent = readFileSync19(skillPath, "utf-8");
   const prompt = buildSkillAuditPrompt(skillContent, stats, soulMd, ccClawSkillsDir);
   const raw = await spawnAnalysis2(adapter, model2, prompt);
   const findings = parseOptimizeOutput(raw, VALID_SKILL_AREAS);
@@ -27472,7 +28462,7 @@ function listCcClawSkills() {
       if (!existsSync28(skillFile)) continue;
       let description = "skill";
       try {
-        const content = readFileSync18(skillFile, "utf-8");
+        const content = readFileSync19(skillFile, "utf-8");
         const descMatch = content.match(/description:\s*>?\s*\n?\s*(.+)/);
         if (descMatch) description = descMatch[1].trim().slice(0, 60);
       } catch {
@@ -27799,7 +28789,7 @@ __export(optimize_exports2, {
   handleOptimizeCallback: () => handleOptimizeCallback,
   handleOptimizeCommand: () => handleOptimizeCommand
 });
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync9, existsSync as existsSync29, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync9, existsSync as existsSync29, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
 import { join as join29, dirname as dirname5 } from "path";
 import { homedir as homedir9 } from "os";
 async function handleOptimizeCommand(chatId, channel, _args, messageId) {
@@ -28029,7 +29019,7 @@ async function applyFinding(chatId, channel, index, messageId) {
       await showFinding(chatId, channel, index + 1, effectiveMsgId);
       return;
     }
-    const original = readFileSync19(targetPath, "utf-8");
+    const original = readFileSync20(targetPath, "utf-8");
     const backupPath = targetPath + `.bak.${Date.now()}`;
     writeFileSync9(backupPath, original, "utf-8");
     pruneBackups2(targetPath);
@@ -29358,6 +30348,7 @@ async function handleNewchatCommand(chatId, commandArgs, msg, channel) {
   const summarized = await summarizeSession(chatId);
   clearSession(chatId);
   clearChatPaidSlots(chatId);
+  clearUsage(chatId);
   setSessionStartedAt(chatId);
   logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: "New session started", detail: { field: "session", action: "reset", summarized } });
   if (typeof channel.sendKeyboard === "function" && oldSessionId) {
@@ -29411,6 +30402,7 @@ async function handleClearCommand(chatId, _commandArgs, _msg, channel) {
   stopAllSideQuests(chatId);
   clearSession(chatId);
   clearChatPaidSlots(chatId);
+  clearUsage(chatId);
   setSessionStartedAt(chatId);
   logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: "Session cleared (no summary)", detail: { field: "session", action: "clear" } });
   await channel.sendText(chatId, "\u{1F9FD} Session cleared. No summary saved.", { parseMode: "plain", priority: 0 /* P0_CRITICAL */ });
@@ -29487,6 +30479,17 @@ async function handleSummarizeCommand(chatId, commandArgs, msg, channel) {
     }
   }
 }
+function formatSummarizerLabel(backend2, model2, fallbackModel) {
+  if (backend2 === "off") return "Off";
+  if (backend2) return `${backend2}: ${model2 ?? "default"}`;
+  return `Auto (${fallbackModel ?? "default"})`;
+}
+function summarizerStatusLine(chatId, adapter) {
+  const { config: config2, source } = getSummarizerWithSource(chatId);
+  const label2 = formatSummarizerLabel(config2.backend, config2.model, adapter?.summarizerModel);
+  if (source === "auto") return label2.toLowerCase();
+  return `${label2} (${source === "global" ? "global" : "per-chat"})`;
+}
 async function handleStatusCommand(chatId, commandArgs, msg, channel) {
   const sessionId = getSessionId(chatId);
   const cwd = getCwd(chatId);
@@ -29503,12 +30506,21 @@ async function handleStatusCommand(chatId, commandArgs, msg, channel) {
   const thinking2 = getThinkingLevel(chatId);
   const mode = getMode(chatId);
   const modelSig = getModelSignature(chatId);
-  const contextMax = adapter?.contextWindow[model2] ?? 2e5;
-  const contextUsed = usage2.context_size;
-  const contextPct = contextMax > 0 ? contextUsed / contextMax * 100 : 0;
-  const ctxBar = buildBar(contextPct);
-  const usedK = (contextUsed / 1e3).toFixed(1);
-  const maxK = (contextMax / 1e3).toFixed(0);
+  let contextLine;
+  if (adapter?.type === "api") {
+    const { estimateContextUsage: estimateContextUsage2 } = await Promise.resolve().then(() => (init_api_context(), api_context_exports));
+    const contextMax = adapter.contextWindow[model2] ?? 8192;
+    const ctxEst = estimateContextUsage2(chatId, contextMax);
+    const ctxBar = buildBar(ctxEst.percentage);
+    const usedK = (ctxEst.estimatedTokens / 1e3).toFixed(1);
+    const maxK = (contextMax / 1e3).toFixed(0);
+    contextLine = `\u{1F4D0} Context: ${ctxBar} ${usedK}K/${maxK}K (${ctxEst.percentage.toFixed(1)}%) \xB7 compacts at 85%`;
+  } else {
+    const pairCount = getMessagePairCount(chatId);
+    const threshold = 30;
+    const remaining = Math.max(0, threshold - pairCount);
+    contextLine = `\u{1F4D0} Session: ${pairCount}/${threshold} messages \xB7 compacts in ${remaining}`;
+  }
   const bootRow = getDb().prepare("SELECT value FROM meta WHERE key = 'boot_time'").get();
   let uptimeStr = "unknown";
   if (bootRow) {
@@ -29562,20 +30574,26 @@ async function handleStatusCommand(chatId, commandArgs, msg, channel) {
   const iDeep = iStats.agentic;
   const intentLine = iTotal > 0 ? `\u26A1 ${iTotal} messages: ${iQuick} quick, ${iDeep} deep` : `\u26A1 No messages classified yet`;
   const sqCount = getActiveSideQuestCount(chatId);
+  const { getPinnedSkills: getPinnedSkills2 } = await Promise.resolve().then(() => (init_chat_settings(), chat_settings_exports));
+  const pinnedSkills = getPinnedSkills2(chatId);
+  const pinnedLine = pinnedSkills.length > 0 ? `\u{1F4CC} Pinned: ${pinnedSkills.join(", ")}` : `\u{1F4CC} Pinned: none`;
   const lines = [
     `\u{1F43E} CC-Claw v${VERSION}`,
     `\u23F1 Uptime: ${uptimeStr}`,
+    isChatBusy(chatId) ? `\u{1F534} Agent: Busy` : `\u{1F7E2} Agent: Idle`,
     ``,
     buildSectionHeader("Engine"),
     `\u{1F9E0} ${adapter?.displayName ?? backendId ?? "not set"} \xB7 ${formatModelShort(model2)}${slotInfo}`,
     `\u{1F4AD} Think: ${thinking2} \xB7 Mode: ${mode}`,
     `\u{1F916} Agents: ${getAgentMode(chatId)}`,
+    pinnedLine,
     `\u{1F507} Voice: ${voice2 ? "on" : "off"} \xB7 Sig: ${modelSig}`,
+    `\u{1F4DD} Summarizer: ${summarizerStatusLine(chatId, adapter)}`,
     ``,
     buildSectionHeader("Session"),
     `\u{1F4CB} ${sessionId ?? "no active session"}`,
     `\u{1F4C1} ${cwd ?? "default workspace"}`,
-    `\u{1F4D0} Context: ${ctxBar} ${usedK}K/${maxK}K (${contextPct.toFixed(1)}%)`,
+    contextLine,
     ...sqCount > 0 ? [`\u{1F5FA} Side quests: ${sqCount} active`] : [],
     ``,
     buildSectionHeader("Usage"),
@@ -29614,11 +30632,16 @@ async function handleBackendCommand2(chatId, commandArgs, msg, channel) {
 async function handleBackendShortcutCommand(chatId, commandArgs, msg, channel) {
   const command = msg.command;
   const backendId = command;
-  if (getAllBackendIds().includes(backendId)) {
-    await sendBackendSwitchConfirmation(chatId, backendId, channel);
-  } else {
+  if (!getAllBackendIds().includes(backendId)) {
     await channel.sendText(chatId, `Backend "${command}" is not available.`, { parseMode: "plain" });
+    return;
   }
+  if (getDisabledBackends().includes(backendId)) {
+    const { sendBackendConfigPanel: sendBackendConfigPanel2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+    await sendBackendConfigPanel2(chatId, backendId, channel);
+    return;
+  }
+  await sendBackendSwitchConfirmation(chatId, backendId, channel);
 }
 async function handleModelCommand(chatId, commandArgs, msg, channel) {
   await sendModelKeyboard(chatId, channel);
@@ -29986,8 +31009,17 @@ async function handleSummarizerCommand(chatId, commandArgs, msg, channel) {
   } catch {
     adapter = null;
   }
-  const current = getSummarizer(chatId);
-  const currentLabel = current.backend === "off" ? "Off" : current.backend ? `${current.backend}:${current.model ?? "default"}` : `Auto (${adapter?.summarizerModel ?? "default"})`;
+  const { config: current, source, globalConfig } = getSummarizerWithSource(chatId);
+  const overrideCount = countSummarizerOverrides();
+  const currentLabel = formatSummarizerLabel(current.backend, current.model, adapter?.summarizerModel);
+  const sourceTag = source === "per-chat" ? "per-chat override" : source === "global" ? "global default" : "auto";
+  const headerLines = [`Summarizer: ${currentLabel} (${sourceTag})`];
+  if (globalConfig.backend) {
+    headerLines.push(`Global default: ${formatSummarizerLabel(globalConfig.backend, globalConfig.model)}`);
+  }
+  if (overrideCount > 0) {
+    headerLines.push(`${overrideCount} chat${overrideCount === 1 ? "" : "s"} with per-chat overrides`);
+  }
   if (typeof channel.sendKeyboard === "function") {
     const isAuto = !current.backend && current.backend !== "off";
     const isOff = current.backend === "off";
@@ -30035,7 +31067,14 @@ async function handleSummarizerCommand(chatId, commandArgs, msg, channel) {
         }]);
       }
     }
-    await channel.sendKeyboard(chatId, `Session summarizer (current: ${currentLabel}):`, buttons);
+    if (overrideCount > 0) {
+      buttons.push([{
+        label: `Clear All Overrides (${overrideCount})`,
+        data: "summarizer:clearall",
+        style: "danger"
+      }]);
+    }
+    await channel.sendKeyboard(chatId, headerLines.join("\n"), buttons);
   } else {
     await channel.sendText(chatId, `Summarizer: ${currentLabel}
 
@@ -30752,7 +31791,7 @@ __export(import_exports, {
   parseClaudeConfig: () => parseClaudeConfig,
   parseCursorConfig: () => parseCursorConfig
 });
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 import { join as join31 } from "path";
 import { homedir as homedir10 } from "os";
 function parseClaudeConfig(config2) {
@@ -30769,7 +31808,7 @@ async function discoverFromSource(source) {
     case "claude": {
       const path = join31(homedir10(), ".claude", "settings.json");
       try {
-        return parseClaudeConfig(JSON.parse(readFileSync20(path, "utf-8")));
+        return parseClaudeConfig(JSON.parse(readFileSync21(path, "utf-8")));
       } catch {
         warn(`[mcp-import] Could not read ${path}`);
         return [];
@@ -30778,7 +31817,7 @@ async function discoverFromSource(source) {
     case "cursor": {
       const path = join31(homedir10(), ".cursor", "mcp.json");
       try {
-        return parseCursorConfig(JSON.parse(readFileSync20(path, "utf-8")));
+        return parseCursorConfig(JSON.parse(readFileSync21(path, "utf-8")));
       } catch {
         warn(`[mcp-import] Could not read ${path}`);
         return [];
@@ -31442,6 +32481,10 @@ async function handleCallback(chatId, data, channel, messageId) {
   if (data.startsWith("backend:")) {
     const chosen = data.slice(8);
     if (!getAllBackendIds().includes(chosen)) return;
+    if (getDisabledBackends().includes(chosen)) {
+      await sendBackendConfigPanel(chatId, chosen, channel, messageId, false);
+      return;
+    }
     const previous = getBackend(chatId);
     if (chosen === previous) {
       await sendBackendConfigPanel(chatId, chosen, channel, messageId, false);
@@ -31495,6 +32538,32 @@ async function handleCallback(chatId, data, channel, messageId) {
         }
       }
       await sendBackendConfigPanel(chatId, backendId, channel, messageId, false);
+    } else if (rest.startsWith("disable:")) {
+      const backendId = rest.slice(8);
+      const { sendBackendDisableFlow: sendBackendDisableFlow2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+      await sendBackendDisableFlow2(chatId, backendId, channel, messageId);
+    } else if (rest.startsWith("enable:")) {
+      const backendId = rest.slice(7);
+      setBackendDisabled(backendId, false);
+      await sendBackendConfigPanel(chatId, backendId, channel, messageId, false);
+    } else if (rest.startsWith("reassign:")) {
+      const parts = rest.slice(9).split(":");
+      const disablingBackend = parts[0];
+      const targetBackend = parts[1];
+      const current = getBackend(chatId);
+      const { executeBackendDisable: executeBackendDisable2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+      await executeBackendDisable2(chatId, disablingBackend, channel, messageId, {
+        reassignTo: targetBackend,
+        ...current === disablingBackend ? { switchTo: targetBackend } : {}
+      });
+    } else if (rest.startsWith("disableswitch:")) {
+      const parts = rest.slice(14).split(":");
+      const disablingBackend = parts[0];
+      const switchToBackend = parts[1];
+      const { executeBackendDisable: executeBackendDisable2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+      await executeBackendDisable2(chatId, disablingBackend, channel, messageId, {
+        switchTo: switchToBackend
+      });
     }
   } else if (data.startsWith("backend_confirm_clear:")) {
     const target = data.slice("backend_confirm_clear:".length);
@@ -31558,14 +32627,40 @@ ${value ? "Full tool inputs/results will be saved to ~/.cc-claw/logs/sessions/"
     if (rest === "auto") {
       clearSummarizer(chatId);
       await channel.sendText(chatId, "Summarizer set to auto (uses active backend).", { parseMode: "plain" });
-    } else if (rest === "off") {
-      setSummarizer(chatId, "off", null);
-      await channel.sendText(chatId, "Session summarization disabled.", { parseMode: "plain" });
+    } else if (rest === "clearall") {
+      const cleared = clearAllSummarizerOverrides();
+      await channel.sendText(chatId, `Cleared ${cleared} per-chat override${cleared === 1 ? "" : "s"}. All chats now use the global default.`, { parseMode: "plain" });
+    } else if (rest.startsWith("promote:")) {
+      const promoteValue = rest.slice(8);
+      const db3 = getDb();
+      const promote = db3.transaction(() => {
+        if (promoteValue === "off") {
+          setGlobalSummarizer("off", null);
+        } else {
+          const [bk, ...modelParts] = promoteValue.split(":");
+          setGlobalSummarizer(bk, modelParts.join(":") || null);
+        }
+        return clearAllSummarizerOverrides();
+      });
+      const cleared = promote();
+      const label2 = promoteValue === "off" ? "Off" : promoteValue;
+      const clearedNote = cleared > 0 ? ` Cleared ${cleared} per-chat override${cleared === 1 ? "" : "s"}.` : "";
+      await channel.sendText(chatId, `Global summarizer set to ${label2}.${clearedNote} All chats now use this default.`, { parseMode: "plain" });
     } else {
-      const [bk, ...modelParts] = rest.split(":");
-      const mdl = modelParts.join(":") || null;
+      const isOff = rest === "off";
+      const bk = isOff ? "off" : rest.split(":")[0];
+      const mdl = isOff ? null : rest.split(":").slice(1).join(":") || null;
       setSummarizer(chatId, bk, mdl);
-      await channel.sendText(chatId, `Summarizer pinned to ${bk}:${mdl ?? "default"}.`, { parseMode: "plain" });
+      const displayLabel = isOff ? "Off" : `${bk}:${mdl ?? "default"}`;
+      const confirmMsg = isOff ? "Session summarization disabled for this chat." : `Summarizer pinned to ${displayLabel} for this chat.`;
+      const promoteData = `summarizer:promote:${rest}`;
+      if (typeof channel.sendKeyboard === "function") {
+        await channel.sendKeyboard(chatId, confirmMsg, [
+          [{ label: "Set as Global Default", data: promoteData }]
+        ]);
+      } else {
+        await channel.sendText(chatId, confirmMsg, { parseMode: "plain" });
+      }
     }
   } else if (data.startsWith("perms:")) {
     let chosen = data.slice(6);
@@ -33309,10 +34404,10 @@ ${formatValidationReport2(validation)}` : "\n\n\u2705 Quality checks passed.";
       return;
     }
     try {
-      const { readFileSync: readFileSync35, writeFileSync: writeFileSync16 } = await import("fs");
+      const { readFileSync: readFileSync36, writeFileSync: writeFileSync16 } = await import("fs");
       const { updateFrontmatter: updateFrontmatter2, ensureThreeTierFrontmatter: ensureThreeTierFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
       const { invalidateSkillCache: invalidateSkillCache2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
-      const raw = readFileSync35(skill.filePath, "utf-8");
+      const raw = readFileSync36(skill.filePath, "utf-8");
       let updated = ensureThreeTierFrontmatter2(raw, { name: skillName, source: "cc-claw" });
       updated = updateFrontmatter2(updated, { status: "approved" });
       writeFileSync16(skill.filePath, updated, "utf-8");
@@ -33362,14 +34457,14 @@ ${stillUnapproved.length} more skill${stillUnapproved.length !== 1 ? "s" : ""} t
       return;
     }
     try {
-      const { readFileSync: readFileSync35, writeFileSync: writeFileSync16 } = await import("fs");
+      const { readFileSync: readFileSync36, writeFileSync: writeFileSync16 } = await import("fs");
       const { updateFrontmatter: updateFrontmatter2, ensureThreeTierFrontmatter: ensureThreeTierFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
       const { invalidateSkillCache: invalidateSkillCache2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
       let approvedCount = 0;
       const issues = [];
       for (const skill of unapproved) {
         try {
-          const raw = readFileSync35(skill.filePath, "utf-8");
+          const raw = readFileSync36(skill.filePath, "utf-8");
           let updated = ensureThreeTierFrontmatter2(raw, { name: skill.name, source: "cc-claw" });
           updated = updateFrontmatter2(updated, { status: "approved" });
           writeFileSync16(skill.filePath, updated, "utf-8");
@@ -33403,6 +34498,29 @@ ${issues.join("\n")}`;
       );
     }
     return;
+  } else if (data.startsWith("pin:")) {
+    const skillName = data.slice(4);
+    const { getPinnedSkills: getPinnedSkills2, setPinnedSkills: setPinnedSkills2 } = await Promise.resolve().then(() => (init_chat_settings(), chat_settings_exports));
+    const pinned = getPinnedSkills2(chatId);
+    if (pinned.includes(skillName)) {
+      setPinnedSkills2(chatId, pinned.filter((n) => n !== skillName));
+      await sendOrEditKeyboard(
+        chatId,
+        channel,
+        messageId,
+        `\u{1F4CC} Unpinned "${skillName}" from this chat.`,
+        [[{ label: "\u2190 Skills", data: "skills:page:1" }]]
+      );
+    } else {
+      setPinnedSkills2(chatId, [...pinned, skillName]);
+      await sendOrEditKeyboard(
+        chatId,
+        channel,
+        messageId,
+        `\u{1F4CC} Pinned "${skillName}" to this chat. It will always inject regardless of message content.`,
+        [[{ label: "\u2190 Skills", data: "skills:page:1" }]]
+      );
+    }
   } else if (data.startsWith("skill:")) {
     const parts = data.slice(6).split(":");
     let skillName;
@@ -33610,134 +34728,6 @@ var init_thread_wrapper = __esm({
   }
 });
 
-// src/intent/complexity.ts
-var complexity_exports = {};
-__export(complexity_exports, {
-  classifyComplexity: () => classifyComplexity
-});
-function wordCount(text) {
-  return text.trim().split(/\s+/).filter(Boolean).length;
-}
-function classifyComplexity(text) {
-  const trimmed = text.trim();
-  const lower = trimmed.toLowerCase();
-  const words = wordCount(trimmed);
-  if (TRIVIAL_EXACT.has(lower)) {
-    log(`[complexity] "${lower}" -> trivial (exact match)`);
-    return "trivial";
-  }
-  if (trimmed.length <= 4 && /^[\p{Emoji}\s]+$/u.test(trimmed)) {
-    log(`[complexity] "${trimmed}" -> trivial (emoji-only)`);
-    return "trivial";
-  }
-  if (COMPLEX_SIGNALS.test(trimmed) && (words > 15 || trimmed.length > 200)) {
-    log(`[complexity] "${trimmed.slice(0, 40)}..." -> complex (signal words + length)`);
-    return "complex";
-  }
-  if (MUTATION_VERBS.test(trimmed)) {
-    const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
-    log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (mutation verb)`);
-    return tier;
-  }
-  for (const pattern of CODE_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
-      log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (code pattern)`);
-      return tier;
-    }
-  }
-  if (trimmed.length > 200 || words > 25) {
-    const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
-    log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (long message)`);
-    return tier;
-  }
-  for (const pattern of QUESTION_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      log(`[complexity] "${trimmed.slice(0, 40)}..." -> simple (question)`);
-      return "simple";
-    }
-  }
-  log(`[complexity] "${trimmed.slice(0, 40)}..." -> moderate (default)`);
-  return "moderate";
-}
-var TRIVIAL_EXACT, COMPLEX_SIGNALS, MUTATION_VERBS, CODE_PATTERNS, QUESTION_PATTERNS;
-var init_complexity = __esm({
-  "src/intent/complexity.ts"() {
-    "use strict";
-    init_log();
-    TRIVIAL_EXACT = /* @__PURE__ */ new Set([
-      "hey",
-      "hi",
-      "hello",
-      "yo",
-      "sup",
-      "howdy",
-      "hiya",
-      "thanks",
-      "thank you",
-      "thx",
-      "ty",
-      "thank u",
-      "ok",
-      "okay",
-      "k",
-      "kk",
-      "cool",
-      "nice",
-      "great",
-      "awesome",
-      "perfect",
-      "good morning",
-      "good night",
-      "good evening",
-      "gm",
-      "gn",
-      "bye",
-      "goodbye",
-      "later",
-      "see ya",
-      "cya",
-      "lol",
-      "lmao",
-      "haha",
-      "heh",
-      "np",
-      "no problem",
-      "no worries",
-      "nw",
-      "got it",
-      "understood",
-      "roger",
-      "copy",
-      "good",
-      "fine",
-      "alright",
-      "sure",
-      "yes",
-      "no",
-      "yep",
-      "nope",
-      "yeah",
-      "nah"
-    ]);
-    COMPLEX_SIGNALS = /\b(architect|design|research|plan|strategy|migration|microservice|distributed|end-to-end|trade-offs|pros\s+and\s+cons)\b/i;
-    MUTATION_VERBS = /\b(fix|create|build|deploy|refactor|implement|write|add|update|edit|test|debug)\b/i;
-    CODE_PATTERNS = [
-      /```/,
-      // code blocks
-      /\.[a-z]{1,5}\b/,
-      // file extensions (.ts, .py, .json)
-      /[/\\][\w.-]+/
-      // file paths (/src/foo, .\bar)
-    ];
-    QUESTION_PATTERNS = [
-      /^(?:what|which|where|when|why|how)\b/i,
-      /^(?:show|tell|list|explain)\b/i,
-      /^(?:is|are)\b/i
-    ];
-  }
-});
-
 // src/intent/auto-route.ts
 var auto_route_exports = {};
 __export(auto_route_exports, {
@@ -34564,6 +35554,8 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
     return;
   }
   getTypingManager().acquire(chatId, channel);
+  let stopDraftTimer = () => {
+  };
   try {
     const tMode = settings.getMode();
     const tVerbose = settings.getVerboseLevel();
@@ -34623,7 +35615,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         draftState.dirty = true;
       };
     }
-    const stopDraftTimer2 = () => {
+    stopDraftTimer = () => {
       if (draftState?.flushTimer) {
         clearInterval(draftState.flushTimer);
         draftState.flushTimer = null;
@@ -34659,9 +35651,14 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         } catch {
         }
       },
-      onCompaction: (cid) => {
-        channel.sendText(cid, "\u{1F4BE} Context saved to memory.").catch(() => {
-        });
+      onCompaction: (cid, phase) => {
+        if (phase === "triggered") {
+          channel.sendText(cid, "\u{1F4BE} Context compaction triggered \u2014 saving conversation to memory...").catch(() => {
+          });
+        } else {
+          channel.sendText(cid, "\u{1F4BE} Context saved to memory.").catch(() => {
+          });
+        }
       },
       onSlotRotation: (cid, from, to) => {
         const slots = getGeminiSlots();
@@ -34679,7 +35676,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         });
       }
     });
-    stopDraftTimer2();
+    stopDraftTimer();
     const elapsedMs = Date.now() - sigT0;
     const elapsedSec = (elapsedMs / 1e3).toFixed(1);
     if (liveStatus && response.thinkingText?.trim()) {
@@ -35081,6 +36078,12 @@ async function executeJob(job) {
   log(`[scheduler] Running job #${job.id}: ${job.description} (model=${resolvedModel})`);
   try {
     const backendId = resolveJobBackendId(job);
+    if (getDisabledBackends().includes(backendId)) {
+      const msg = `Backend "${backendId}" is disabled. Reassign this job with /editjob or re-enable the backend.`;
+      completeJobRun(runId, "skipped", { error: msg, durationMs: Date.now() - t0 });
+      await notifyJobFailure(job, msg);
+      return;
+    }
     const limitMsg = checkBackendLimits(backendId);
     if (limitMsg) {
       completeJobRun(runId, "skipped", { error: limitMsg, durationMs: Date.now() - t0 });
@@ -35511,7 +36514,7 @@ var init_wrap_backend = __esm({
 });
 
 // src/agents/runners/config-loader.ts
-import { readFileSync as readFileSync21, readdirSync as readdirSync14, existsSync as existsSync30, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
+import { readFileSync as readFileSync22, readdirSync as readdirSync14, existsSync as existsSync30, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
 import { join as join33 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 function resolveExecutable2(config2) {
@@ -35653,7 +36656,7 @@ function configToRunner(config2) {
 }
 function loadRunnerConfig(filePath) {
   try {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     warn(`[runners] Failed to load config ${filePath}: ${err}`);
@@ -36269,7 +37272,7 @@ var init_telegram2 = __esm({
         };
       }
       async start(handler) {
-        await this.bot.api.setMyCommands([
+        await this.throttle.send(this.primaryChatId, "setMyCommands", () => this.bot.api.setMyCommands([
           // Core
           { command: "menu", description: "Home screen \u2014 quick-access keyboard" },
           { command: "m", description: "Home screen (alias for /menu)" },
@@ -36347,7 +37350,7 @@ var init_telegram2 = __esm({
           // Context & info
           { command: "info", description: "Current chat context (ID, topic, sender, settings)" },
           { command: "council", description: "Multi-model debate (select models, anonymous rounds)" }
-        ]);
+        ]));
         this.bot.on("message", async (ctx) => {
           const chatId = ctx.chat.id.toString();
           const senderId = ctx.from?.id?.toString() ?? "";
@@ -36393,15 +37396,13 @@ var init_telegram2 = __esm({
           const chatId = ctx.callbackQuery.message?.chat?.id?.toString() ?? userId;
           log(`[telegram] Callback from user ${userId} in chat ${chatId}: ${ctx.callbackQuery.data}`);
           if (!this.isAuthorized(userId) && !this.isAuthorized(chatId)) {
-            ctx.answerCallbackQuery("Unauthorized").catch(() => {
-            });
+            this.throttle.tryBestEffort(chatId, "answerCallbackQuery:unauth", () => ctx.answerCallbackQuery("Unauthorized"));
             return;
           }
           const data = ctx.callbackQuery.data;
           const messageId = ctx.callbackQuery.message?.message_id?.toString();
           const threadId = ctx.callbackQuery.message?.message_thread_id;
-          ctx.answerCallbackQuery().catch(() => {
-          });
+          this.throttle.tryBestEffort(chatId, "answerCallbackQuery", () => ctx.answerCallbackQuery());
           (async () => {
             let ch = this;
             if (threadId) {
@@ -36450,7 +37451,7 @@ var init_telegram2 = __esm({
         this.keepaliveInterval = setInterval(async () => {
           if (!this.pollingExpected) return;
           try {
-            await this.bot.api.getMe();
+            await this.throttle.tryBestEffort(this.primaryChatId, "getMe:keepalive", () => this.bot.api.getMe());
             this.lastPollingCheckAt = Date.now();
           } catch (err) {
             error("[telegram] Keepalive ping failed:", err);
@@ -36590,7 +37591,7 @@ var init_telegram2 = __esm({
         );
       }
       async downloadFile(fileId) {
-        const file = await this.bot.api.getFile(fileId);
+        const file = await this.throttle.send(this.primaryChatId, "getFile", () => this.bot.api.getFile(fileId));
         const fileUrl = `https://api.telegram.org/file/bot${process.env.TELEGRAM_BOT_TOKEN}/${file.file_path}`;
         const response = await fetch(fileUrl);
         return Buffer.from(await response.arrayBuffer());
@@ -36879,7 +37880,11 @@ var init_telegram2 = __esm({
             }
           }
         }
-        await ctx.answerInlineQuery(results.slice(0, 10), { cache_time: 30 });
+        await this.throttle.tryBestEffort(
+          this.primaryChatId,
+          "answerInlineQuery",
+          () => ctx.answerInlineQuery(results.slice(0, 10), { cache_time: 30 })
+        );
       }
       trackAgentMessage(messageId, chatId) {
         if (this.agentMessageIds.size >= 1e4) {
@@ -37066,7 +38071,7 @@ var init_telegram2 = __esm({
 });
 
 // src/skills/bootstrap.ts
-import { existsSync as existsSync31, readFileSync as readFileSync22, writeFileSync as writeFileSync10, copyFileSync as copyFileSync3, readdirSync as readdirSync15 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync23, writeFileSync as writeFileSync10, copyFileSync as copyFileSync3, readdirSync as readdirSync15 } from "fs";
 import { readdir as readdir6, copyFile } from "fs/promises";
 import { join as join34, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -37115,7 +38120,7 @@ function migrateSkillsToThreeTier() {
     }
     if (!skillPath) continue;
     try {
-      const raw = readFileSync22(skillPath, "utf-8");
+      const raw = readFileSync23(skillPath, "utf-8");
       const fmMatch = raw.match(/^---\s*\n([\s\S]*?)\n---/);
       if (fmMatch) {
         const fm = fmMatch[1];
@@ -37758,7 +38763,7 @@ var index_exports = {};
 __export(index_exports, {
   main: () => main
 });
-import { mkdirSync as mkdirSync12, existsSync as existsSync33, renameSync as renameSync2, statSync as statSync9, readFileSync as readFileSync24 } from "fs";
+import { mkdirSync as mkdirSync12, existsSync as existsSync33, renameSync as renameSync2, statSync as statSync9, readFileSync as readFileSync25 } from "fs";
 import { join as join36 } from "path";
 import dotenv from "dotenv";
 function migrateLayout() {
@@ -37801,7 +38806,7 @@ async function main() {
   let version = "unknown";
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    version = JSON.parse(readFileSync24(pkgPath, "utf-8")).version;
+    version = JSON.parse(readFileSync25(pkgPath, "utf-8")).version;
   } catch {
   }
   log(`[cc-claw] Starting v${version}`);
@@ -38029,6 +39034,11 @@ ${lines.join("\n")}`;
   log("[cc-claw] Ready!");
   const shutdown = async (signal) => {
     log(`[cc-claw] Received ${signal}, shutting down...`);
+    const forceExit = setTimeout(() => {
+      error("[cc-claw] Shutdown timed out after 30s \u2014 forcing exit.");
+      process.exit(1);
+    }, 3e4);
+    forceExit.unref();
     try {
       const { stopAllActiveAgents: stopAllActiveAgents2, stopStaleChatSweep: stopStaleChatSweep2 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
       stopAllActiveAgents2();
@@ -38540,13 +39550,13 @@ var init_daemon = __esm({
 });
 
 // src/cli/resolve-chat.ts
-import { readFileSync as readFileSync26 } from "fs";
+import { readFileSync as readFileSync27 } from "fs";
 function resolveChatId2(globalOpts) {
   const explicit = globalOpts.chat;
   if (explicit) return explicit;
   if (_cachedDefault) return _cachedDefault;
   try {
-    const content = readFileSync26(ENV_PATH, "utf-8");
+    const content = readFileSync27(ENV_PATH, "utf-8");
     const match = content.match(/^ALLOWED_CHAT_ID=(.+)$/m);
     if (match) {
       _cachedDefault = match[1].split(",")[0].trim();
@@ -39008,7 +40018,7 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import { existsSync as existsSync37, readFileSync as readFileSync28, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync29, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
 async function logsCommand(opts) {
   const logFile = opts.error ? ERROR_LOG_PATH : LOG_PATH;
   if (!existsSync37(logFile)) {
@@ -39016,7 +40026,7 @@ async function logsCommand(opts) {
     process.exit(1);
   }
   const maxLines = parseInt(opts.lines ?? "100", 10);
-  const content = readFileSync28(logFile, "utf-8");
+  const content = readFileSync29(logFile, "utf-8");
   const allLines = content.split("\n");
   const tailLines = allLines.slice(-maxLines);
   console.log(muted(`  \u2500\u2500 ${logFile} (last ${tailLines.length} lines) \u2500\u2500`));
@@ -39027,7 +40037,7 @@ async function logsCommand(opts) {
     let lastLength = content.length;
     watchFile2(logFile, { interval: 500 }, () => {
       try {
-        const newContent = readFileSync28(logFile, "utf-8");
+        const newContent = readFileSync29(logFile, "utf-8");
         if (newContent.length > lastLength) {
           const newPart = newContent.slice(lastLength);
           process.stdout.write(newPart);
@@ -39059,7 +40069,7 @@ __export(session_logs_exports, {
   sessionLogsList: () => sessionLogsList,
   sessionLogsTail: () => sessionLogsTail
 });
-import { readFileSync as readFileSync29, watchFile as watchFile3, unwatchFile as unwatchFile3 } from "fs";
+import { readFileSync as readFileSync30, watchFile as watchFile3, unwatchFile as unwatchFile3 } from "fs";
 async function sessionLogsList(opts) {
   const logs = listSessionLogs();
   if (logs.length === 0) {
@@ -39117,12 +40127,12 @@ async function sessionLogsTail(opts) {
     console.log(muted("\n  Following... (Ctrl+C to stop)\n"));
     let lastLength = 0;
     try {
-      lastLength = readFileSync29(targetPath, "utf-8").length;
+      lastLength = readFileSync30(targetPath, "utf-8").length;
     } catch {
     }
     watchFile3(targetPath, { interval: 500 }, () => {
       try {
-        const content = readFileSync29(targetPath, "utf-8");
+        const content = readFileSync30(targetPath, "utf-8");
         if (content.length > lastLength) {
           process.stdout.write(content.slice(lastLength));
           lastLength = content.length;
@@ -39166,7 +40176,7 @@ __export(gemini_exports, {
   geminiReorder: () => geminiReorder,
   geminiRotation: () => geminiRotation
 });
-import { existsSync as existsSync39, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13, readFileSync as readFileSync30, chmodSync } from "fs";
+import { existsSync as existsSync39, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13, readFileSync as readFileSync31, chmodSync } from "fs";
 import { join as join38 } from "path";
 import { createInterface as createInterface8 } from "readline";
 function requireDb() {
@@ -39197,7 +40207,7 @@ function resolveOAuthEmail(configHome) {
   try {
     const accountsPath = join38(configHome, ".gemini", "google_accounts.json");
     if (!existsSync39(accountsPath)) return null;
-    const accounts = JSON.parse(readFileSync30(accountsPath, "utf-8"));
+    const accounts = JSON.parse(readFileSync31(accountsPath, "utf-8"));
     return accounts.active || null;
   } catch {
     return null;
@@ -39460,7 +40470,7 @@ async function geminiRelogin(globalOpts, idOrLabel) {
   setGeminiSlotEnabled2(slotId, true);
   let accountEmail = slot.label;
   try {
-    const accounts = JSON.parse(readFileSync30(join38(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(readFileSync31(join38(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
     if (accounts.active) accountEmail = accounts.active;
   } catch {
   }
@@ -39519,7 +40529,7 @@ __export(backend_cmd_factory_exports, {
   makeReorder: () => makeReorder,
   registerBackendSlotCommands: () => registerBackendSlotCommands
 });
-import { existsSync as existsSync40, mkdirSync as mkdirSync15, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync40, mkdirSync as mkdirSync15, readFileSync as readFileSync32 } from "fs";
 import { join as join39 } from "path";
 import { createInterface as createInterface9 } from "readline";
 function requireDb2() {
@@ -39873,7 +40883,7 @@ var init_backend_cmd_factory = __esm({
           const claudeJsonNested = join39(slotDir, ".claude", ".claude.json");
           if (existsSync40(claudeJson)) {
             try {
-              const data = JSON.parse(readFileSync31(claudeJson, "utf-8"));
+              const data = JSON.parse(readFileSync32(claudeJson, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
@@ -39881,7 +40891,7 @@ var init_backend_cmd_factory = __esm({
           }
           if (existsSync40(claudeJsonNested)) {
             try {
-              const data = JSON.parse(readFileSync31(claudeJsonNested, "utf-8"));
+              const data = JSON.parse(readFileSync32(claudeJsonNested, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
@@ -39904,7 +40914,7 @@ var init_backend_cmd_factory = __esm({
           try {
             const claudeJson = join39(slotDir, ".claude.json");
             if (existsSync40(claudeJson)) {
-              const data = JSON.parse(readFileSync31(claudeJson, "utf-8"));
+              const data = JSON.parse(readFileSync32(claudeJson, "utf-8"));
               if (data.oauthAccount?.emailAddress) return data.oauthAccount.emailAddress;
             }
           } catch {
@@ -39923,7 +40933,7 @@ var init_backend_cmd_factory = __esm({
         },
         extractLabel: (slotDir) => {
           try {
-            const authData = JSON.parse(readFileSync31(join39(slotDir, "auth.json"), "utf-8"));
+            const authData = JSON.parse(readFileSync32(join39(slotDir, "auth.json"), "utf-8"));
             if (authData.email) return authData.email;
             if (authData.account_name) return authData.account_name;
             if (authData.user?.email) return authData.user.email;
@@ -41290,7 +42300,7 @@ __export(config_exports2, {
   configList: () => configList,
   configSet: () => configSet
 });
-import { existsSync as existsSync49, readFileSync as readFileSync32 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync33 } from "fs";
 async function configList(globalOpts) {
   if (!existsSync49(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
@@ -41376,7 +42386,7 @@ async function configEnv(_globalOpts) {
     outputError("ENV_NOT_FOUND", `No .env file at ${ENV_PATH}. Run cc-claw setup.`);
     process.exit(1);
   }
-  const content = readFileSync32(ENV_PATH, "utf-8");
+  const content = readFileSync33(ENV_PATH, "utf-8");
   const entries = {};
   const secretPatterns = /TOKEN|KEY|SECRET|PASSWORD|CREDENTIALS/i;
   for (const line of content.split("\n")) {
@@ -42372,11 +43382,11 @@ __export(chat_exports2, {
   chatSend: () => chatSend
 });
 import { request as httpRequest2 } from "http";
-import { readFileSync as readFileSync33, existsSync as existsSync59 } from "fs";
+import { readFileSync as readFileSync34, existsSync as existsSync59 } from "fs";
 function getToken2() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync59(TOKEN_PATH)) return readFileSync33(TOKEN_PATH, "utf-8").trim();
+    if (existsSync59(TOKEN_PATH)) return readFileSync34(TOKEN_PATH, "utf-8").trim();
   } catch {
   }
   return null;
@@ -43533,7 +44543,7 @@ var init_optimize3 = __esm({
 
 // src/setup.ts
 var setup_exports = {};
-import { existsSync as existsSync61, writeFileSync as writeFileSync15, readFileSync as readFileSync34, copyFileSync as copyFileSync5, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
+import { existsSync as existsSync61, writeFileSync as writeFileSync15, readFileSync as readFileSync35, copyFileSync as copyFileSync5, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
 import { execFileSync as execFileSync6 } from "child_process";
 import { createInterface as createInterface11 } from "readline";
 import { join as join41 } from "path";
@@ -43625,7 +44635,7 @@ async function setup() {
   if (envSource) {
     console.log(yellow(`  Found existing config at ${envSource} \u2014 your values will be preserved`));
     console.log(yellow("  unless you enter new ones. Just press Enter to keep existing values.\n"));
-    const existing = readFileSync34(envSource, "utf-8");
+    const existing = readFileSync35(envSource, "utf-8");
     for (const line of existing.split("\n")) {
       const match = line.match(/^([^#=]+)=(.*)$/);
       if (match) env[match[1].trim()] = match[2].trim();