cc-claw 0.29.3 → 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.3" : (() => {
+    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;
   }
 });
 
@@ -2819,6 +2920,7 @@ __export(chat_settings_exports, {
   clearExecMode: () => clearExecMode,
   clearModel: () => clearModel,
   clearModelMap: () => clearModelMap,
+  clearPinnedSkills: () => clearPinnedSkills,
   clearSummarizer: () => clearSummarizer,
   clearThinkingLevel: () => clearThinkingLevel,
   countSummarizerOverrides: () => countSummarizerOverrides,
@@ -2837,6 +2939,7 @@ __export(chat_settings_exports, {
   getMode: () => getMode,
   getModel: () => getModel,
   getPendingEscalation: () => getPendingEscalation,
+  getPinnedSkills: () => getPinnedSkills,
   getRecentBookmarks: () => getRecentBookmarks,
   getSessionLogEnabled: () => getSessionLogEnabled,
   getShowThinkingUi: () => getShowThinkingUi,
@@ -2856,6 +2959,7 @@ __export(chat_settings_exports, {
   setGlobalSummarizer: () => setGlobalSummarizer,
   setMode: () => setMode,
   setModel: () => setModel,
+  setPinnedSkills: () => setPinnedSkills,
   setSessionLogEnabled: () => setSessionLogEnabled,
   setShowThinkingUi: () => setShowThinkingUi,
   setSkillSuggestionsEnabled: () => setSkillSuggestionsEnabled,
@@ -3265,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 = ?"
@@ -3648,6 +3773,7 @@ __export(jobs_exports, {
   cancelJobById: () => cancelJobById,
   completeJobRun: () => completeJobRun,
   getActiveJobs: () => getActiveJobs,
+  getActiveJobsByBackend: () => getActiveJobsByBackend,
   getAllJobs: () => getAllJobs,
   getJobById: () => getJobById,
   getJobRuns: () => getJobRuns,
@@ -3655,6 +3781,7 @@ __export(jobs_exports, {
   insertJob: () => insertJob,
   insertJobRun: () => insertJobRun,
   pruneJobRuns: () => pruneJobRuns,
+  reassignJobsBackend: () => reassignJobsBackend,
   resetJobFailures: () => resetJobFailures,
   updateJob: () => updateJob,
   updateJobEnabled: () => updateJobEnabled,
@@ -3711,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;
@@ -4904,6 +5040,7 @@ __export(store_exports5, {
   clearMessageLog: () => clearMessageLog,
   clearModel: () => clearModel,
   clearModelMap: () => clearModelMap,
+  clearPinnedSkills: () => clearPinnedSkills,
   clearSession: () => clearSession,
   clearSummarizer: () => clearSummarizer,
   clearThinkingLevel: () => clearThinkingLevel,
@@ -4922,6 +5059,7 @@ __export(store_exports5, {
   forget: () => forget,
   forgetMemory: () => forgetMemory,
   getActiveJobs: () => getActiveJobs,
+  getActiveJobsByBackend: () => getActiveJobsByBackend,
   getActiveWatches: () => getActiveWatches,
   getAgentMode: () => getAgentMode,
   getAllBackendLimits: () => getAllBackendLimits,
@@ -4948,6 +5086,7 @@ __export(store_exports5, {
   getChatUsageByModel: () => getChatUsageByModel,
   getCwd: () => getCwd,
   getDb: () => getDb,
+  getDisabledBackends: () => getDisabledBackends,
   getEligibleBackendSlots: () => getEligibleBackendSlots,
   getEligibleGeminiSlots: () => getEligibleGeminiSlots,
   getEnabledTools: () => getEnabledTools,
@@ -4969,6 +5108,7 @@ __export(store_exports5, {
   getNextBackendSlot: () => getNextBackendSlot,
   getNextGeminiSlot: () => getNextGeminiSlot,
   getPendingEscalation: () => getPendingEscalation,
+  getPinnedSkills: () => getPinnedSkills,
   getRecentBookmarks: () => getRecentBookmarks,
   getRecentMemories: () => getRecentMemories,
   getRecentMessageLog: () => getRecentMessageLog,
@@ -5010,6 +5150,7 @@ __export(store_exports5, {
   pruneJobRuns: () => pruneJobRuns,
   pruneMessageLog: () => pruneMessageLog,
   queueHalfLifeExtension: () => queueHalfLifeExtension,
+  reassignJobsBackend: () => reassignJobsBackend,
   recall: () => recall,
   reenableBackendSlot: () => reenableBackendSlot,
   reenableSlot: () => reenableSlot,
@@ -5041,6 +5182,7 @@ __export(store_exports5, {
   setAgentMode: () => setAgentMode,
   setAllowPaidSlots: () => setAllowPaidSlots,
   setBackend: () => setBackend,
+  setBackendDisabled: () => setBackendDisabled,
   setBackendLimit: () => setBackendLimit,
   setBackendRotationMode: () => setBackendRotationMode,
   setBackendSlotEnabled: () => setBackendSlotEnabled,
@@ -5056,6 +5198,7 @@ __export(store_exports5, {
   setMode: () => setMode,
   setModel: () => setModel,
   setModelSignature: () => setModelSignature,
+  setPinnedSkills: () => setPinnedSkills,
   setResponseStyle: () => setResponseStyle,
   setSessionId: () => setSessionId,
   setSessionLogEnabled: () => setSessionLogEnabled,
@@ -5087,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);
 }
@@ -5102,6 +5246,7 @@ function getDb() {
 function _setDbForTesting(testDb) {
   db = testDb;
   _testDbPath = testDb.name;
+  _setSchemaDbGetter(() => db);
 }
 var db, _testDbPath;
 var init_store5 = __esm({
@@ -7618,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, {
@@ -7645,6 +7836,7 @@ 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;
@@ -7826,7 +8018,7 @@ 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 (pause remains until ${new Date(this.pausedUntil).toISOString()})`);
+                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");
                 break;
               }
@@ -8669,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"() {
@@ -8684,6 +8940,7 @@ var discover_exports = {};
 __export(discover_exports, {
   discoverAllSkills: () => discoverAllSkills,
   invalidateSkillCache: () => invalidateSkillCache,
+  parseFrontmatter: () => parseFrontmatter,
   resolveSkillForTask: () => resolveSkillForTask,
   stripFrontmatter: () => stripFrontmatter
 });
@@ -8756,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;
@@ -8788,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) {
@@ -8803,7 +9062,8 @@ function mergeAndDeduplicate(raw) {
           contentHash: hash,
           type: primary.type,
           status: primary.status,
-          requires: primary.requires
+          requires: primary.requires,
+          triggers: primary.triggers
         });
       }
     }
@@ -8823,7 +9083,8 @@ function parseFrontmatter(content, fallbackName, source) {
       description: "",
       type: "tool",
       status: source === "cc-claw" ? "imported" : "external",
-      requires: []
+      requires: [],
+      triggers: []
     };
   }
   const fm = fmMatch[1];
@@ -8849,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) {
@@ -8865,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`);
@@ -11330,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.
@@ -11361,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
@@ -11447,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>
 
@@ -11486,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();
@@ -11544,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>
@@ -11727,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",
     "",
@@ -11749,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({
@@ -11761,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();
@@ -11775,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 stripFrontmatter3(content) {
-  if (!content.startsWith("---")) return content;
-  const end = content.indexOf("---", 3);
-  return end === -1 ? content : content.slice(end + 3).trim();
+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 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;
@@ -11797,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;
       }
@@ -11809,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()) {
@@ -11832,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) {
@@ -11855,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") {
@@ -11893,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") {
@@ -12064,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";
@@ -12077,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;
@@ -12119,7 +12830,8 @@ __export(client_exports, {
   listModels: () => listModels,
   ping: () => ping,
   runningModels: () => runningModels,
-  showModel: () => showModel
+  showModel: () => showModel,
+  unloadModel: () => unloadModel
 });
 function buildHeaders(apiKey) {
   const headers = {
@@ -12205,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,
@@ -12892,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);
@@ -13082,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)) {
@@ -13880,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;
@@ -13887,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) {
@@ -13941,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,
@@ -14019,9 +14781,11 @@ function killProcessGroup(proc, signal = "SIGTERM") {
 function runCompaction(chatId, reason, onCompaction) {
   return summarizeWithFallbackChain(chatId).then((saved) => {
     if (saved) {
-      clearSession(chatId);
-      clearUsage(chatId);
-      onCompaction?.(chatId);
+      return withChatLock(chatId, async () => {
+        clearSession(chatId);
+        clearUsage(chatId);
+        onCompaction?.(chatId);
+      });
     }
   }).catch((err) => {
     warn(`[agent] Compaction failed for ${chatId} (${reason}): ${err}`);
@@ -14084,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) {
@@ -14095,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,
@@ -14204,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;
@@ -14401,6 +15173,7 @@ Partial output: ${accumulatedText.slice(-500)}`;
         return;
       }
       const cleanedResult = stripThinkingContent(resultText || accumulatedText);
+      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 });
     });
   });
@@ -14609,14 +15382,14 @@ 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;
@@ -14676,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({
@@ -14917,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);
@@ -14966,9 +15749,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 pairCount = profile !== "chat" ? getMessagePairCount(chatId) : 0;
-    if (pairCount >= 30) {
+    if (pairCount >= 30 && !compactionInFlight.has(chatId)) {
+      compactionInFlight.add(chatId);
       log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
-      runCompaction(chatId, "30-pair-threshold", opts?.onCompaction);
+      runCompaction(chatId, "30-pair-threshold", opts?.onCompaction).finally(() => {
+        compactionInFlight.delete(chatId);
+      });
     }
   }
   return {
@@ -15513,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;
@@ -16851,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) => {
@@ -17084,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 {
@@ -17266,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}`);
@@ -17515,6 +18255,7 @@ __export(ui_exports, {
   ROTATION_MODE_LABELS: () => ROTATION_MODE_LABELS,
   buildAccountSlotKeyboard: () => buildAccountSlotKeyboard,
   doBackendSwitch: () => doBackendSwitch,
+  executeBackendDisable: () => executeBackendDisable,
   getJobScheduleText: () => getJobScheduleText,
   getJobStatusEmoji: () => getJobStatusEmoji,
   getJobStatusLabel: () => getJobStatusLabel,
@@ -17522,6 +18263,7 @@ __export(ui_exports, {
   sendApiToolsKeyboard: () => sendApiToolsKeyboard,
   sendBackendAccountPicker: () => sendBackendAccountPicker,
   sendBackendConfigPanel: () => sendBackendConfigPanel,
+  sendBackendDisableFlow: () => sendBackendDisableFlow,
   sendBackendModelPicker: () => sendBackendModelPicker,
   sendBackendPicker: () => sendBackendPicker,
   sendBackendSwitchConfirmation: () => sendBackendSwitchConfirmation,
@@ -18265,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 = [];
@@ -18999,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 = [
     [
@@ -19006,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);
@@ -19083,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"],
@@ -19091,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}`,
@@ -19151,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);
@@ -20641,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) {
@@ -20663,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 {
@@ -20738,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)");
@@ -20872,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 "";
   }
@@ -21031,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;
@@ -21039,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);
@@ -21061,7 +21934,8 @@ async function runAnalysisImpl(chatId, opts) {
     })),
     codebaseEnabled,
     availableTargets,
-    skillContents
+    skillContents,
+    skillCorrections
   });
   const resolved = resolveReflectionAdapter(chatId);
   if (!resolved) {
@@ -21411,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;
@@ -21499,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 {
@@ -21521,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` };
   }
@@ -21662,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;
@@ -22394,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":
@@ -22590,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__";
@@ -22677,29 +23560,31 @@ 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 {
         }
-        const ollamaProviderOpts = {};
-        if (disableThinking) ollamaProviderOpts.think = false;
         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,
@@ -22728,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;
@@ -22748,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 {
@@ -22837,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
@@ -23023,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({
@@ -23036,6 +23921,7 @@ var init_backends = __esm({
     init_ollama2();
     init_openrouter();
     init_store5();
+    init_schema();
     init_log();
     init_types();
     openRouterAdapter = new OpenRouterAdapter();
@@ -23325,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);
@@ -23456,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() + `
@@ -26759,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()}`);
@@ -26836,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);
@@ -26981,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 "";
   }
@@ -27138,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---/);
@@ -27184,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"),
@@ -27213,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
@@ -27357,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) {
@@ -27488,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 "";
   }
@@ -27501,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 {
       }
@@ -27553,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);
@@ -27576,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 {
@@ -27903,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) {
@@ -28133,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);
@@ -29688,14 +30574,19 @@ 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)}`,
     ``,
@@ -29741,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);
@@ -30895,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) {
@@ -30912,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 [];
@@ -30921,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 [];
@@ -31585,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);
@@ -31638,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);
@@ -33478,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");
@@ -33531,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");
@@ -33572,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;
@@ -33779,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, {
@@ -35257,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 });
@@ -35687,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) {
@@ -35829,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}`);
@@ -37244,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";
@@ -37293,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];
@@ -37936,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() {
@@ -37979,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}`);
@@ -38207,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();
@@ -38718,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();
@@ -39186,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)) {
@@ -39194,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`));
@@ -39205,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);
@@ -39237,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) {
@@ -39295,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;
@@ -39344,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() {
@@ -39375,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;
@@ -39638,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 {
   }
@@ -39697,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() {
@@ -40051,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;
@@ -40059,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;
@@ -40082,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 {
@@ -40101,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;
@@ -41468,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.");
@@ -41554,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")) {
@@ -42550,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;
@@ -43711,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";
@@ -43803,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();