cc-claw 0.17.1 → 0.18.0

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.17.1" : (() => {
+    VERSION = true ? "0.18.0" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -60,13 +60,21 @@ __export(paths_exports, {
   SKILLS_PATH: () => SKILLS_PATH,
   WORKSPACE_PATH: () => WORKSPACE_PATH
 });
-import { homedir } from "os";
+import { homedir, userInfo } from "os";
 import { join as join2 } from "path";
+function resolveRealHome() {
+  try {
+    const info = userInfo();
+    if (info.homedir) return info.homedir;
+  } catch {
+  }
+  return homedir();
+}
 var CC_CLAW_HOME, ENV_PATH, DATA_PATH, DB_PATH, LOGS_PATH, LOG_PATH, ERROR_LOG_PATH, IDENTITY_PATH, WORKSPACE_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH, MEDIA_PATH;
 var init_paths = __esm({
   "src/paths.ts"() {
     "use strict";
-    CC_CLAW_HOME = process.env.CC_CLAW_HOME ?? join2(homedir(), ".cc-claw");
+    CC_CLAW_HOME = process.env.CC_CLAW_HOME ?? join2(resolveRealHome(), ".cc-claw");
     ENV_PATH = join2(CC_CLAW_HOME, ".env");
     DATA_PATH = join2(CC_CLAW_HOME, "data");
     DB_PATH = process.env.DB_PATH ?? join2(DATA_PATH, "cc-claw.db");
@@ -1735,6 +1743,12 @@ function initSchema(db3) {
       mode TEXT NOT NULL DEFAULT 'approved'
     );
   `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS chat_show_thinking_ui (
+      chat_id TEXT PRIMARY KEY,
+      value INTEGER NOT NULL DEFAULT 0
+    );
+  `);
   db3.exec(`
     CREATE TABLE IF NOT EXISTS backend_credentials (
       id                 INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -2419,6 +2433,52 @@ var init_sessions = __esm({
 });
 
 // src/memory/chat-settings.ts
+var chat_settings_exports = {};
+__export(chat_settings_exports, {
+  ALL_TOOLS: () => ALL_TOOLS,
+  clearAgentMode: () => clearAgentMode,
+  clearCwd: () => clearCwd,
+  clearExecMode: () => clearExecMode,
+  clearModel: () => clearModel,
+  clearSummarizer: () => clearSummarizer,
+  clearThinkingLevel: () => clearThinkingLevel,
+  deleteBookmark: () => deleteBookmark,
+  determineEscalationTarget: () => determineEscalationTarget,
+  findBookmarksByPrefix: () => findBookmarksByPrefix,
+  getAgentMode: () => getAgentMode,
+  getAllBookmarks: () => getAllBookmarks,
+  getBackend: () => getBackend,
+  getBookmark: () => getBookmark,
+  getCwd: () => getCwd,
+  getEnabledTools: () => getEnabledTools,
+  getExecMode: () => getExecMode,
+  getMode: () => getMode,
+  getModel: () => getModel,
+  getPendingEscalation: () => getPendingEscalation,
+  getRecentBookmarks: () => getRecentBookmarks,
+  getShowThinkingUi: () => getShowThinkingUi,
+  getSummarizer: () => getSummarizer,
+  getThinkingLevel: () => getThinkingLevel,
+  getToolsMap: () => getToolsMap,
+  getVerboseLevel: () => getVerboseLevel,
+  removePendingEscalation: () => removePendingEscalation,
+  resetTools: () => resetTools,
+  setAgentMode: () => setAgentMode,
+  setBackend: () => setBackend,
+  setCwd: () => setCwd,
+  setExecMode: () => setExecMode,
+  setMode: () => setMode,
+  setModel: () => setModel,
+  setShowThinkingUi: () => setShowThinkingUi,
+  setSummarizer: () => setSummarizer,
+  setThinkingLevel: () => setThinkingLevel,
+  setVerboseLevel: () => setVerboseLevel,
+  storePendingEscalation: () => storePendingEscalation,
+  toggleShowThinkingUi: () => toggleShowThinkingUi,
+  toggleTool: () => toggleTool,
+  touchBookmark: () => touchBookmark,
+  upsertBookmark: () => upsertBookmark
+});
 function getCwd(chatId) {
   const row = getDb().prepare(
     "SELECT cwd FROM chat_cwd WHERE chat_id = ?"
@@ -2517,6 +2577,25 @@ function setVerboseLevel(chatId, level) {
     ON CONFLICT(chat_id) DO UPDATE SET level = ?
   `).run(chatId, level, level);
 }
+function getShowThinkingUi(chatId) {
+  const row = getDb().prepare(
+    "SELECT value FROM chat_show_thinking_ui WHERE chat_id = ?"
+  ).get(chatId);
+  return (row?.value ?? 0) === 1;
+}
+function setShowThinkingUi(chatId, enabled) {
+  getDb().prepare(`
+    INSERT INTO chat_show_thinking_ui (chat_id, value)
+    VALUES (?, ?)
+    ON CONFLICT(chat_id) DO UPDATE SET value = ?
+  `).run(chatId, enabled ? 1 : 0, enabled ? 1 : 0);
+}
+function toggleShowThinkingUi(chatId) {
+  const current = getShowThinkingUi(chatId);
+  const next = !current;
+  setShowThinkingUi(chatId, next);
+  return next;
+}
 function getMode(chatId) {
   const row = getDb().prepare(
     "SELECT mode FROM chat_mode WHERE chat_id = ?"
@@ -3532,6 +3611,7 @@ __export(store_exports5, {
   getSessionStartedAt: () => getSessionStartedAt,
   getSessionSummaries: () => getSessionSummaries,
   getSessionSummariesWithoutEmbeddings: () => getSessionSummariesWithoutEmbeddings,
+  getShowThinkingUi: () => getShowThinkingUi,
   getSummarizer: () => getSummarizer,
   getThinkingLevel: () => getThinkingLevel,
   getToolsMap: () => getToolsMap,
@@ -3591,11 +3671,13 @@ __export(store_exports5, {
   setResponseStyle: () => setResponseStyle,
   setSessionId: () => setSessionId,
   setSessionStartedAt: () => setSessionStartedAt,
+  setShowThinkingUi: () => setShowThinkingUi,
   setSummarizer: () => setSummarizer,
   setThinkingLevel: () => setThinkingLevel,
   setVerboseLevel: () => setVerboseLevel,
   storePendingEscalation: () => storePendingEscalation,
   toFts5Query: () => toFts5Query,
+  toggleShowThinkingUi: () => toggleShowThinkingUi,
   toggleTool: () => toggleTool,
   touchBookmark: () => touchBookmark,
   updateHeartbeatTimestamps: () => updateHeartbeatTimestamps,
@@ -3914,10 +3996,16 @@ var init_claude = __esm({
             });
           }
           const content = message?.content ?? [];
-          const textParts = [];
+          let hasTextContent = false;
+          let textContent = "";
           for (const block of content) {
             if (block.type === "text" && block.text) {
-              textParts.push(block.text);
+              textContent += block.text;
+              hasTextContent = true;
+            } else if (block.type === "thinking" && block.thinking) {
+              events.push({ type: "thinking", text: block.thinking });
+            } else if (block.type === "redacted_thinking") {
+              events.push({ type: "thinking", text: "[Redacted Thinking]" });
             } else if (block.type === "tool_use") {
               events.push({
                 type: "tool_start",
@@ -3927,8 +4015,16 @@ var init_claude = __esm({
               });
             }
           }
-          if (textParts.length > 0) {
-            const cleaned = stripThinkingContent(textParts.join(""));
+          if (hasTextContent) {
+            const matches = [...textContent.matchAll(/<thinking>([\s\S]*?)<\/thinking>/gi)];
+            for (const match of matches) {
+              events.push({ type: "thinking", text: match[1].trim() });
+            }
+            const matchesThink = [...textContent.matchAll(/<think>([\s\S]*?)<\/think>/gi)];
+            for (const match of matchesThink) {
+              events.push({ type: "thinking", text: match[1].trim() });
+            }
+            const cleaned = stripThinkingContent(textContent);
             if (cleaned) events.push({ type: "text", text: cleaned });
           }
         } else if (line.type === "user") {
@@ -4282,8 +4378,18 @@ var init_gemini = __esm({
           events.push({ type: "init", sessionId: line.session_id });
         } else if (line.type === "message" && line.role === "assistant") {
           if (line.thought === true) {
+            events.push({ type: "thinking", text: String(line.content ?? "") });
           } else if (line.content) {
-            const cleaned = stripThinkingContent(line.content);
+            let contentStr = line.content;
+            const matches = [...contentStr.matchAll(/<thinking>([\s\S]*?)<\/thinking>/gi)];
+            for (const match of matches) {
+              events.push({ type: "thinking", text: match[1].trim() });
+            }
+            const matchesThink = [...contentStr.matchAll(/<think>([\s\S]*?)<\/think>/gi)];
+            for (const match of matchesThink) {
+              events.push({ type: "thinking", text: match[1].trim() });
+            }
+            const cleaned = stripThinkingContent(contentStr);
             if (cleaned) {
               events.push({ type: "text", text: cleaned });
             }
@@ -4490,26 +4596,74 @@ var init_codex = __esm({
           events.push({ type: "init", sessionId: line.thread_id });
         } else if (line.type === "item.completed") {
           const item = line.item;
-          if (item?.type === "agent_message" && item.text) {
+          if (!item) return events;
+          if (item.type === "agent_message" && item.text) {
             const cleaned = stripThinkingContent(item.text);
             if (cleaned) events.push({ type: "text", text: cleaned });
-          } else if (item?.type === "command_execution") {
+          } else if (item.type === "command_execution") {
             events.push({
               type: "tool_end",
               toolName: "Shell",
               toolId: item.id,
               toolOutput: item.aggregated_output ?? ""
             });
+          } else if (item.type === "web_search") {
+            const action = item.action;
+            const query = action?.query || item.query || "";
+            events.push({
+              type: "tool_end",
+              toolName: "Web Search",
+              toolId: item.id,
+              toolOutput: query ? `Searched: ${query}` : "Search completed"
+            });
+          } else if (item.type === "file_search") {
+            events.push({
+              type: "tool_end",
+              toolName: "File Search",
+              toolId: item.id,
+              toolOutput: item.query ?? ""
+            });
+          } else if (item.type === "mcp_tool_call") {
+            events.push({
+              type: "tool_end",
+              toolName: item.name ?? "MCP Tool",
+              toolId: item.id,
+              toolOutput: typeof item.output === "string" ? item.output : ""
+            });
           }
         } else if (line.type === "item.started") {
           const item = line.item;
-          if (item?.type === "command_execution") {
+          if (!item) return events;
+          if (item.type === "command_execution") {
             events.push({
               type: "tool_start",
               toolName: "Shell",
               toolId: item.id,
               toolInput: { command: item.command ?? "" }
             });
+          } else if (item.type === "web_search") {
+            const action = item.action;
+            const query = action?.query || item.query || "";
+            events.push({
+              type: "tool_start",
+              toolName: "Web Search",
+              toolId: item.id,
+              toolInput: { query: query || "Searching\u2026" }
+            });
+          } else if (item.type === "file_search") {
+            events.push({
+              type: "tool_start",
+              toolName: "File Search",
+              toolId: item.id,
+              toolInput: { query: item.query ?? "" }
+            });
+          } else if (item.type === "mcp_tool_call") {
+            events.push({
+              type: "tool_start",
+              toolName: item.name ?? "MCP Tool",
+              toolId: item.id,
+              toolInput: item.arguments ?? {}
+            });
           }
         } else if (line.type === "turn.completed") {
           const u = line.usage;
@@ -5292,6 +5446,11 @@ If the user asks *how* to do something with CC-Claw, use this expertise to sugge
 });
 
 // src/bootstrap/init.ts
+var init_exports = {};
+__export(init_exports, {
+  bootstrapWorkspaceFiles: () => bootstrapWorkspaceFiles,
+  syncNativeCliFiles: () => syncNativeCliFiles
+});
 import {
   existsSync as existsSync8,
   writeFileSync,
@@ -8677,15 +8836,37 @@ var init_scheduler = __esm({
         validateAgentIdentity(req, body);
         const { updateJob: updateJob2, getJobById: getJobById3 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
         const { stopJobTimer: stopJobTimer2, startSingleJob: startSingleJob2 } = await Promise.resolve().then(() => (init_cron(), cron_exports));
-        const updated = updateJob2(body.jobId, body.updates);
-        if (updated) {
-          stopJobTimer2(body.jobId);
-          const freshJob = getJobById3(body.jobId);
-          if (freshJob && freshJob.active && freshJob.enabled) {
-            startSingleJob2(freshJob);
-          }
+        const existing = getJobById3(body.jobId);
+        if (!existing) {
+          return jsonResponse(res, { success: false, error: `Job #${body.jobId} not found.` }, 404);
+        }
+        const updates = { ...body.updates };
+        if (updates.cron !== void 0) {
+          updates.scheduleType = "cron";
+          updates.atTime = null;
+          updates.everyMs = null;
+        } else if (updates.atTime !== void 0) {
+          updates.scheduleType = "at";
+          updates.cron = null;
+          updates.everyMs = null;
+        } else if (updates.everyMs !== void 0) {
+          updates.scheduleType = "every";
+          updates.cron = null;
+          updates.atTime = null;
+        }
+        const updated = updateJob2(body.jobId, updates);
+        if (!updated) {
+          return jsonResponse(res, {
+            success: false,
+            error: `No recognized fields to update. Valid fields: cron, atTime, everyMs, title, description, backend, model, thinking, timeout, timezone, sessionType, deliveryMode, channel, target.`
+          }, 400);
         }
-        jsonResponse(res, { success: updated });
+        stopJobTimer2(body.jobId);
+        const freshJob = getJobById3(body.jobId);
+        if (freshJob && freshJob.active && freshJob.enabled) {
+          startSingleJob2(freshJob);
+        }
+        jsonResponse(res, { success: true });
       } catch (err) {
         jsonResponse(res, { error: errorMessage(err) }, 400);
       }
@@ -10178,11 +10359,11 @@ var init_evolve = __esm({
         const body = JSON.parse(await readBody(req));
         const { setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
         const { existsSync: fileExists, readFileSync: fileRead } = await import("fs");
-        const { join: join30 } = await import("path");
+        const { join: join34 } = await import("path");
         const { CC_CLAW_HOME: home } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const chatId = body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || "default";
-        const soulPath = join30(home, "identity/SOUL.md");
-        const userPath = join30(home, "identity/USER.md");
+        const soulPath = join34(home, "identity/SOUL.md");
+        const userPath = join34(home, "identity/USER.md");
         const soul = fileExists(soulPath) ? fileRead(soulPath, "utf-8") : "";
         const user = fileExists(userPath) ? fileRead(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
@@ -10762,6 +10943,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     }, effectiveTimeout);
     let resultText = "";
     let accumulatedText = "";
+    let accumulatedThinking = "";
     let sessionId;
     let input = 0;
     let output2 = 0;
@@ -10828,6 +11010,19 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
               if (opts?.onStream) opts.onStream(ev.text);
             }
             break;
+          case "thinking":
+            if (!gotModelContent) {
+              gotModelContent = true;
+              if (firstResponseTimer) {
+                clearTimeout(firstResponseTimer);
+                firstResponseTimer = void 0;
+              }
+            }
+            if (ev.text) {
+              accumulatedThinking = appendTextChunk(accumulatedThinking, ev.text);
+              if (opts?.onThinking) opts.onThinking(ev.text);
+            }
+            break;
           case "tool_start":
             if (!gotModelContent) {
               gotModelContent = true;
@@ -10968,7 +11163,7 @@ Partial output: ${accumulatedText.slice(-500)}`;
         return;
       }
       const cleanedResult = stripThinkingContent(resultText || accumulatedText);
-      resolve({ resultText: cleanedResult, sessionId, input, output: output2, cacheRead, contextSize, sawToolEvents, sawResultEvent });
+      resolve({ resultText: cleanedResult, thinkingText: accumulatedThinking, sessionId, input, output: output2, cacheRead, contextSize, sawToolEvents, sawResultEvent });
     });
   });
 }
@@ -11128,7 +11323,7 @@ function askAgent(chatId, userMessage, opts) {
   return withChatLock(chatId, () => askAgentImpl(chatId, userMessage, opts));
 }
 async function askAgentImpl(chatId, userMessage, opts) {
-  const { cwd, onStream, model: model2, backend: backend2, permMode, onToolAction, bootstrapTier, timeoutMs, maxTurns, onSlotRotation, onModelDowngrade, agentMode: optsAgentMode, onSubagentActivity, settingsSourceChatId, planningDirective } = opts ?? {};
+  const { cwd, onStream, model: model2, backend: backend2, permMode, onToolAction, bootstrapTier, timeoutMs, maxTurns, onSlotRotation, onModelDowngrade, agentMode: optsAgentMode, onSubagentActivity, settingsSourceChatId, planningDirective, onThinking } = opts ?? {};
   const settingsChat = settingsSourceChatId ?? chatId;
   const adapter = backend2 ? getAdapter(backend2) : getAdapterForChat(settingsChat);
   const mode = permMode ?? getMode(settingsChat);
@@ -11176,6 +11371,7 @@ async function askAgentImpl(chatId, userMessage, opts) {
     onStream,
     onToolAction,
     onSubagentActivity,
+    onThinking,
     // First-response timeout: only arm for fresh Gemini sessions (cold-start).
     // If Gemini has already responded at least once (existingSessionId is set),
     // the session is established — mid-conversation silence is a legitimate long task,
@@ -11369,6 +11565,7 @@ async function askAgentImpl(chatId, userMessage, opts) {
   }
   return {
     text: result.resultText || `(No response from ${adapter.displayName})`,
+    thinkingText: result.thinkingText,
     sessionId: result.sessionId,
     usage: { input: result.input, output: result.output, cacheRead: result.cacheRead, contextSize: result.contextSize },
     resolvedModel: result.resolvedModel
@@ -11741,9 +11938,15 @@ function buildReviewCompleteMessage(results) {
 Skipped proposals will appear in your next review.`;
 }
 function formatNightlySummary(insights, totalPending) {
-  const displayCount = totalPending ?? insights.length;
-  const header2 = `Nightly Reflection \u2014 ${displayCount} proposal${displayCount === 1 ? "" : "s"} ready`;
-  const list = insights.map((ins, i) => `${i + 1}. [${ins.category}] ${ins.insight}`).join("\n");
+  const newCount = insights.length;
+  const total = totalPending ?? newCount;
+  let header2;
+  if (total > newCount) {
+    header2 = `Nightly Reflection \u2014 ${newCount} new proposal${newCount === 1 ? "" : "s"} (${total} total pending)`;
+  } else {
+    header2 = `Nightly Reflection \u2014 ${newCount} proposal${newCount === 1 ? "" : "s"} ready`;
+  }
+  const list = insights.map((ins, i) => `\u2022 [${ins.category}] ${ins.insight}`).join("\n");
   return `${header2}
 
 ${list}
@@ -12023,6 +12226,7 @@ function classifyIntent(text, chatId) {
   if (trimmed.startsWith(">>")) return "agentic";
   if (trimmed.startsWith("/")) return "agentic";
   const lower = trimmed.toLowerCase();
+  const normalized = trimmed.replace(/^["'\u201C\u201D\u2018\u2019`\s]+|["'\u201C\u201D\u2018\u2019`\s]+$/g, "");
   const sessionId = getSessionId(chatId);
   if (sessionId) {
     const lastTs = getLastMessageTimestamp(chatId);
@@ -12045,18 +12249,32 @@ function classifyIntent(text, chatId) {
     intentCounts.chat++;
     return "chat";
   }
-  for (const pattern of AGENTIC_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      log(`[intent] "${trimmed.slice(0, 30)}..." -> agentic (pattern: ${pattern})`);
+  for (const pattern of STRUCTURAL_PATTERNS) {
+    if (pattern.test(normalized)) {
+      log(`[intent] "${trimmed.slice(0, 40)}..." -> agentic (structural: ${pattern})`);
+      intentCounts.agentic++;
+      return "agentic";
+    }
+  }
+  for (const pattern of MUTATION_PATTERNS) {
+    if (pattern.test(normalized)) {
+      log(`[intent] "${trimmed.slice(0, 40)}..." -> agentic (mutation: ${pattern})`);
       intentCounts.agentic++;
       return "agentic";
     }
   }
-  log(`[intent] "${trimmed.slice(0, 30)}..." -> agentic (default)`);
+  for (const pattern of CHAT_QUESTION_PATTERNS) {
+    if (pattern.test(normalized)) {
+      log(`[intent] "${trimmed.slice(0, 40)}..." -> chat (question: ${pattern})`);
+      intentCounts.chat++;
+      return "chat";
+    }
+  }
+  log(`[intent] "${trimmed.slice(0, 40)}..." -> agentic (default)`);
   intentCounts.agentic++;
   return "agentic";
 }
-var intentCounts, CHAT_EXACT, AGENTIC_PATTERNS;
+var intentCounts, CHAT_EXACT, MUTATION_PATTERNS, CHAT_QUESTION_PATTERNS, STRUCTURAL_PATTERNS;
 var init_classify = __esm({
   "src/intent/classify.ts"() {
     "use strict";
@@ -12113,27 +12331,44 @@ var init_classify = __esm({
       "alright",
       "sure"
     ]);
-    AGENTIC_PATTERNS = [
-      /\.\w{1,5}$/,
-      // file extensions (.ts, .py, .md)
-      /[\/\\][\w.-]+/,
-      // file paths
+    MUTATION_PATTERNS = [
+      /\b(fix|create|build|deploy|install|uninstall|delete|remove|update|edit|write|modify|move|rename|push|pull|commit|merge|rebase|refactor|implement|generate|scaffold|configure|enable|disable|migrate|upgrade|downgrade|seed|reset|rollback|apply|patch|publish|release|format|lint|compile|transpile|bundle|obfuscat)\b/i,
+      /\b(add\s+(?:a|an|the|new|\w+\s+to))/i,
+      // "add a function", "add to the file"
+      /\b(change\s+(?:the|a|my|this|that|\w+\s+to))/i,
+      // "change the config to"
+      /\b(make\s+(?:a|an|it|this|the|sure))\b/i,
+      // "make a new file", "make it work"
+      /\b(set\s+(?:up|the|a|my))\b/i
+      // "set up the database"
+    ];
+    CHAT_QUESTION_PATTERNS = [
+      /^(?:what|whats|what's)\s+/i,
+      // "what is", "what version", "what does"
+      /^(?:which|where|when|why|who)\s+/i,
+      // "which file", "where is", "when did"
+      /^(?:how\s+(?:do|does|can|did|many|much|long|often|come))\s+/i,
+      // "how do I", "how many"
+      /^(?:show|tell|list|explain|describe|summarize|display)\s+(?:me\s+)?/i,
+      /^(?:do you|can you|could you|are you|is there|are there)\s+(?:know|have|see|find|show|tell|check|list|explain|describe)\s+/i,
+      /^(?:give\s+me|get\s+me)\s+(?:the|a|my|an|current|latest)\s+/i,
+      /^(?:is|are|was|were|does|did|has|have|had)\s+(?:the|a|my|it|this|that|there)\s+/i
+    ];
+    STRUCTURAL_PATTERNS = [
+      /\.[a-z]{1,5}\b/,
+      // file extensions (.ts, .py, .md, .json)
+      /[/\\][\w.-]+/,
+      // file paths (/src/foo, .\bar)
       /`[^`]+`/,
-      // inline code
+      // inline code `like this`
       /```/,
       // code blocks
-      /\b(fix|create|build|deploy|run|execute|install|delete|remove|update|edit|write|read|check|test|debug|refactor|implement|add|change|modify|move|copy|rename|push|pull|commit|merge|rebase)\b/i,
-      // imperative verbs
-      /\b(error|bug|crash|fail|broken|issue|problem|exception|stack ?trace)\b/i,
-      // error keywords
-      /\b(function|class|const|let|var|import|export|return|async|await)\b/i,
-      // code keywords
       /[!]{1,2}\s/,
-      // shell prefix
+      // shell prefix (! or !!)
       /^\/\//,
-      // backend command prefix
-      /\b(file|folder|directory|script|server|database|api|endpoint|config|package|module|component)\b/i
-      // tech nouns
+      // backend command prefix (//)
+      /\b(error|bug|crash|fail|broken|issue|problem|exception|stack\s?trace)\b/i,
+      /\b(function|class|const|let|var|import|export|return|async|await)\b/i
     ];
   }
 });
@@ -12833,7 +13068,7 @@ var init_classify2 = __esm({
 // src/execution/gate.ts
 function shouldRequireApproval(input) {
   if (input.execMode !== "approved") return false;
-  if (input.intent !== "agentic") return false;
+  if (input.intent === "chat") return false;
   if (input.messageText.startsWith(">>")) return false;
   if (EXEMPT_TIERS.has(input.bootstrapTier)) return false;
   if (input.isSideQuest) return false;
@@ -12841,28 +13076,40 @@ function shouldRequireApproval(input) {
 }
 function buildPlanningDirective() {
   return [
-    "## PLANNING MODE \u2014 Read-Only",
+    "## PLANNING MODE \u2014 Describe Only, Do Not Execute",
     "",
-    "You are in PLANNING mode. Your goal is to research and present a plan.",
+    "You are in PLANNING MODE. Your job is to research the request and describe",
+    "what you will do. The user will review and approve before you execute anything.",
     "",
     "**ALLOWED:**",
-    "- Read files, directories, and code",
-    "- Load and read skills",
-    "- Search the codebase (grep, glob, find)",
-    "- Search the web for documentation or solutions",
-    "- Analyze and reason about architecture",
+    "- Read file contents",
+    "- Search/grep the codebase",
+    "- Analyze code and architecture",
+    "- Search the web for documentation",
+    "",
+    "**NOT ALLOWED \u2014 do NOT do any of these, even if they seem harmless:**",
+    "- Run any shell or terminal commands (no node --version, no ls, no cat, no npm, nothing)",
+    "- Create, modify, or delete any files",
+    "- Write or generate code",
+    "- Install or uninstall packages",
+    "- Execute any mutations whatsoever",
+    "",
+    "**IMPORTANT:** Even if you already know the answer (e.g. from training data),",
+    "do NOT run a command to confirm it. Just describe what you WILL do.",
     "",
-    "**NOT ALLOWED:**",
-    "- Do NOT create, modify, or delete any files",
-    "- Do NOT run shell commands that mutate state",
-    "- Do NOT write code or make edits",
-    "- Do NOT install packages or dependencies",
+    "**OUTPUT FORMAT (strict):**",
+    "- No preamble, no 'Here is my plan:', no closing remarks",
+    "- Start with a bold title: '**Plan: <short description>**'",
+    "- Use bullet points (\u2022) for each step \u2014 max 15 words per bullet",
+    "- Be specific about which files you'll touch and what you'll change",
+    "- Max total output: 3000 characters",
     "",
-    "**YOUR TASK:**",
-    "Research the request thoroughly, then present a clear, concise plan",
-    "of what you will do. The user will review and approve before you execute.",
-    "Structure your plan with numbered steps and be specific about which",
-    "files you will modify and what changes you will make."
+    "Example:",
+    "**Plan: Add retry logic to API client**",
+    "\u2022 Read `src/api/client.ts` \u2014 identify fetch call sites",
+    "\u2022 Add `retryWithBackoff()` helper (max 3 retries, exponential backoff)",
+    "\u2022 Update `src/sync.ts` and `src/scheduler.ts` to use the wrapper",
+    "\u2022 Add unit test in `src/api/client.test.ts`"
   ].join("\n");
 }
 function storePendingPlan(chatId, plan, originalMessage) {
@@ -15826,11 +16073,11 @@ async function sendJobPicker(chatId, channel, action) {
 }
 async function sendCurrentProposal(chatId, channel) {
   const { getReviewSession: getReviewSession2, getInsightById: getInsightById2, deleteReviewSession: deleteReviewSession2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
-  const { formatProposalCardWithProgress: formatProposalCardWithProgress2, buildProposalKeyboard: buildProposalKeyboard2, buildReviewCompleteMessage: buildReviewCompleteMessage2 } = await Promise.resolve().then(() => (init_propose(), propose_exports));
+  const { formatProposalCardWithProgress: formatProposalCardWithProgress2, buildProposalKeyboard: buildProposalKeyboard2, buildReviewCompleteMessage: buildReviewCompleteMessage3 } = await Promise.resolve().then(() => (init_propose(), propose_exports));
   const session2 = getReviewSession2(getDb(), chatId);
   if (!session2) return;
   if (session2.currentIndex >= session2.insightIds.length) {
-    const summary = buildReviewCompleteMessage2(session2.results);
+    const summary = buildReviewCompleteMessage3(session2.results);
     deleteReviewSession2(getDb(), chatId);
     await channel.sendText(chatId, summary, { parseMode: "plain" });
     return;
@@ -16070,7 +16317,7 @@ async function handleEvolveCallback(chatId, data, channel) {
       if (pending.length === 0) {
         await channel.sendText(chatId, "No pending proposals.", { parseMode: "plain" });
       } else {
-        const insightIds = pending.slice(0, 5).map((p) => p.id);
+        const insightIds = pending.map((p) => p.id);
         createReviewSession2(getDb(), chatId, insightIds);
         await channel.sendText(chatId, `${pending.length} proposal(s) ready. Let's review them one by one.`, { parseMode: "plain" });
         await sendCurrentProposal(chatId, channel);
@@ -16231,13 +16478,13 @@ async function handleEvolveCallback(chatId, data, channel) {
       const { getReflectionStatus: getReflectionStatus2, setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
-        const { readFileSync: readFileSync22, existsSync: existsSync50 } = await import("fs");
-        const { join: join30 } = await import("path");
+        const { readFileSync: readFileSync26, existsSync: existsSync54 } = await import("fs");
+        const { join: join34 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const soulPath = join30(CC_CLAW_HOME3, "identity/SOUL.md");
-        const userPath = join30(CC_CLAW_HOME3, "identity/USER.md");
-        const soul = existsSync50(soulPath) ? readFileSync22(soulPath, "utf-8") : "";
-        const user = existsSync50(userPath) ? readFileSync22(userPath, "utf-8") : "";
+        const soulPath = join34(CC_CLAW_HOME3, "identity/SOUL.md");
+        const userPath = join34(CC_CLAW_HOME3, "identity/USER.md");
+        const soul = existsSync54(soulPath) ? readFileSync26(soulPath, "utf-8") : "";
+        const user = existsSync54(userPath) ? readFileSync26(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
         const { logActivity: logActivity2 } = await Promise.resolve().then(() => (init_store3(), store_exports3));
         logActivity2(getDb(), { chatId, source: "telegram", eventType: "reflection_unfrozen", summary: "Reflection enabled" });
@@ -16313,107 +16560,1284 @@ var init_evolve2 = __esm({
   }
 });
 
-// src/router/commands.ts
-import { readFile as readFile6 } from "fs/promises";
-async function handleCommand(msg, channel) {
-  const { chatId, command, commandArgs } = msg;
-  if (command?.startsWith("/")) {
-    return handleBackendCommand(command, chatId, channel);
+// src/optimizer/identity-audit.ts
+import { readFileSync as readFileSync10, existsSync as existsSync19, readdirSync as readdirSync9, statSync as statSync6 } from "fs";
+import { join as join20 } from "path";
+function readIdentityFile2(filename) {
+  try {
+    return readFileSync10(join20(IDENTITY_PATH, filename), "utf-8");
+  } catch {
+    return "";
   }
-  switch (command) {
-    case "start":
-    case "help": {
-      if (typeof channel.sendKeyboard === "function") {
-        await sendHelpCategories(chatId, channel);
-      } else {
-        await channel.sendText(
-          chatId,
-          "CC-Claw Commands\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n\n" + Object.entries(HELP_CATEGORIES).map(
-            ([cat, cmds]) => `${cat}:
-${cmds.map((c) => `  ${c.cmd} \u2014 ${c.desc}`).join("\n")}`
-          ).join("\n\n"),
-          { parseMode: "plain" }
-        );
+}
+function getMtime(filepath) {
+  try {
+    return statSync6(filepath).mtime.toISOString();
+  } catch {
+    return "unknown";
+  }
+}
+function findBackupFiles() {
+  const backups = [];
+  const dirs = [IDENTITY_PATH];
+  const contextDir = join20(IDENTITY_PATH, "..", "workspace", "context");
+  if (existsSync19(contextDir)) dirs.push(contextDir);
+  for (const dir of dirs) {
+    try {
+      for (const entry of readdirSync9(dir)) {
+        if (entry.endsWith(".bak") || /\.bak\.\d{4}-\d{2}-\d{2}/.test(entry)) {
+          backups.push(join20(dir, entry));
+        }
       }
-      break;
+    } catch {
     }
-    case "menu":
-    case "m": {
-      if (typeof channel.sendKeyboard === "function") {
-        const header2 = `\u{1F43E} ${buildSectionHeader("CC-Claw")}`;
-        await channel.sendKeyboard(chatId, header2, [
-          [{ label: "New Chat", data: "menu:newchat" }, { label: "Status", data: "menu:status" }],
-          [{ label: "Backend", data: "menu:backend" }, { label: "Model", data: "menu:model" }],
-          [{ label: "Jobs", data: "menu:jobs" }, { label: "Memory", data: "menu:memory" }],
-          [{ label: "History", data: "menu:history" }, { label: "Help", data: "menu:help" }]
-        ]);
-      } else {
-        await channel.sendText(
-          chatId,
-          "CC-Claw Menu:\n/newchat \xB7 /status \xB7 /backend \xB7 /model\n/jobs \xB7 /memory \xB7 /history \xB7 /help",
-          { parseMode: "plain" }
-        );
-      }
-      break;
+  }
+  return backups;
+}
+function computeIdentityStats(pendingProposals, driftPercent) {
+  const soulContent = readIdentityFile2("SOUL.md");
+  const userContent = readIdentityFile2("USER.md");
+  const ccClawContent = readIdentityFile2("CC-CLAW.md");
+  const soulChars = soulContent.length;
+  const userChars = userContent.length;
+  const ccClawChars = ccClawContent.length;
+  const boilerplateChars = Math.max(0, ccClawChars - soulChars - userChars);
+  return {
+    soulChars,
+    userChars,
+    ccClawChars,
+    boilerplateChars,
+    soulMtime: getMtime(join20(IDENTITY_PATH, "SOUL.md")),
+    userMtime: getMtime(join20(IDENTITY_PATH, "USER.md")),
+    ccClawMtime: getMtime(join20(IDENTITY_PATH, "CC-CLAW.md")),
+    backupFiles: findBackupFiles(),
+    estimatedTokens: Math.ceil(ccClawChars / 4),
+    pendingEvolveProposals: pendingProposals,
+    driftPercent
+  };
+}
+function buildTokenReport(stats) {
+  return {
+    soulChars: stats.soulChars,
+    userChars: stats.userChars,
+    boilerplateChars: stats.boilerplateChars,
+    totalChars: stats.ccClawChars,
+    estimatedTokens: stats.estimatedTokens
+  };
+}
+function buildIdentityAuditPrompt(soulMd, userMd, ccClawMd, stats, contextFiles) {
+  const sections = [];
+  sections.push(`You are an expert prompt engineer and identity file auditor for an AI assistant platform.
+
+Your task: Analyze the assistant's identity files against a strict rubric and produce ONLY high-confidence, actionable findings. Every finding must earn its place \u2014 no fluff, no generic observations, no "nice to have" suggestions.
+
+SCRUTINY RULE: Before including ANY finding, ask yourself: "Does this have a clear, specific impact on AI behavior, prompt compliance, or token waste?" If you cannot articulate the exact impact, DO NOT include it.
+
+Return at most 8 findings. If everything is clean, return NO_FINDINGS.`);
+  sections.push(`[Pre-computed Stats]
+SOUL.md: ${stats.soulChars} chars (~${Math.ceil(stats.soulChars / 4)} tokens), modified: ${stats.soulMtime}
+USER.md: ${stats.userChars} chars (~${Math.ceil(stats.userChars / 4)} tokens), modified: ${stats.userMtime}
+CC-CLAW.md: ${stats.ccClawChars} chars (~${stats.estimatedTokens} tokens), modified: ${stats.ccClawMtime}
+Boilerplate overhead: ~${stats.boilerplateChars} chars (~${Math.ceil(stats.boilerplateChars / 4)} tokens)
+Total identity tokens per message: ~${stats.estimatedTokens}
+Backup files found: ${stats.backupFiles.length > 0 ? stats.backupFiles.join(", ") : "none"}
+Pending evolve proposals: ${stats.pendingEvolveProposals}
+Drift from baseline: ${stats.driftPercent !== null ? `${stats.driftPercent}%` : "not calculated"}`);
+  sections.push(`[Rubric \u2014 Evaluate Each Area]
+
+1. STRUCTURAL HEALTH
+   - Are file sizes reasonable? (SOUL.md >5000 chars or USER.md >3000 chars = bloat risk)
+   - Is CC-CLAW.md stale? (modified before SOUL.md or USER.md = needs regeneration)
+   - Orphan backup files accumulating?
+   - Logical section organization within each file?
+
+2. CONTENT ROUTING
+   - User profile data (job title, employer, location) misplaced in SOUL.md? \u2192 belongs in USER.md
+   - Personality directives (tone, style rules) misplaced in USER.md? \u2192 belongs in SOUL.md
+   - Secrets, credentials, or API keys in any file?
+   - Temporary content (TODOs, dates, one-off instructions) in identity files?
+   - Content that should live in workspace/context/ files instead?
+
+3. TOKEN EFFICIENCY
+   - Content duplicated between SOUL.md and USER.md?
+   - Verbose explanations that could be tightened without losing meaning?
+   - Inline lists (emoji lists, tool lists) that are too long?
+   - Content from context files that duplicates identity content?
+
+4. EVOLVE INTEGRATION
+   - Pending proposal count (${stats.pendingEvolveProposals}) \u2014 are stale proposals accumulating?
+   - Drift from baseline (${stats.driftPercent !== null ? `${stats.driftPercent}%` : "N/A"}) \u2014 is it excessive (>50%)?
+
+5. QUALITY & CLARITY
+   - Conflicting instructions within the same file (e.g., "be brief" AND "provide detailed explanations")
+   - Vague or ambiguous rules the AI is unlikely to follow consistently
+   - Outdated references (old tool names, deprecated services)
+   - Missing important directives (timezone, OS, communication style preferences)
+
+6. IDENTITY COMPLETENESS
+   - Does USER.md have enough info for the assistant to be truly personal?
+   - Missing: timezone, work context, communication preferences, personal interests?
+   - Contradictory user info (e.g., conflicting roles, locations, or personal details)?
+   - What additional info could the user provide to improve personalization?`);
+  sections.push("[Current SOUL.md]");
+  sections.push(soulMd || "(empty)");
+  sections.push("[Current USER.md]");
+  sections.push(userMd || "(empty)");
+  sections.push("[Current CC-CLAW.md (generated)]");
+  sections.push(ccClawMd || "(empty)");
+  if (contextFiles.length > 0) {
+    sections.push("[Context Files]");
+    for (const f of contextFiles) {
+      sections.push(`--- ${f.name} ---`);
+      sections.push(f.content.length > 2e3 ? f.content.slice(0, 2e3) + "\n[...truncated]" : f.content);
     }
-    case "stop": {
-      const stopped = stopAgent(chatId);
-      stopAllSideQuests(chatId);
-      cancelAllAgents(chatId);
-      await channel.sendText(
-        chatId,
-        stopped ? "Stopping current task..." : "Nothing is running.",
-        { parseMode: "plain" }
-      );
-      if (stopped && typeof channel.sendKeyboard === "function") {
-        await channel.sendKeyboard(chatId, "", [
-          [{ label: "\u{1F195} New Chat", data: "menu:newchat" }]
-        ]);
-      }
-      break;
+  }
+  sections.push(`[Output Format]
+For each finding, output EXACTLY this format. Separate multiple findings with "---" on its own line.
+
+FINDING: <short title, max 80 chars>
+AREA: <structural | routing | efficiency | evolve | quality | completeness>
+SEVERITY: <critical | warning | info>
+DETAIL: <1-3 sentences explaining the issue AND its specific impact on AI behavior>
+LOCATION: <file:line or file:section, e.g. "SOUL.md:## Communication" or "USER.md:15">
+SUGGESTION: <specific actionable fix>
+DIFF:
+<proposed changes as diff lines, + for additions, - for removals>
+---
+
+If no findings are warranted after thorough analysis, output: NO_FINDINGS
+
+CRITICAL: For COMPLETENESS findings where you suggest the user ADD information, leave DIFF empty and explain in SUGGESTION what the user should provide. You cannot generate personal information \u2014 only the user can.`);
+  return sections.join("\n\n");
+}
+var init_identity_audit = __esm({
+  "src/optimizer/identity-audit.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/optimizer/skill-audit.ts
+import { readFileSync as readFileSync11, existsSync as existsSync20 } from "fs";
+import { join as join21, basename as basename2 } from "path";
+function parseFrontmatter3(content) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return {};
+  const fm = fmMatch[1];
+  const result = {};
+  const nameMatch = fm.match(/^name:\s*(.+)/m);
+  if (nameMatch) result.name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+  const descMatch = fm.match(/^description:\s*>?\s*\n?([\s\S]*?)(?=\n\w|\n---)/m);
+  if (descMatch) {
+    result.description = descMatch[1].trim().replace(/\n\s+/g, " ");
+  } else {
+    const singleDesc = fm.match(/^description:\s*(.+)/m);
+    if (singleDesc) result.description = singleDesc[1].trim().replace(/^["']|["']$/g, "");
+  }
+  const backendsMatch = fm.match(/^compatible_backends:\s*(.+)/m);
+  if (backendsMatch) result.compatibleBackends = backendsMatch[1].trim();
+  const modelMatch = fm.match(/^recommended_model:\s*(.+)/m);
+  if (modelMatch) result.recommendedModel = modelMatch[1].trim();
+  return result;
+}
+function detectDependentSkills(content) {
+  const deps = /* @__PURE__ */ new Set();
+  const loadMatches = content.matchAll(/(?:load|activate|use|invoke)\s+(?:the\s+)?[`"]?([a-z0-9_-]+)[`"]?\s+(?:skill)?/gi);
+  for (const m of loadMatches) {
+    const name = m[1].toLowerCase();
+    if (name.length > 2 && !["the", "this", "that", "skill", "tool"].includes(name)) {
+      deps.add(name);
     }
-    case "permissions": {
-      const currentMode = getMode(chatId);
-      if (typeof channel.sendKeyboard === "function") {
-        const buttons = Object.entries(PERM_MODES).map(([id, label2]) => [{
-          label: `${id === currentMode ? "\u2713 " : ""}${label2}`,
-          data: `perms:${id}`,
-          ...id === currentMode ? { style: "primary" } : {}
-        }]);
-        await channel.sendKeyboard(chatId, "Select permission mode:", buttons);
-      } else {
-        const lines = ["Permission modes:", ""];
-        for (const [id, label2] of Object.entries(PERM_MODES)) {
-          lines.push(`${id === currentMode ? "\u2713 " : "  "}/permissions ${id} \u2014 ${label2}`);
-        }
-        await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
-      }
-      break;
+  }
+  const btMatches = content.matchAll(/`([a-z][a-z0-9_-]+(?:-skill)?)`/g);
+  for (const m of btMatches) {
+    const name = m[1];
+    if (!name.includes(".") && !name.startsWith("cc-claw") && name.length > 3) {
+      deps.add(name);
     }
-    case "mode":
-    case "execmode": {
-      const currentExecMode = getExecMode(chatId);
-      const EXEC_MODES = {
-        approved: "\u2705 Approved \u2014 AI shows a plan before acting",
-        yolo: "\u26A1 YOLO \u2014 AI executes immediately"
-      };
-      if (typeof channel.sendKeyboard === "function") {
-        const buttons = Object.entries(EXEC_MODES).map(([id, label2]) => [{
-          label: `${id === currentExecMode ? "\u2713 " : ""}${label2}`,
-          data: `execmode:${id}`,
-          ...id === currentExecMode ? { style: "primary" } : {}
-        }]);
-        await channel.sendKeyboard(chatId, `Execution mode (current: <b>${currentExecMode}</b>):`, buttons);
-      } else {
-        const lines = ["Execution modes:", ""];
-        for (const [id, label2] of Object.entries(EXEC_MODES)) {
-          lines.push(`${id === currentExecMode ? "\u2713 " : "  "}/mode ${id} \u2014 ${label2}`);
+  }
+  return Array.from(deps);
+}
+function computeSkillStats(skillPath) {
+  const content = readFileSync11(skillPath, "utf-8");
+  const lines = content.split("\n");
+  return {
+    skillName: basename2(skillPath, ".md") === "SKILL" ? basename2(join21(skillPath, "..")) : basename2(skillPath, ".md"),
+    skillPath,
+    lineCount: lines.length,
+    charCount: content.length,
+    estimatedTokens: Math.ceil(content.length / 4),
+    frontmatter: parseFrontmatter3(content),
+    dependentSkills: detectDependentSkills(content)
+  };
+}
+function buildSkillTokenReport(stats) {
+  return {
+    skillChars: stats.charCount,
+    estimatedTokens: stats.estimatedTokens,
+    lineCount: stats.lineCount
+  };
+}
+function loadDependentSkillContents(depNames, ccClawSkillsDir) {
+  const results = [];
+  for (const name of depNames) {
+    const candidates = [
+      join21(ccClawSkillsDir, name, "SKILL.md"),
+      join21(ccClawSkillsDir, `${name}-skill`, "SKILL.md")
+    ];
+    for (const candidate of candidates) {
+      if (existsSync20(candidate)) {
+        try {
+          const content = readFileSync11(candidate, "utf-8");
+          results.push({
+            name,
+            content: content.length > 3e3 ? content.slice(0, 3e3) + "\n[...truncated]" : content
+          });
+        } catch {
         }
-        await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
+        break;
       }
-      break;
     }
-    case "verbose": {
+  }
+  return results;
+}
+function buildSkillAuditPrompt(skillContent, stats, soulMd, ccClawSkillsDir) {
+  const sections = [];
+  sections.push(`You are an expert prompt engineer specializing in AI agent skills. Analyze this skill file against a strict rubric derived from Anthropic's skill-creator best practices and prompt engineering research.
+
+Your task: Produce ONLY high-confidence, actionable findings that will measurably improve how well the AI follows this skill's instructions. Every finding must earn its place.
+
+SCRUTINY RULE: Before including ANY finding, ask yourself: "Will fixing this change how the AI executes this skill?" If the answer is no or unclear, DO NOT include it. We want zero fluff.
+
+Return at most 8 findings. If the skill is well-constructed, return NO_FINDINGS.`);
+  sections.push(`[Skill Stats]
+Name: ${stats.skillName}
+Path: ${stats.skillPath}
+Lines: ${stats.lineCount} (cap: 500 \u2014 over 500 = progressive disclosure needed)
+Chars: ${stats.charCount} (~${stats.estimatedTokens} tokens)
+Frontmatter name: ${stats.frontmatter.name || "(missing)"}
+Frontmatter description: ${stats.frontmatter.description ? stats.frontmatter.description.slice(0, 200) : "(missing)"}
+Compatible backends: ${stats.frontmatter.compatibleBackends || "(not specified)"}
+Recommended model: ${stats.frontmatter.recommendedModel || "(not specified)"}
+Referenced skills: ${stats.dependentSkills.length > 0 ? stats.dependentSkills.join(", ") : "none"}`);
+  sections.push(`[Rubric \u2014 Evaluate Each Area]
+
+1. FRONTMATTER QUALITY
+   - Is 'name' present and descriptive?
+   - Does 'description' include BOTH what the skill does AND trigger info (when to use it)?
+   - A good description tells the AI exactly when to activate this skill
+   - Should 'compatible_backends' or 'recommended_model' be specified?
+
+2. BODY STRUCTURE
+   - Over 500 lines? \u2192 needs progressive disclosure (essentials in body, details in references/)
+   - Is there a "When to Use" section in the body? \u2192 that belongs in the frontmatter description
+   - Are workflow steps clear and sequential?
+   - Are phases/steps numbered for easy reference?
+   - Is there a clear guard clause (preconditions before starting)?
+
+3. TOKEN EFFICIENCY
+   - Verbose explanations that could be condensed without losing meaning?
+   - Redundant examples (one clear example > three repetitive ones)?
+   - Reference material that should be in a references/ subdirectory?
+   - Emotional emphasis (bold, caps, exclamation marks) that wastes tokens without improving adherence?
+   - Duplicated instructions (same rule stated multiple times in different sections)?
+
+4. CONTRADICTION DETECTION
+   - Instructions that conflict with SOUL.md behavioral rules?
+     (e.g., skill says "be thorough and detailed" but SOUL.md says "be concise")
+   - Tone mismatches between skill and personality?
+   - Conflicting tool usage patterns?
+   - Internal contradictions within the skill itself?
+
+5. COMPLIANCE & CLARITY
+   - Negative framing ("DO NOT do X") that should be positive ("do Y instead")?
+   - Vague rules the AI is unlikely to follow consistently?
+   - Emotional escalation ("NEVER EVER", "THIS IS CRITICAL") \u2014 does it add compliance or just tokens?
+   - Instructions that rely on the AI "remembering" without structural enforcement?`);
+  sections.push("[Skill File Content]");
+  sections.push(skillContent);
+  sections.push("[SOUL.md (for contradiction check)]");
+  sections.push(soulMd || "(empty)");
+  if (stats.dependentSkills.length > 0) {
+    const depContents = loadDependentSkillContents(stats.dependentSkills, ccClawSkillsDir);
+    if (depContents.length > 0) {
+      sections.push("[Referenced Skill Contents]");
+      for (const dep of depContents) {
+        sections.push(`--- ${dep.name} ---`);
+        sections.push(dep.content);
+      }
+    }
+  }
+  sections.push(`[Output Format]
+For each finding, output EXACTLY this format. Separate multiple findings with "---" on its own line.
+
+FINDING: <short title, max 80 chars>
+AREA: <frontmatter | body | efficiency | contradiction | compliance>
+SEVERITY: <critical | warning | info>
+DETAIL: <1-3 sentences explaining the issue AND its specific impact on AI compliance>
+LOCATION: <SKILL.md:line or SKILL.md:section, e.g. "SKILL.md:## Phase 1" or "SKILL.md:45">
+SUGGESTION: <specific actionable fix>
+DIFF:
+<proposed changes as diff lines, + for additions, - for removals>
+---
+
+If the skill is well-constructed after thorough analysis, output: NO_FINDINGS`);
+  return sections.join("\n\n");
+}
+var init_skill_audit = __esm({
+  "src/optimizer/skill-audit.ts"() {
+    "use strict";
+  }
+});
+
+// src/optimizer/analyze.ts
+var analyze_exports2 = {};
+__export(analyze_exports2, {
+  getModelDisplayInfo: () => getModelDisplayInfo,
+  isWeakModel: () => isWeakModel,
+  listCcClawSkills: () => listCcClawSkills,
+  parseOptimizeOutput: () => parseOptimizeOutput,
+  resolveOptimizeAdapter: () => resolveOptimizeAdapter,
+  runIdentityAudit: () => runIdentityAudit,
+  runSkillAudit: () => runSkillAudit
+});
+import { spawn as spawn6 } from "child_process";
+import { createInterface as createInterface5 } from "readline";
+import { readFileSync as readFileSync12, existsSync as existsSync21, readdirSync as readdirSync11 } from "fs";
+import { join as join22 } from "path";
+import { homedir as homedir7 } from "os";
+function parseOptimizeOutput(raw, validAreas) {
+  if (!raw || raw.includes("NO_FINDINGS")) return [];
+  if (!raw.includes("FINDING:")) return [];
+  const blocks = raw.split(/\n---\n/).slice(0, MAX_FINDINGS);
+  const results = [];
+  for (const block of blocks) {
+    const findingMatch = block.match(/^FINDING:\s*(.+)/m);
+    const areaMatch = block.match(/^AREA:\s*(.+)/m);
+    const severityMatch = block.match(/^SEVERITY:\s*(.+)/m);
+    const detailMatch = block.match(/^DETAIL:\s*(.+)/m);
+    const locationMatch = block.match(/^LOCATION:\s*(.+)/m);
+    const suggestionMatch = block.match(/^SUGGESTION:\s*(.+)/m);
+    const diffMatch = block.match(/^DIFF:\n([\s\S]*?)$/m);
+    if (!findingMatch || !areaMatch) continue;
+    const area = areaMatch[1].trim().toLowerCase();
+    if (!validAreas.includes(area)) continue;
+    const severity = severityMatch?.[1]?.trim().toLowerCase() ?? "info";
+    if (!VALID_SEVERITIES.includes(severity)) continue;
+    results.push({
+      title: findingMatch[1].trim().slice(0, 80),
+      area,
+      severity,
+      detail: detailMatch?.[1]?.trim() ?? "",
+      location: locationMatch?.[1]?.trim() ?? "",
+      suggestion: suggestionMatch?.[1]?.trim() ?? "",
+      proposedDiff: diffMatch?.[1]?.trim() ?? ""
+    });
+  }
+  return results;
+}
+async function spawnAnalysis2(adapter, model2, prompt, timeoutMs = ANALYSIS_TIMEOUT_MS2) {
+  const config2 = adapter.buildSpawnConfig({
+    prompt,
+    model: model2,
+    permMode: "yolo",
+    allowedTools: []
+  });
+  const env = adapter.getEnv();
+  let resultText = "";
+  let accumulatedText = "";
+  await new Promise((resolve) => {
+    const proc = spawn6(config2.executable, config2.args, {
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...config2.cwd ? { cwd: config2.cwd } : {}
+    });
+    proc.stderr?.resume();
+    const rl2 = createInterface5({ input: proc.stdout });
+    const timeout = setTimeout(() => {
+      warn(`[optimizer] Analysis timeout (${adapter.id}:${model2})`);
+      rl2.close();
+      proc.kill("SIGTERM");
+      setTimeout(() => proc.kill("SIGKILL"), 2e3);
+    }, timeoutMs);
+    rl2.on("line", (line) => {
+      if (!line.trim()) return;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        return;
+      }
+      const events = adapter.parseLine(msg);
+      for (const ev of events) {
+        if (ev.type === "text" && ev.text) accumulatedText = appendTextChunk(accumulatedText, ev.text);
+        if (ev.type === "result") {
+          resultText = ev.resultText || accumulatedText;
+          if (adapter.shouldKillOnResult()) {
+            rl2.close();
+            proc.kill("SIGTERM");
+          }
+        }
+      }
+    });
+    proc.on("error", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    proc.on("close", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+  if (!resultText) resultText = accumulatedText;
+  return resultText;
+}
+function resolveOptimizeAdapter(chatId) {
+  try {
+    const adapter = getAdapterForChat(chatId);
+    return { adapter, model: adapter.defaultModel };
+  } catch {
+    try {
+      const adapter = getAdapter("claude");
+      return { adapter, model: adapter.defaultModel };
+    } catch {
+      return null;
+    }
+  }
+}
+function isWeakModel(adapter, model2) {
+  const weakPatterns = [
+    "flash",
+    "haiku",
+    "mini",
+    "4o-mini",
+    "gpt-4o-mini"
+  ];
+  const lower = model2.toLowerCase();
+  return weakPatterns.some((p) => lower.includes(p));
+}
+function getModelDisplayInfo(chatId) {
+  const resolved = resolveOptimizeAdapter(chatId);
+  if (!resolved) return null;
+  const { getThinkingLevel: getThinkingLevel2 } = (init_store5(), __toCommonJS(store_exports5));
+  const thinkingLevel = getThinkingLevel2(chatId);
+  return {
+    backend: resolved.adapter.displayName,
+    model: resolved.model,
+    thinkingLevel,
+    isWeak: isWeakModel(resolved.adapter, resolved.model)
+  };
+}
+function readIdentityFile3(filename) {
+  try {
+    return readFileSync12(join22(IDENTITY_PATH, filename), "utf-8");
+  } catch {
+    return "";
+  }
+}
+function loadContextFiles() {
+  const contextDir = join22(homedir7(), ".cc-claw", "workspace", "context");
+  const results = [];
+  if (!existsSync21(contextDir)) return results;
+  try {
+    for (const entry of readdirSync11(contextDir)) {
+      if (!entry.endsWith(".md")) continue;
+      try {
+        const content = readFileSync12(join22(contextDir, entry), "utf-8");
+        results.push({ name: entry, content });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+async function runIdentityAudit(chatId) {
+  const resolved = resolveOptimizeAdapter(chatId);
+  if (!resolved) throw new Error("No AI backend available for analysis");
+  const { adapter, model: model2 } = resolved;
+  log(`[optimizer] Running identity audit with ${adapter.id}:${model2}`);
+  let pendingProposals = 0;
+  try {
+    const { getPendingInsightCount: getPendingInsightCount2 } = (init_store4(), __toCommonJS(store_exports4));
+    const { getPrimaryChatId: getPrimaryChatId2 } = (init_resolve(), __toCommonJS(resolve_exports));
+    const reflChatId = getPrimaryChatId2() || chatId;
+    pendingProposals = getPendingInsightCount2(getDb(), reflChatId);
+  } catch {
+  }
+  let driftPercent = null;
+  try {
+    const { calculateDrift: calculateDrift2 } = (init_apply(), __toCommonJS(apply_exports));
+  } catch {
+  }
+  const stats = computeIdentityStats(pendingProposals, driftPercent);
+  const soulMd = readIdentityFile3("SOUL.md");
+  const userMd = readIdentityFile3("USER.md");
+  const ccClawMd = readIdentityFile3("CC-CLAW.md");
+  const contextFiles = loadContextFiles();
+  const prompt = buildIdentityAuditPrompt(soulMd, userMd, ccClawMd, stats, contextFiles);
+  const raw = await spawnAnalysis2(adapter, model2, prompt);
+  const findings = parseOptimizeOutput(raw, VALID_IDENTITY_AREAS);
+  log(`[optimizer] Identity audit complete: ${findings.length} findings`);
+  return {
+    findings,
+    tokenReport: buildTokenReport(stats),
+    model: model2,
+    backend: adapter.id,
+    target: "identity"
+  };
+}
+async function runSkillAudit(chatId, skillPath) {
+  const resolved = resolveOptimizeAdapter(chatId);
+  if (!resolved) throw new Error("No AI backend available for analysis");
+  const { adapter, model: model2 } = resolved;
+  const stats = computeSkillStats(skillPath);
+  log(`[optimizer] Running skill audit on ${stats.skillName} with ${adapter.id}:${model2}`);
+  const soulMd = readIdentityFile3("SOUL.md");
+  const ccClawSkillsDir = join22(homedir7(), ".cc-claw", "workspace", "skills");
+  const skillContent = readFileSync12(skillPath, "utf-8");
+  const prompt = buildSkillAuditPrompt(skillContent, stats, soulMd, ccClawSkillsDir);
+  const raw = await spawnAnalysis2(adapter, model2, prompt);
+  const findings = parseOptimizeOutput(raw, VALID_SKILL_AREAS);
+  log(`[optimizer] Skill audit complete for ${stats.skillName}: ${findings.length} findings`);
+  return {
+    findings,
+    tokenReport: buildSkillTokenReport(stats),
+    model: model2,
+    backend: adapter.id,
+    target: stats.skillName
+  };
+}
+function listCcClawSkills() {
+  const skillsDir = join22(homedir7(), ".cc-claw", "workspace", "skills");
+  const entries = [];
+  if (!existsSync21(skillsDir)) return entries;
+  try {
+    for (const dir of readdirSync11(skillsDir)) {
+      const skillFile = join22(skillsDir, dir, "SKILL.md");
+      if (!existsSync21(skillFile)) continue;
+      let description = "skill";
+      try {
+        const content = readFileSync12(skillFile, "utf-8");
+        const descMatch = content.match(/description:\s*>?\s*\n?\s*(.+)/);
+        if (descMatch) description = descMatch[1].trim().slice(0, 60);
+      } catch {
+      }
+      entries.push({ name: dir, path: skillFile, description });
+    }
+  } catch {
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+var ANALYSIS_TIMEOUT_MS2, MAX_FINDINGS, VALID_IDENTITY_AREAS, VALID_SKILL_AREAS, VALID_SEVERITIES;
+var init_analyze2 = __esm({
+  "src/optimizer/analyze.ts"() {
+    "use strict";
+    init_log();
+    init_text_utils();
+    init_paths();
+    init_backends();
+    init_store5();
+    init_identity_audit();
+    init_skill_audit();
+    ANALYSIS_TIMEOUT_MS2 = 18e4;
+    MAX_FINDINGS = 8;
+    VALID_IDENTITY_AREAS = [
+      "structural",
+      "routing",
+      "efficiency",
+      "evolve",
+      "quality",
+      "completeness"
+    ];
+    VALID_SKILL_AREAS = [
+      "frontmatter",
+      "body",
+      "efficiency",
+      "contradiction",
+      "compliance"
+    ];
+    VALID_SEVERITIES = ["critical", "warning", "info"];
+  }
+});
+
+// src/optimizer/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  buildFindingKeyboard: () => buildFindingKeyboard,
+  buildFindingMessage: () => buildFindingMessage,
+  buildIdentityAuditKeyboard: () => buildIdentityAuditKeyboard,
+  buildIdentityAuditSummary: () => buildIdentityAuditSummary,
+  buildMainMenuKeyboard: () => buildMainMenuKeyboard,
+  buildMainMenuMessage: () => buildMainMenuMessage,
+  buildModelRecommendationKeyboard: () => buildModelRecommendationKeyboard,
+  buildModelRecommendationMessage: () => buildModelRecommendationMessage,
+  buildProgressMessage: () => buildProgressMessage,
+  buildReviewCompleteKeyboard: () => buildReviewCompleteKeyboard,
+  buildReviewCompleteMessage: () => buildReviewCompleteMessage2,
+  buildSkillAuditKeyboard: () => buildSkillAuditKeyboard,
+  buildSkillAuditSummary: () => buildSkillAuditSummary,
+  buildSkillPickerKeyboard: () => buildSkillPickerKeyboard,
+  buildSkillPickerMessage: () => buildSkillPickerMessage
+});
+function severityEmoji(severity) {
+  switch (severity) {
+    case "critical":
+      return "\u{1F534}";
+    case "warning":
+      return "\u26A0\uFE0F";
+    case "info":
+      return "\u2139\uFE0F";
+    default:
+      return "\u2022";
+  }
+}
+function areaEmoji(area) {
+  switch (area) {
+    case "structural":
+      return "\u{1F4D0}";
+    case "routing":
+      return "\u{1F4C2}";
+    case "efficiency":
+      return "\u{1F4B0}";
+    case "evolve":
+      return "\u{1F504}";
+    case "quality":
+      return "\u2728";
+    case "completeness":
+      return "\u{1F464}";
+    case "frontmatter":
+      return "\u{1F4CB}";
+    case "body":
+      return "\u{1F4DD}";
+    case "contradiction":
+      return "\u26A1";
+    case "compliance":
+      return "\u2705";
+    default:
+      return "\u2022";
+  }
+}
+function buildMainMenuMessage(backend2, model2, thinkingLevel) {
+  const thinkText = thinkingLevel !== "off" && thinkingLevel !== "auto" ? ` | Thinking: ${thinkingLevel}` : thinkingLevel === "auto" ? " | Thinking: auto" : "";
+  return [
+    "\u{1F527} CC-Claw Optimizer",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    "AI-powered analysis of your identity files and skills.",
+    "Optimize for clarity, efficiency, and compliance.",
+    "",
+    `\u2699\uFE0F Using: ${backend2} ${model2}${thinkText}`
+  ].join("\n");
+}
+function buildMainMenuKeyboard() {
+  return [
+    [
+      { label: "\u{1F9E0} Identity Audit", data: "opt:identity" },
+      { label: "\u{1F9E9} Skill Audit", data: "opt:skill-menu" }
+    ],
+    [
+      { label: "\u274C Close", data: "opt:close" }
+    ]
+  ];
+}
+function buildModelRecommendationMessage(currentModel) {
+  return [
+    "\u{1F527} CC-Claw Optimizer",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    `\u26A0\uFE0F You're using ${currentModel} \u2014 for best audit results,`,
+    "an advanced model is recommended."
+  ].join("\n");
+}
+function buildModelRecommendationKeyboard() {
+  return [
+    [
+      { label: "\u26A1 Continue anyway", data: "opt:model-ok" },
+      { label: "\u{1F9E0} Switch model first", data: "opt:model-switch", style: "primary" }
+    ],
+    [
+      { label: "\u274C Cancel", data: "opt:close" }
+    ]
+  ];
+}
+function buildProgressMessage(target, backend2, model2, thinkingLevel) {
+  const thinkText = thinkingLevel !== "off" ? ` | Thinking: ${thinkingLevel}` : "";
+  return `\u{1F50D} Analyzing ${target}...
+Using ${backend2} ${model2}${thinkText}`;
+}
+function buildIdentityAuditSummary(result) {
+  const { findings, tokenReport, model: model2, backend: backend2 } = result;
+  const tr = tokenReport;
+  const identityAreas = ["structural", "routing", "efficiency", "evolve", "quality", "completeness"];
+  const lines = [
+    "\u{1F9E0} Identity Audit Complete",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    ""
+  ];
+  for (const area of identityAreas) {
+    const emoji = areaEmoji(area);
+    const label2 = area.charAt(0).toUpperCase() + area.slice(1);
+    const areaFindings = findings.filter((f) => f.area === area);
+    const status = areaFindings.length === 0 ? "\u2705 Clean" : `\u26A0\uFE0F ${areaFindings.length} finding${areaFindings.length > 1 ? "s" : ""}`;
+    lines.push(`${emoji} ${label2.padEnd(14)} ${status}`);
+  }
+  lines.push("");
+  lines.push(`\u{1F4B0} Token footprint: ~${tr.estimatedTokens}/message`);
+  lines.push(`   (SOUL: ~${Math.ceil(tr.soulChars / 4)} + USER: ~${Math.ceil(tr.userChars / 4)} + System: ~${Math.ceil(tr.boilerplateChars / 4)})`);
+  if (findings.length > 0) {
+    lines.push("");
+    lines.push(`${findings.length} finding${findings.length > 1 ? "s" : ""} to review`);
+  } else {
+    lines.push("");
+    lines.push("\u2705 All checks passed \u2014 your identity files are clean!");
+  }
+  lines.push("");
+  lines.push(`Analyzed by: ${backend2} ${model2}`);
+  return lines.join("\n");
+}
+function buildIdentityAuditKeyboard(findingsCount) {
+  if (findingsCount === 0) {
+    return [[{ label: "\u2705 Done", data: "opt:close" }]];
+  }
+  return [
+    [
+      { label: "\u{1F4CB} Review Findings", data: "opt:review:0", style: "primary" },
+      { label: "\u274C Close", data: "opt:close" }
+    ]
+  ];
+}
+function buildSkillAuditSummary(result) {
+  const { findings, tokenReport, model: model2, backend: backend2, target } = result;
+  const tr = tokenReport;
+  const skillAreas = ["frontmatter", "body", "efficiency", "contradiction", "compliance"];
+  const lines = [
+    `\u{1F9E9} Skill Audit: ${target}`,
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    ""
+  ];
+  for (const area of skillAreas) {
+    const emoji = areaEmoji(area);
+    const label2 = area.charAt(0).toUpperCase() + area.slice(1);
+    const areaFindings = findings.filter((f) => f.area === area);
+    const status = areaFindings.length === 0 ? "\u2705 Clean" : `\u26A0\uFE0F ${areaFindings.length} finding${areaFindings.length > 1 ? "s" : ""}`;
+    lines.push(`${emoji} ${label2.padEnd(14)} ${status}`);
+  }
+  lines.push("");
+  lines.push(`\u{1F4CA} Skill size: ${tr.lineCount} lines, ~${tr.estimatedTokens} tokens`);
+  if (findings.length > 0) {
+    lines.push("");
+    lines.push(`${findings.length} finding${findings.length > 1 ? "s" : ""} to review`);
+  } else {
+    lines.push("");
+    lines.push("\u2705 All checks passed \u2014 this skill is well-constructed!");
+  }
+  lines.push("");
+  lines.push(`Analyzed by: ${backend2} ${model2}`);
+  return lines.join("\n");
+}
+function buildSkillAuditKeyboard(findingsCount) {
+  if (findingsCount === 0) {
+    return [[{ label: "\u2705 Done", data: "opt:close" }]];
+  }
+  return [
+    [
+      { label: "\u{1F4CB} Review Findings", data: "opt:review:0", style: "primary" },
+      { label: "\u274C Close", data: "opt:close" }
+    ]
+  ];
+}
+function buildFindingMessage(finding, index, total) {
+  const lines = [
+    `${severityEmoji(finding.severity)} Finding ${index + 1}/${total} \u2014 ${finding.area}`,
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    finding.title,
+    "",
+    `\u{1F4CD} ${finding.location}`,
+    "",
+    finding.detail
+  ];
+  if (finding.suggestion) {
+    lines.push("");
+    lines.push(`\u{1F4A1} ${finding.suggestion}`);
+  }
+  if (finding.proposedDiff) {
+    lines.push("");
+    lines.push("Proposed change:");
+    lines.push("```");
+    lines.push(finding.proposedDiff);
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+function buildFindingKeyboard(index, total, hasDiff) {
+  if (hasDiff) {
+    return [[
+      { label: "\u2705 Apply Fix", data: `opt:fix:${index}`, style: "success" },
+      { label: "\u23ED\uFE0F Skip", data: `opt:skip:${index}` },
+      { label: "\u{1F6D1} Stop Review", data: "opt:stop", style: "danger" }
+    ]];
+  }
+  return [[
+    { label: "\u23ED\uFE0F Next", data: `opt:skip:${index}` },
+    { label: "\u{1F6D1} Stop Review", data: "opt:stop", style: "danger" }
+  ]];
+}
+function buildSkillPickerMessage(page, totalPages) {
+  return [
+    "\u{1F9E9} Select a Skill to Audit",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    "Showing CC-Claw skills (~/.cc-claw/workspace/skills/)",
+    ...totalPages > 1 ? [`Page ${page + 1}/${totalPages}`] : []
+  ].join("\n");
+}
+function buildSkillPickerKeyboard(skills2, page) {
+  const totalPages = Math.ceil(skills2.length / SKILLS_PER_PAGE2);
+  const start = page * SKILLS_PER_PAGE2;
+  const pageSkills = skills2.slice(start, start + SKILLS_PER_PAGE2);
+  const rows = [];
+  for (let i = 0; i < pageSkills.length; i += 2) {
+    const row = [];
+    row.push({ label: pageSkills[i].name, data: `opt:skill-pick:${pageSkills[i].name}` });
+    if (pageSkills[i + 1]) {
+      row.push({ label: pageSkills[i + 1].name, data: `opt:skill-pick:${pageSkills[i + 1].name}` });
+    }
+    rows.push(row);
+  }
+  const navRow = [];
+  if (page > 0) navRow.push({ label: "\u2190 Prev", data: `opt:skill-page:${page - 1}` });
+  if (page < totalPages - 1) navRow.push({ label: "Next \u2192", data: `opt:skill-page:${page + 1}` });
+  navRow.push({ label: "\u274C Cancel", data: "opt:close" });
+  rows.push(navRow);
+  return rows;
+}
+function buildReviewCompleteMessage2(applied, skipped, total) {
+  return [
+    "\u{1F527} Review Complete",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    `\u2705 Applied: ${applied}`,
+    `\u23ED\uFE0F Skipped: ${skipped}`,
+    `\u{1F4CA} Total findings: ${total}`
+  ].join("\n");
+}
+function buildReviewCompleteKeyboard() {
+  return [[{ label: "\u2705 Done", data: "opt:close" }]];
+}
+var SKILLS_PER_PAGE2;
+var init_ui2 = __esm({
+  "src/optimizer/ui.ts"() {
+    "use strict";
+    SKILLS_PER_PAGE2 = 6;
+  }
+});
+
+// src/router/optimize.ts
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, existsSync as existsSync22 } from "fs";
+import { join as join23 } from "path";
+import { homedir as homedir8 } from "os";
+async function handleOptimizeCommand(chatId, channel, _args) {
+  const { getModelDisplayInfo: getModelDisplayInfo2 } = await Promise.resolve().then(() => (init_analyze2(), analyze_exports2));
+  const {
+    buildMainMenuMessage: buildMainMenuMessage2,
+    buildMainMenuKeyboard: buildMainMenuKeyboard2,
+    buildModelRecommendationMessage: buildModelRecommendationMessage2,
+    buildModelRecommendationKeyboard: buildModelRecommendationKeyboard2
+  } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
+  const modelInfo = getModelDisplayInfo2(chatId);
+  if (!modelInfo) {
+    await channel.sendText(chatId, "No AI backend available. Configure one first.", { parseMode: "plain" });
+    return;
+  }
+  if (modelInfo.isWeak) {
+    const msg2 = buildModelRecommendationMessage2(modelInfo.model);
+    if (typeof channel.sendKeyboard === "function") {
+      await channel.sendKeyboard(chatId, msg2, buildModelRecommendationKeyboard2());
+    } else {
+      await channel.sendText(chatId, msg2 + "\n\nSwitch to an advanced model for best results.", { parseMode: "plain" });
+    }
+    return;
+  }
+  const msg = buildMainMenuMessage2(modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel);
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendKeyboard(chatId, msg, buildMainMenuKeyboard2());
+  } else {
+    await channel.sendText(chatId, msg, { parseMode: "plain" });
+  }
+}
+async function handleOptimizeCallback(chatId, data, channel) {
+  const parts = data.split(":");
+  const action = parts[1];
+  switch (action) {
+    case "identity": {
+      await runIdentityAuditFlow(chatId, channel);
+      break;
+    }
+    case "skill-menu": {
+      await showSkillPicker(chatId, channel, 0);
+      break;
+    }
+    case "skill-page": {
+      const page = parseInt(parts[2], 10) || 0;
+      await showSkillPicker(chatId, channel, page);
+      break;
+    }
+    case "skill-pick": {
+      const skillName = parts.slice(2).join(":");
+      await runSkillAuditFlow(chatId, channel, skillName);
+      break;
+    }
+    case "model-ok": {
+      const { getModelDisplayInfo: getModelDisplayInfo2 } = await Promise.resolve().then(() => (init_analyze2(), analyze_exports2));
+      const { buildMainMenuMessage: buildMainMenuMessage2, buildMainMenuKeyboard: buildMainMenuKeyboard2 } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
+      const modelInfo = getModelDisplayInfo2(chatId);
+      if (!modelInfo) return;
+      const msg = buildMainMenuMessage2(modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel);
+      if (typeof channel.sendKeyboard === "function") {
+        await channel.sendKeyboard(chatId, msg, buildMainMenuKeyboard2());
+      }
+      break;
+    }
+    case "model-switch": {
+      await channel.sendText(chatId, "Use /model or /backend to switch to a more powerful model, then run /optimize again.", { parseMode: "plain" });
+      break;
+    }
+    case "review": {
+      const index = parseInt(parts[2], 10) || 0;
+      await showFinding(chatId, channel, index);
+      break;
+    }
+    case "fix": {
+      const fixIndex = parseInt(parts[2], 10) || 0;
+      await applyFinding(chatId, channel, fixIndex);
+      break;
+    }
+    case "skip": {
+      const skipIndex = parseInt(parts[2], 10) || 0;
+      await skipFinding(chatId, channel, skipIndex);
+      break;
+    }
+    case "stop": {
+      await stopReview(chatId, channel);
+      break;
+    }
+    case "close": {
+      activeSessions.delete(chatId);
+      await channel.sendText(chatId, "Optimizer closed.", { parseMode: "plain" });
+      break;
+    }
+    default:
+      break;
+  }
+}
+async function runIdentityAuditFlow(chatId, channel) {
+  const { getModelDisplayInfo: getModelDisplayInfo2, runIdentityAudit: runIdentityAudit2 } = await Promise.resolve().then(() => (init_analyze2(), analyze_exports2));
+  const {
+    buildProgressMessage: buildProgressMessage2,
+    buildIdentityAuditSummary: buildIdentityAuditSummary2,
+    buildIdentityAuditKeyboard: buildIdentityAuditKeyboard2
+  } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
+  const modelInfo = getModelDisplayInfo2(chatId);
+  if (!modelInfo) return;
+  await channel.sendText(
+    chatId,
+    buildProgressMessage2("identity files", modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel),
+    { parseMode: "plain" }
+  );
+  try {
+    const result = await runIdentityAudit2(chatId);
+    activeSessions.set(chatId, {
+      chatId,
+      result,
+      currentIndex: 0,
+      applied: [],
+      skipped: []
+    });
+    const summary = buildIdentityAuditSummary2(result);
+    if (typeof channel.sendKeyboard === "function") {
+      await channel.sendKeyboard(chatId, summary, buildIdentityAuditKeyboard2(result.findings.length));
+    } else {
+      await channel.sendText(chatId, summary, { parseMode: "plain" });
+    }
+  } catch (e) {
+    await channel.sendText(chatId, `Identity audit failed: ${e}`, { parseMode: "plain" });
+  }
+}
+async function showSkillPicker(chatId, channel, page) {
+  const { listCcClawSkills: listCcClawSkills2 } = await Promise.resolve().then(() => (init_analyze2(), analyze_exports2));
+  const { buildSkillPickerMessage: buildSkillPickerMessage2, buildSkillPickerKeyboard: buildSkillPickerKeyboard2 } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
+  const skills2 = listCcClawSkills2();
+  if (skills2.length === 0) {
+    await channel.sendText(chatId, "No CC-Claw skills found in ~/.cc-claw/workspace/skills/", { parseMode: "plain" });
+    return;
+  }
+  const totalPages = Math.ceil(skills2.length / 6);
+  const msg = buildSkillPickerMessage2(page, totalPages);
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendKeyboard(chatId, msg, buildSkillPickerKeyboard2(skills2, page));
+  } else {
+    const list = skills2.map((s) => `\u2022 ${s.name} \u2014 ${s.description}`).join("\n");
+    await channel.sendText(chatId, msg + "\n\n" + list, { parseMode: "plain" });
+  }
+}
+async function runSkillAuditFlow(chatId, channel, skillName) {
+  const { getModelDisplayInfo: getModelDisplayInfo2, runSkillAudit: runSkillAudit2 } = await Promise.resolve().then(() => (init_analyze2(), analyze_exports2));
+  const {
+    buildProgressMessage: buildProgressMessage2,
+    buildSkillAuditSummary: buildSkillAuditSummary2,
+    buildSkillAuditKeyboard: buildSkillAuditKeyboard2
+  } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
+  const modelInfo = getModelDisplayInfo2(chatId);
+  if (!modelInfo) return;
+  const skillPath = join23(homedir8(), ".cc-claw", "workspace", "skills", skillName, "SKILL.md");
+  await channel.sendText(
+    chatId,
+    buildProgressMessage2(`skill: ${skillName}`, modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel),
+    { parseMode: "plain" }
+  );
+  try {
+    const result = await runSkillAudit2(chatId, skillPath);
+    activeSessions.set(chatId, {
+      chatId,
+      result,
+      currentIndex: 0,
+      applied: [],
+      skipped: []
+    });
+    const summary = buildSkillAuditSummary2(result);
+    if (typeof channel.sendKeyboard === "function") {
+      await channel.sendKeyboard(chatId, summary, buildSkillAuditKeyboard2(result.findings.length));
+    } else {
+      await channel.sendText(chatId, summary, { parseMode: "plain" });
+    }
+  } catch (e) {
+    await channel.sendText(chatId, `Skill audit failed: ${e}`, { parseMode: "plain" });
+  }
+}
+async function showFinding(chatId, channel, index) {
+  const session2 = activeSessions.get(chatId);
+  if (!session2) {
+    await channel.sendText(chatId, "No active optimizer session. Run /optimize first.", { parseMode: "plain" });
+    return;
+  }
+  const { findings } = session2.result;
+  if (index >= findings.length) {
+    await finishReview(chatId, channel);
+    return;
+  }
+  session2.currentIndex = index;
+  const finding = findings[index];
+  const { buildFindingMessage: buildFindingMessage2, buildFindingKeyboard: buildFindingKeyboard2 } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
+  const msg = buildFindingMessage2(finding, index, findings.length);
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendKeyboard(chatId, msg, buildFindingKeyboard2(index, findings.length, !!finding.proposedDiff));
+  } else {
+    await channel.sendText(chatId, msg, { parseMode: "plain" });
+  }
+}
+async function applyFinding(chatId, channel, index) {
+  const session2 = activeSessions.get(chatId);
+  if (!session2) return;
+  const finding = session2.result.findings[index];
+  if (!finding || !finding.proposedDiff) {
+    await channel.sendText(chatId, "No diff to apply for this finding.", { parseMode: "plain" });
+    await showFinding(chatId, channel, index + 1);
+    return;
+  }
+  try {
+    const targetPath = resolveTargetFile(finding.location, session2.result.target);
+    if (!targetPath) {
+      await channel.sendText(chatId, `Cannot determine target file from location: ${finding.location}`, { parseMode: "plain" });
+      session2.skipped.push(index);
+      await showFinding(chatId, channel, index + 1);
+      return;
+    }
+    if (!existsSync22(targetPath)) {
+      await channel.sendText(chatId, `Target file not found: ${targetPath}`, { parseMode: "plain" });
+      session2.skipped.push(index);
+      await showFinding(chatId, channel, index + 1);
+      return;
+    }
+    const original = readFileSync13(targetPath, "utf-8");
+    const backupPath = targetPath + `.bak.${Date.now()}`;
+    writeFileSync7(backupPath, original, "utf-8");
+    pruneBackups2(targetPath);
+    const { applyDiff: applyDiff2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
+    const newContent = applyDiff2(original, finding.proposedDiff, "replace");
+    if (newContent === original) {
+      await channel.sendText(chatId, `\u26A0\uFE0F Diff produced no changes. The content may have already been modified.`, { parseMode: "plain" });
+      session2.skipped.push(index);
+      await showFinding(chatId, channel, index + 1);
+      return;
+    }
+    writeFileSync7(targetPath, newContent, "utf-8");
+    session2.applied.push(index);
+    if (targetPath.includes("identity/")) {
+      try {
+        const { syncNativeCliFiles: syncNativeCliFiles2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+        await syncNativeCliFiles2();
+      } catch {
+      }
+    }
+    await channel.sendText(chatId, `\u2705 Applied: ${finding.title}`, { parseMode: "plain" });
+  } catch (e) {
+    const errorMsg = e?.message ?? String(e);
+    await channel.sendText(chatId, `\u274C Failed to apply fix: ${errorMsg}`, { parseMode: "plain" });
+    session2.skipped.push(index);
+  }
+  await showFinding(chatId, channel, index + 1);
+}
+async function skipFinding(chatId, channel, index) {
+  const session2 = activeSessions.get(chatId);
+  if (!session2) return;
+  session2.skipped.push(index);
+  await showFinding(chatId, channel, index + 1);
+}
+async function stopReview(chatId, channel) {
+  await finishReview(chatId, channel);
+}
+async function finishReview(chatId, channel) {
+  const session2 = activeSessions.get(chatId);
+  if (!session2) return;
+  const { buildReviewCompleteMessage: buildReviewCompleteMessage3, buildReviewCompleteKeyboard: buildReviewCompleteKeyboard2 } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
+  const msg = buildReviewCompleteMessage3(
+    session2.applied.length,
+    session2.skipped.length,
+    session2.result.findings.length
+  );
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendKeyboard(chatId, msg, buildReviewCompleteKeyboard2());
+  } else {
+    await channel.sendText(chatId, msg, { parseMode: "plain" });
+  }
+  activeSessions.delete(chatId);
+}
+function resolveTargetFile(location, auditTarget) {
+  const ccClawHome = join23(homedir8(), ".cc-claw");
+  const filePart = location.split(":")[0]?.trim();
+  if (!filePart) return null;
+  if (filePart === "SOUL.md") return join23(ccClawHome, "identity", "SOUL.md");
+  if (filePart === "USER.md") return join23(ccClawHome, "identity", "USER.md");
+  if (filePart === "CC-CLAW.md") return join23(ccClawHome, "identity", "CC-CLAW.md");
+  if (filePart === "SKILL.md" && auditTarget !== "identity") {
+    return join23(ccClawHome, "workspace", "skills", auditTarget, "SKILL.md");
+  }
+  return null;
+}
+function pruneBackups2(absolutePath) {
+  const { readdirSync: readDir, unlinkSync: unlink4 } = __require("fs");
+  const { dirname: dirName } = __require("path");
+  const dir = dirName(absolutePath);
+  const baseName = absolutePath.split("/").pop() ?? "";
+  try {
+    const backups = readDir(dir).filter((f) => f.startsWith(baseName + ".bak.")).sort().map((f) => join23(dir, f));
+    while (backups.length > 3) {
+      const oldest = backups.shift();
+      try {
+        unlink4(oldest);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var activeSessions;
+var init_optimize = __esm({
+  "src/router/optimize.ts"() {
+    "use strict";
+    activeSessions = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/router/commands.ts
+import { readFile as readFile6 } from "fs/promises";
+async function handleCommand(msg, channel) {
+  const { chatId, command, commandArgs } = msg;
+  if (command?.startsWith("/")) {
+    return handleBackendCommand(command, chatId, channel);
+  }
+  switch (command) {
+    case "start":
+    case "help": {
+      if (typeof channel.sendKeyboard === "function") {
+        await sendHelpCategories(chatId, channel);
+      } else {
+        await channel.sendText(
+          chatId,
+          "CC-Claw Commands\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n\n" + Object.entries(HELP_CATEGORIES).map(
+            ([cat, cmds]) => `${cat}:
+${cmds.map((c) => `  ${c.cmd} \u2014 ${c.desc}`).join("\n")}`
+          ).join("\n\n"),
+          { parseMode: "plain" }
+        );
+      }
+      break;
+    }
+    case "menu":
+    case "m": {
+      if (typeof channel.sendKeyboard === "function") {
+        const header2 = `\u{1F43E} ${buildSectionHeader("CC-Claw")}`;
+        await channel.sendKeyboard(chatId, header2, [
+          [{ label: "New Chat", data: "menu:newchat" }, { label: "Status", data: "menu:status" }],
+          [{ label: "Backend", data: "menu:backend" }, { label: "Model", data: "menu:model" }],
+          [{ label: "Jobs", data: "menu:jobs" }, { label: "Memory", data: "menu:memory" }],
+          [{ label: "History", data: "menu:history" }, { label: "Help", data: "menu:help" }]
+        ]);
+      } else {
+        await channel.sendText(
+          chatId,
+          "CC-Claw Menu:\n/newchat \xB7 /status \xB7 /backend \xB7 /model\n/jobs \xB7 /memory \xB7 /history \xB7 /help",
+          { parseMode: "plain" }
+        );
+      }
+      break;
+    }
+    case "stop": {
+      const stopped = stopAgent(chatId);
+      stopAllSideQuests(chatId);
+      cancelAllAgents(chatId);
+      await channel.sendText(
+        chatId,
+        stopped ? "Stopping current task..." : "Nothing is running.",
+        { parseMode: "plain" }
+      );
+      if (stopped && typeof channel.sendKeyboard === "function") {
+        await channel.sendKeyboard(chatId, "", [
+          [{ label: "\u{1F195} New Chat", data: "menu:newchat" }]
+        ]);
+      }
+      break;
+    }
+    case "permissions": {
+      const currentMode = getMode(chatId);
+      const currentExecMode = getExecMode(chatId);
+      if (typeof channel.sendKeyboard === "function") {
+        const permButtons = Object.entries(PERM_MODES).map(([id, label2]) => [{
+          label: `${id === currentMode ? "\u2713 " : ""}${label2}`,
+          data: `perms:${id}`,
+          ...id === currentMode ? { style: "primary" } : {}
+        }]);
+        const approvalOn = currentExecMode === "approved";
+        permButtons.push([{
+          label: `${approvalOn ? "\u2713 " : ""}\u{1F512} Approve Before Execute: ${approvalOn ? "ON" : "OFF"}`,
+          data: `execmode:${approvalOn ? "yolo" : "approved"}`,
+          ...approvalOn ? { style: "primary" } : {}
+        }]);
+        await channel.sendKeyboard(chatId, "Permission & Execution Settings:", permButtons);
+      } else {
+        const lines = ["Permission modes:", ""];
+        for (const [id, label2] of Object.entries(PERM_MODES)) {
+          lines.push(`${id === currentMode ? "\u2713 " : "  "}/permissions ${id} \u2014 ${label2}`);
+        }
+        lines.push("");
+        lines.push(`Approve Before Execute: ${currentExecMode === "approved" ? "ON" : "OFF"}`);
+        await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
+      }
+      break;
+    }
+    case "verbose": {
       const currentVerbose = getVerboseLevel(chatId);
       const buttons = Object.entries(VERBOSE_LEVELS).map(([id, label2]) => [{
         label: `${id === currentVerbose ? "\u2713 " : ""}${label2}`,
@@ -16971,8 +18395,8 @@ ${lines.join("\n")}`, { parseMode: "plain" });
       if (arg.startsWith("/") || arg.startsWith("~")) {
         const resolvedPath = arg.startsWith("~") ? arg.replace("~", process.env.HOME ?? "") : arg;
         setCwd(chatId, resolvedPath);
-        const basename2 = resolvedPath.split("/").filter(Boolean).pop();
-        if (basename2) upsertBookmark(chatId, basename2, resolvedPath, false);
+        const basename3 = resolvedPath.split("/").filter(Boolean).pop();
+        if (basename3) upsertBookmark(chatId, basename3, resolvedPath, false);
         logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Working directory set to ${resolvedPath}`, detail: { field: "cwd", value: resolvedPath } });
         await sendCwdSessionChoice(chatId, resolvedPath, channel);
         return;
@@ -17133,20 +18557,29 @@ Use /model to pick a model with \u26A1 thinking support.`, { parseMode: "plain"
         break;
       }
       if (typeof channel.sendKeyboard === "function") {
+        const showThinkingUi = getShowThinkingUi(chatId);
         const buttons = modelInfo.thinkingLevels.map((level) => [{
           label: `${level === currentLevel ? "\u2713 " : ""}${level === "auto" ? "Auto" : capitalize(level)}`,
           data: `thinking:${level}`,
           ...level === currentLevel ? { style: "primary" } : {}
         }]);
+        buttons.push([{
+          label: `${showThinkingUi ? "\u2713 " : ""}\u{1F4AD} Show Thinking`,
+          data: "thinking_show_ui:toggle",
+          ...showThinkingUi ? { style: "primary" } : {}
+        }]);
         await channel.sendKeyboard(
           chatId,
           `\u{1F4AD} Thinking Level \u2014 ${shortModelName(currentModel)}
-Current: ${capitalize(currentLevel)}`,
+Current: ${capitalize(currentLevel)}
+Show thinking tokens: ${showThinkingUi ? "On" : "Off"}${adapter.id === "gemini" ? "\n\n\u26A0\uFE0F Gemini CLI doesn't stream thinking tokens" : ""}`,
           buttons
         );
       } else {
+        const showThinkingUi = getShowThinkingUi(chatId);
         await channel.sendText(chatId, `Thinking: ${capitalize(currentLevel)}
 Levels: ${modelInfo.thinkingLevels.join(", ")}
+Show thinking tokens: ${showThinkingUi ? "On" : "Off"}
 Set via callback (keyboard required).`, { parseMode: "plain" });
       }
       break;
@@ -17744,8 +19177,8 @@ ${agentLines.join("\n")}`, buttons);
         lines.push(`  \u2705 <b>cc-claw</b>  <i>Agent orchestrator (spawn, tasks, inbox)</i>`);
       }
       const { execFile: execFile5 } = await import("child_process");
-      const { homedir: homedir10 } = await import("os");
-      const discoveryCwd = homedir10();
+      const { homedir: homedir12 } = await import("os");
+      const discoveryCwd = homedir12();
       const runnerResults = await Promise.allSettled(
         getAllRunners().map((runner) => {
           const listCmd = runner.getMcpListCommand();
@@ -17887,6 +19320,10 @@ Message: "${testMsg}"`, { parseMode: "plain" });
       await handleEvolveCommand(chatId, channel);
       break;
     }
+    case "optimize": {
+      await handleOptimizeCommand(chatId, channel, commandArgs);
+      break;
+    }
     default:
       await channel.sendText(chatId, `Unknown command: /${command}. Type /help for available commands.`, { parseMode: "plain" });
   }
@@ -17925,6 +19362,7 @@ var init_commands = __esm({
     init_ui();
     init_state();
     init_evolve2();
+    init_optimize();
   }
 });
 
@@ -18046,6 +19484,21 @@ Select thinking/effort level:`,
     logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Thinking level set to ${level}`, detail: { field: "thinking", value: level } });
     const label2 = level === "auto" ? "Auto" : level.replace("_", " ").replace(/\b\w/g, (c) => c.toUpperCase());
     await channel.sendText(chatId, `Thinking level set to: ${label2}`, { parseMode: "plain" });
+  } else if (data === "thinking_show_ui:toggle") {
+    const newState = toggleShowThinkingUi(chatId);
+    logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Show thinking UI ${newState ? "enabled" : "disabled"}`, detail: { field: "show_thinking_ui", value: String(newState) } });
+    let msg;
+    if (newState) {
+      let backendId;
+      try {
+        backendId = getAdapterForChat(chatId).id;
+      } catch {
+      }
+      msg = backendId === "gemini" ? "\u{1F4AD} Thinking tokens enabled \u2014 but Gemini CLI doesn't stream them." : "\u{1F4AD} Thinking tokens will now stream live in the status message.";
+    } else {
+      msg = "\u{1F4AD} Thinking tokens hidden. Toggle on again via /thinking.";
+    }
+    await channel.sendText(chatId, msg, { parseMode: "plain" });
   } else if (data.startsWith("summarizer:")) {
     const rest = data.slice(11);
     if (rest === "auto") {
@@ -18144,9 +19597,12 @@ ${PERM_MODES[chosen]}`,
     }
     removePendingPlan(chatId);
     await channel.sendText(chatId, "\u2705 Approved. Executing...", { parseMode: "plain" });
+    bypassBusyCheck.add(chatId);
     const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+    const overrideMsg = `[SYSTEM: Planning mode disabled. Execution APPROVED. Please execute the plan.]
+${plan.originalMessage}`;
     await handleMessage2(
-      { text: `>>${plan.originalMessage}`, chatId, source: "telegram", type: "text", senderName: "", messageId: "" },
+      { text: `>>${overrideMsg}`, chatId, source: "telegram", type: "text", senderName: "", messageId: "" },
       channel
     );
     return;
@@ -18169,9 +19625,12 @@ ${PERM_MODES[chosen]}`,
     removePendingPlan(chatId);
     setExecMode(chatId, "yolo");
     await channel.sendText(chatId, "\u26A1 Switched to YOLO mode. Executing without approval gate...", { parseMode: "plain" });
+    bypassBusyCheck.add(chatId);
     const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+    const overrideMsg = `[SYSTEM: Planning mode disabled. YOLO mode enabled. Proceed immediately without asking for approval.]
+${plan.originalMessage}`;
     await handleMessage2(
-      { text: `>>${plan.originalMessage}`, chatId, source: "telegram", type: "text", senderName: "", messageId: "" },
+      { text: `>>${overrideMsg}`, chatId, source: "telegram", type: "text", senderName: "", messageId: "" },
       channel
     );
     return;
@@ -18179,9 +19638,8 @@ ${PERM_MODES[chosen]}`,
     const mode = data.split(":")[1];
     if (mode === "approved" || mode === "yolo") {
       setExecMode(chatId, mode);
-      const desc = mode === "approved" ? "AI will show a plan for approval before acting." : "AI will execute immediately without showing a plan.";
-      await channel.sendText(chatId, `Execution mode set to <b>${mode}</b>.
-${desc}`, { parseMode: "html" });
+      const msg = mode === "approved" ? "\u{1F512} Approve Before Execute: <b>ON</b>\nAI will show a plan for your approval before acting." : "\u26A1 Approve Before Execute: <b>OFF</b>\nAI will execute immediately (YOLO mode).";
+      await channel.sendText(chatId, msg, { parseMode: "html" });
     }
     return;
   } else if (data.startsWith("model_sig:")) {
@@ -18611,6 +20069,9 @@ ${rotationNote}`, { parseMode: "html" });
   } else if (data.startsWith("reflect:")) {
     await handleReflectCallback(chatId, data, channel);
     return;
+  } else if (data.startsWith("opt:")) {
+    await handleOptimizeCallback(chatId, data, channel);
+    return;
   } else if (data.startsWith("summ:")) {
     const action = data.slice(5);
     if (action === "all") {
@@ -18951,10 +20412,216 @@ var init_callbacks = __esm({
     init_state();
     init_sidequest();
     init_evolve2();
+    init_optimize();
     init_commands();
   }
 });
 
+// src/router/live-status.ts
+var live_status_exports = {};
+__export(live_status_exports, {
+  LiveStatusMessage: () => LiveStatusMessage,
+  makeLiveStatus: () => makeLiveStatus
+});
+function dedupThinking(entries) {
+  const out = [];
+  for (const e of entries) {
+    const last = out[out.length - 1];
+    if (e.kind === "thinking" && last?.kind === "thinking" && last.text === e.text) continue;
+    out.push(e);
+  }
+  return out;
+}
+function renderEntry(e) {
+  if (e.kind === "thinking") {
+    const truncated = e.text.length > MAX_THINKING_CHARS ? e.text.slice(0, MAX_THINKING_CHARS) + "\u2026" : e.text;
+    return `\u{1F4AD} ${truncated}`;
+  }
+  return e.text;
+}
+function renderEntries(entries, modelLabel, elapsedMs) {
+  const elapsedSec = (elapsedMs / 1e3).toFixed(1);
+  const lines = [`\u23F3 ${modelLabel} \xB7 ${elapsedSec}s`, ""];
+  for (const e of entries) lines.push(renderEntry(e));
+  return lines.join("\n");
+}
+function renderFinal(entries, modelLabel, elapsedSec) {
+  const lines = [`\u2705 ${modelLabel} \xB7 ${elapsedSec}s`, ""];
+  for (const e of entries) lines.push(renderEntry(e));
+  if (lines.length === 2) return `\u2705 ${modelLabel} \xB7 ${elapsedSec}s`;
+  return lines.join("\n");
+}
+function renderFrozen(entries, modelLabel, elapsedSec) {
+  const lines = [`\u{1F4CE} ${modelLabel} \xB7 ${elapsedSec}s`, ""];
+  for (const e of entries) lines.push(renderEntry(e));
+  if (lines.length === 2) return `\u{1F4CE} ${modelLabel} \xB7 ${elapsedSec}s`;
+  return lines.join("\n");
+}
+function makeLiveStatus(chatId, channel, modelLabel, verboseLevel, showThinking) {
+  const liveStatus = new LiveStatusMessage(chatId, channel, modelLabel, verboseLevel, showThinking);
+  const toolCb = async (toolName, input, result) => {
+    if (result === void 0) {
+      liveStatus.addToolStart(toolName, input);
+    } else {
+      liveStatus.addToolEnd(toolName, result);
+    }
+  };
+  return { liveStatus, toolCb };
+}
+var FLUSH_INTERVAL_MS, MAX_ENTRIES, MAX_THINKING_CHARS, SPILLOVER_THRESHOLD, LiveStatusMessage;
+var init_live_status = __esm({
+  "src/router/live-status.ts"() {
+    "use strict";
+    init_log();
+    init_helpers();
+    FLUSH_INTERVAL_MS = 1e3;
+    MAX_ENTRIES = 50;
+    MAX_THINKING_CHARS = 800;
+    SPILLOVER_THRESHOLD = 3800;
+    LiveStatusMessage = class {
+      constructor(chatId, channel, modelLabel, verboseLevel, showThinking = false) {
+        this.chatId = chatId;
+        this.channel = channel;
+        this.modelLabel = modelLabel;
+        this.verboseLevel = verboseLevel;
+        this.showThinking = showThinking;
+      }
+      messageId = null;
+      entries = [];
+      startTime = Date.now();
+      flushTimer = null;
+      lastRendered = "";
+      finalized = false;
+      /**
+       * Entries already frozen in previous spillover messages.
+       * Tracked so we only render NEW entries in the current message.
+       */
+      frozenEntryCount = 0;
+      /** Send the initial status message. Must be called before adding entries. */
+      async init() {
+        if (!this.channel.sendTextReturningId) return;
+        try {
+          const initial = `\u23F3 ${this.modelLabel} \xB7 Processing\u2026`;
+          this.messageId = await this.channel.sendTextReturningId(this.chatId, initial, "plain") ?? null;
+          if (this.messageId) {
+            this.flushTimer = setInterval(() => this.flush().catch(() => {
+            }), FLUSH_INTERVAL_MS);
+          }
+        } catch (err) {
+          log(`[live-status] init failed: ${err}`);
+        }
+      }
+      /** Add a thinking token preview (from NdjsonEvent type "thinking"). */
+      addThinking(text) {
+        if (!this.showThinking) return;
+        if (!this.messageId || this.finalized) return;
+        const trimmed = text.trim();
+        if (!trimmed) return;
+        this.entries.push({ kind: "thinking", text: trimmed, ts: Date.now() });
+        this.trimEntries();
+      }
+      /** Add a tool start event. */
+      addToolStart(toolName, input, toolId) {
+        if (!this.messageId || this.finalized) return;
+        const formatted = formatToolStart(toolName, input, this.verboseLevel);
+        this.entries.push({ kind: "tool_start", text: formatted, toolId, ts: Date.now() });
+        this.trimEntries();
+      }
+      /** Add a tool result event. */
+      addToolEnd(toolName, result, toolId) {
+        if (!this.messageId || this.finalized) return;
+        if (this.verboseLevel !== "verbose") return;
+        const formatted = formatToolResult(toolName, result ?? "");
+        if (formatted) {
+          this.entries.push({ kind: "tool_end", text: formatted, toolId, ts: Date.now() });
+          this.trimEntries();
+        }
+      }
+      /** Add an informational entry (e.g. backend capability notes). */
+      addInfo(text) {
+        if (!this.messageId || this.finalized) return;
+        this.entries.push({ kind: "info", text, ts: Date.now() });
+        this.trimEntries();
+      }
+      /**
+       * Finalize the status message: replace the spinner with ✅ and elapsed time.
+       * Stops the flush loop. No-op if no message was created (channel doesn't support editing).
+       */
+      async finalize(elapsedMs) {
+        this.finalized = true;
+        if (this.flushTimer) {
+          clearInterval(this.flushTimer);
+          this.flushTimer = null;
+        }
+        if (!this.messageId || !this.channel.editText) return;
+        const elapsedSec = (elapsedMs / 1e3).toFixed(1);
+        const currentEntries = dedupThinking(this.entries.slice(this.frozenEntryCount));
+        const body = renderFinal(currentEntries, this.modelLabel, elapsedSec);
+        try {
+          await this.channel.editText(this.chatId, this.messageId, body, "plain");
+        } catch (err) {
+          log(`[live-status] finalize edit failed: ${err}`);
+        }
+      }
+      /** Returns the messageId of the status message (if created). */
+      getMessageId() {
+        return this.messageId;
+      }
+      // ── Internal ──────────────────────────────────────────────────────────
+      async flush() {
+        if (this.finalized || !this.messageId || !this.channel.editText) return;
+        const currentEntries = dedupThinking(this.entries.slice(this.frozenEntryCount));
+        const body = renderEntries(currentEntries, this.modelLabel, Date.now() - this.startTime);
+        if (body.length > SPILLOVER_THRESHOLD && currentEntries.length > 1) {
+          await this.spillover();
+          return;
+        }
+        if (body === this.lastRendered) return;
+        this.lastRendered = body;
+        try {
+          await this.channel.editText(this.chatId, this.messageId, body, "plain");
+        } catch (err) {
+          log(`[live-status] flush edit failed: ${err}`);
+        }
+      }
+      /**
+       * Freeze the current message and start a new continuation message.
+       * The frozen message keeps its content (with 📎 prefix) — nothing is lost.
+       */
+      async spillover() {
+        if (!this.channel.editText || !this.channel.sendTextReturningId || !this.messageId) return;
+        const elapsedSec = ((Date.now() - this.startTime) / 1e3).toFixed(1);
+        const currentEntries = dedupThinking(this.entries.slice(this.frozenEntryCount));
+        const frozenBody = renderFrozen(currentEntries, this.modelLabel, elapsedSec);
+        try {
+          await this.channel.editText(this.chatId, this.messageId, frozenBody, "plain");
+        } catch (err) {
+          log(`[live-status] spillover freeze failed: ${err}`);
+        }
+        this.frozenEntryCount = this.entries.length;
+        try {
+          const initial = `\u23F3 ${this.modelLabel} \xB7 ${elapsedSec}s (continued)`;
+          const newId = await this.channel.sendTextReturningId(this.chatId, initial, "plain") ?? null;
+          if (newId) {
+            this.messageId = newId;
+            this.lastRendered = "";
+          }
+        } catch (err) {
+          log(`[live-status] spillover new message failed: ${err}`);
+        }
+      }
+      trimEntries() {
+        if (this.entries.length > MAX_ENTRIES + this.frozenEntryCount) {
+          const keep = this.entries.slice(0, this.frozenEntryCount);
+          const current = this.entries.slice(this.frozenEntryCount);
+          const trimmed = current.slice(current.length - MAX_ENTRIES);
+          this.entries = [...keep, ...trimmed];
+        }
+      }
+    };
+  }
+});
+
 // src/router.ts
 var router_exports = {};
 __export(router_exports, {
@@ -19072,7 +20739,7 @@ async function handleText(msg, channel) {
   let intent = classifyIntent(text, chatId);
   const cleanText = text.startsWith(">>") ? text.slice(2).trim() : text;
   let bootstrapTier = intent === "chat" ? "chat" : void 0;
-  let maxTurns = intent === "chat" ? 1 : void 0;
+  let maxTurns = void 0;
   let effectiveAgentMode = msg.agentMode ?? getAgentMode(chatId);
   const observedSubagents = /* @__PURE__ */ new Set();
   if (effectiveAgentMode === "auto" && !text.startsWith(">>")) {
@@ -19238,15 +20905,20 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
       });
       typingActive2 = false;
       if (planResponse.text) {
-        storePendingPlan(chatId, planResponse.text, cleanText || text);
+        let planText = planResponse.text.replace(/\[REACT:.+?\]/g, "").replace(/\[SEND_FILE:.+?\]/g, "").replace(/\[GENERATE_IMAGE:.+?\]/g, "").replace(/\[HISTORY_SEARCH:[^\]]+\]/g, "").trim();
+        const PLAN_DISPLAY_LIMIT = 3500;
+        if (planText.length > PLAN_DISPLAY_LIMIT) {
+          planText = planText.slice(0, PLAN_DISPLAY_LIMIT) + "\n\u2026(truncated \u2014 tap Approve to proceed)";
+        }
+        storePendingPlan(chatId, planText, cleanText || text);
         if (typeof channel.sendKeyboard === "function") {
-          await channel.sendKeyboard(chatId, `\u{1F50D} ${planResponse.text}`, [
+          await channel.sendKeyboard(chatId, `\u{1F50D} ${planText}`, [
             [
               { label: "\u2705 Approve", data: "exec:approve", style: "success" },
               { label: "\u274C Reject", data: "exec:reject", style: "danger" }
             ],
             [
-              { label: "\u26A1 Skip & YOLO", data: "exec:yolo" }
+              { label: "\u26A1 Approve & Switch to YOLO", data: "exec:yolo" }
             ]
           ]);
         } else {
@@ -19276,7 +20948,24 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
   try {
     const tMode = getMode(chatId);
     const tVerbose = getVerboseLevel(chatId);
-    const tToolCb = tVerbose !== "off" ? makeToolActionCallback(chatId, channel, tVerbose) : void 0;
+    const adapter = getAdapterForChat(chatId);
+    const modelLabel = formatModelShort(model2 ?? adapter.defaultModel);
+    const { getShowThinkingUi: getShowThinkingUi3 } = await Promise.resolve().then(() => (init_chat_settings(), chat_settings_exports));
+    const showThinkingUi = getShowThinkingUi3(chatId);
+    const needsLiveStatus = tVerbose !== "off" || showThinkingUi;
+    let liveStatus = null;
+    let tToolCb;
+    if (needsLiveStatus) {
+      const { makeLiveStatus: makeLiveStatus2 } = await Promise.resolve().then(() => (init_live_status(), live_status_exports));
+      const effectiveVerbose = tVerbose === "off" ? "normal" : tVerbose;
+      const ls = makeLiveStatus2(chatId, channel, modelLabel, effectiveVerbose, showThinkingUi);
+      liveStatus = ls.liveStatus;
+      tToolCb = tVerbose !== "off" ? ls.toolCb : void 0;
+      await liveStatus.init();
+      if (showThinkingUi && adapter.id === "gemini") {
+        liveStatus.addInfo("\u{1F4AD} Thinking display not available for Gemini");
+      }
+    }
     const sigT0 = Date.now();
     const response = await askAgent(chatId, cleanText || text, {
       cwd: getCwd(chatId),
@@ -19286,6 +20975,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
       bootstrapTier,
       maxTurns,
       agentMode: effectiveAgentMode,
+      onThinking: liveStatus ? (chunk) => liveStatus.addThinking(chunk) : void 0,
       onSubagentActivity: (backendId2, info) => {
         observedSubagents.add(info.name);
         try {
@@ -19319,26 +21009,31 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         });
       }
     });
-    const elapsedSec = ((Date.now() - sigT0) / 1e3).toFixed(1);
+    const elapsedMs = Date.now() - sigT0;
+    const elapsedSec = (elapsedMs / 1e3).toFixed(1);
+    if (liveStatus && response.thinkingText?.trim()) {
+      liveStatus.addThinking(response.thinkingText.trim());
+    }
+    if (liveStatus) await liveStatus.finalize(elapsedMs);
     if (response.usage) addUsage(chatId, response.usage.input, response.usage.output, response.usage.cacheRead, model2, void 0, response.usage.contextSize);
     let responseText = response.text;
     const sigEnabled = getModelSignature(chatId);
     if (sigEnabled === "on" && responseText && !responseText.startsWith("(No response")) {
-      const adapter = getAdapterForChat(chatId);
-      const modelId = response.resolvedModel ?? model2 ?? adapter.defaultModel;
+      const adapter2 = getAdapterForChat(chatId);
+      const modelId = response.resolvedModel ?? model2 ?? adapter2.defaultModel;
       const thinking2 = getThinkingLevel(chatId) || "auto";
       const shortModel = formatModelShort(modelId);
       let slotTag = "";
-      if (adapter.id === "gemini") {
+      if (adapter2.id === "gemini") {
         const slotId = getChatGeminiSlotId(chatId);
         if (slotId) {
           const slot = getGeminiSlots().find((s) => s.id === slotId);
           if (slot) slotTag = ` \xB7 ${slot.label || `slot-${slot.id}`}`;
         }
-      } else if (adapter.id === "claude" || adapter.id === "codex") {
-        const slotId = getChatBackendSlotId(chatId, adapter.id);
+      } else if (adapter2.id === "claude" || adapter2.id === "codex") {
+        const slotId = getChatBackendSlotId(chatId, adapter2.id);
         if (slotId) {
-          const slot = getBackendSlots(adapter.id).find((s) => s.id === slotId);
+          const slot = getBackendSlots(adapter2.id).find((s) => s.id === slotId);
           if (slot) slotTag = ` \xB7 ${slot.label || `slot-${slot.id}`}`;
         }
       }
@@ -19372,10 +21067,10 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
     await sendResponse(chatId, channel, responseText, msg.messageId);
     try {
       const { detectAndLogSignals: detectAndLogSignals2 } = await Promise.resolve().then(() => (init_detect(), detect_exports));
-      const adapter = getAdapterForChat(chatId);
+      const adapter2 = getAdapterForChat(chatId);
       detectAndLogSignals2(chatId, cleanText || text, responseText, {
-        backendId: adapter.id,
-        model: model2 ?? adapter.defaultModel,
+        backendId: adapter2.id,
+        model: model2 ?? adapter2.defaultModel,
         thinkingLevel: getThinkingLevel(chatId) || void 0
       });
     } catch (e) {
@@ -19828,7 +21523,7 @@ var init_cron = __esm({
 });
 
 // src/agents/runners/wrap-backend.ts
-import { join as join20 } from "path";
+import { join as join24 } from "path";
 function buildMcpCommands(backendId) {
   const exe = backendId === "cursor" ? "agent" : backendId;
   return {
@@ -19922,7 +21617,7 @@ function wrapBackendAdapter(adapter) {
       const configPath = writeMcpConfigFile(server);
       return ["--mcp-config", configPath];
     },
-    getSkillPath: () => join20(SKILLS_PATH, `agent-${adapter.id}.md`)
+    getSkillPath: () => join24(SKILLS_PATH, `agent-${adapter.id}.md`)
   };
 }
 var BACKEND_CAPABILITIES;
@@ -19973,18 +21668,18 @@ var init_wrap_backend = __esm({
 });
 
 // src/agents/runners/config-loader.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync9, existsSync as existsSync19, mkdirSync as mkdirSync9, watchFile, unwatchFile } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync14, readdirSync as readdirSync12, existsSync as existsSync23, mkdirSync as mkdirSync9, watchFile, unwatchFile } from "fs";
+import { join as join25 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 function resolveExecutable(config2) {
-  if (existsSync19(config2.executable)) return config2.executable;
+  if (existsSync23(config2.executable)) return config2.executable;
   try {
     return execFileSync2("which", [config2.executable], { encoding: "utf-8" }).trim();
   } catch {
   }
   for (const fallback of config2.executableFallbacks ?? []) {
     const resolved = fallback.replace(/^~/, process.env.HOME ?? "");
-    if (existsSync19(resolved)) return resolved;
+    if (existsSync23(resolved)) return resolved;
   }
   return config2.executable;
 }
@@ -20110,12 +21805,12 @@ function configToRunner(config2) {
     prepareMcpInjection() {
       return [];
     },
-    getSkillPath: () => join21(SKILLS_PATH, `agent-${config2.id}.md`)
+    getSkillPath: () => join25(SKILLS_PATH, `agent-${config2.id}.md`)
   };
 }
 function loadRunnerConfig(filePath) {
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     warn(`[runners] Failed to load config ${filePath}: ${err}`);
@@ -20123,14 +21818,14 @@ function loadRunnerConfig(filePath) {
   }
 }
 function loadAllRunnerConfigs() {
-  if (!existsSync19(RUNNERS_PATH)) {
+  if (!existsSync23(RUNNERS_PATH)) {
     mkdirSync9(RUNNERS_PATH, { recursive: true });
     return [];
   }
-  const files = readdirSync9(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
+  const files = readdirSync12(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   const configs = [];
   for (const file of files) {
-    const config2 = loadRunnerConfig(join21(RUNNERS_PATH, file));
+    const config2 = loadRunnerConfig(join25(RUNNERS_PATH, file));
     if (config2) configs.push(config2);
   }
   return configs;
@@ -20151,16 +21846,16 @@ function registerConfigRunners() {
   return count;
 }
 function watchRunnerConfigs(onChange) {
-  if (!existsSync19(RUNNERS_PATH)) return;
+  if (!existsSync23(RUNNERS_PATH)) return;
   for (const prev of watchedFiles) {
-    if (!existsSync19(prev)) {
+    if (!existsSync23(prev)) {
       unwatchFile(prev);
       watchedFiles.delete(prev);
     }
   }
-  const files = readdirSync9(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
+  const files = readdirSync12(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   for (const file of files) {
-    const fullPath = join21(RUNNERS_PATH, file);
+    const fullPath = join25(RUNNERS_PATH, file);
     if (watchedFiles.has(fullPath)) continue;
     watchedFiles.add(fullPath);
     watchFile(fullPath, { interval: 5e3 }, () => {
@@ -20601,7 +22296,8 @@ var init_telegram2 = __esm({
           { command: "chats", description: "Manage multi-chat aliases" },
           { command: "intent", description: "Test intent classifier on a message" },
           { command: "evolve", description: "Self-learning & evolution controls" },
-          { command: "reflect", description: "Trigger reflection analysis" }
+          { command: "reflect", description: "Trigger reflection analysis" },
+          { command: "optimize", description: "Audit identity files and skills" }
         ]);
         this.bot.on("message", async (ctx) => {
           const chatId = ctx.chat.id.toString();
@@ -20785,13 +22481,24 @@ var init_telegram2 = __esm({
           }
           keyboard.row();
         }
+        const MAX_KEYBOARD_TEXT = 4e3;
+        const safeText = text.length > MAX_KEYBOARD_TEXT ? text.slice(0, MAX_KEYBOARD_TEXT) + "\n\n\u2026(truncated)" : text;
         try {
-          const msg = await this.bot.api.sendMessage(numericChatId(chatId), text, {
+          const msg = await this.bot.api.sendMessage(numericChatId(chatId), safeText, {
             reply_markup: keyboard
           });
           return msg.message_id.toString();
-        } catch {
-          return void 0;
+        } catch (err) {
+          error(`[telegram] sendKeyboard failed (chat=${chatId}, textLen=${text.length}):`, err);
+          try {
+            const fallbackMsg = await this.bot.api.sendMessage(numericChatId(chatId), "\u2B06\uFE0F (see above for details)", {
+              reply_markup: keyboard
+            });
+            return fallbackMsg.message_id.toString();
+          } catch (fallbackErr) {
+            error(`[telegram] sendKeyboard fallback also failed:`, fallbackErr);
+            return void 0;
+          }
         }
       }
       async reactToMessage(chatId, messageId, emoji) {
@@ -20995,19 +22702,19 @@ var init_telegram2 = __esm({
 });
 
 // src/skills/bootstrap.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { readdir as readdir6, readFile as readFile8, writeFile as writeFile5, copyFile } from "fs/promises";
-import { join as join22, dirname as dirname4 } from "path";
+import { join as join26, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function copyAgentManifestSkills() {
-  if (!existsSync20(PKG_SKILLS)) return;
+  if (!existsSync24(PKG_SKILLS)) return;
   try {
     const entries = await readdir6(PKG_SKILLS, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.startsWith("agent-") || !entry.name.endsWith(".md")) continue;
-      const src = join22(PKG_SKILLS, entry.name);
-      const dest = join22(SKILLS_PATH, entry.name);
-      if (existsSync20(dest)) continue;
+      const src = join26(PKG_SKILLS, entry.name);
+      const dest = join26(SKILLS_PATH, entry.name);
+      if (existsSync24(dest)) continue;
       await copyFile(src, dest);
       log(`[skills] Bootstrapped ${entry.name} to ${SKILLS_PATH}`);
     }
@@ -21017,8 +22724,8 @@ async function copyAgentManifestSkills() {
 }
 async function bootstrapSkills() {
   await copyAgentManifestSkills();
-  const usmDir = join22(SKILLS_PATH, USM_DIR_NAME);
-  if (existsSync20(usmDir)) return;
+  const usmDir = join26(SKILLS_PATH, USM_DIR_NAME);
+  if (existsSync24(usmDir)) return;
   try {
     const entries = await readdir6(SKILLS_PATH);
     const dirs = entries.filter((e) => !e.startsWith("."));
@@ -21040,8 +22747,8 @@ async function bootstrapSkills() {
   }
 }
 async function patchUsmForCcClaw(usmDir) {
-  const skillPath = join22(usmDir, "SKILL.md");
-  if (!existsSync20(skillPath)) return;
+  const skillPath = join26(usmDir, "SKILL.md");
+  if (!existsSync24(skillPath)) return;
   try {
     let content = await readFile8(skillPath, "utf-8");
     let patched = false;
@@ -21086,8 +22793,8 @@ var init_bootstrap = __esm({
     USM_REPO = "jacob-bd/universal-skills-manager";
     USM_DIR_NAME = "universal-skills-manager";
     CC_CLAW_ECOSYSTEM_PATCH = `| **CC-Claw** | \`~/.cc-claw/workspace/skills/\` | N/A (daemon, no project scope) |`;
-    PKG_ROOT = join22(dirname4(fileURLToPath2(import.meta.url)), "..", "..");
-    PKG_SKILLS = join22(PKG_ROOT, "skills");
+    PKG_ROOT = join26(dirname5(fileURLToPath2(import.meta.url)), "..", "..");
+    PKG_SKILLS = join26(PKG_ROOT, "skills");
   }
 });
 
@@ -21309,13 +23016,13 @@ __export(ai_skill_exports, {
   generateAiSkill: () => generateAiSkill,
   installAiSkill: () => installAiSkill
 });
-import { existsSync as existsSync21, writeFileSync as writeFileSync7, mkdirSync as mkdirSync10 } from "fs";
-import { join as join23 } from "path";
-import { homedir as homedir7 } from "os";
+import { existsSync as existsSync25, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
+import { join as join27 } from "path";
+import { homedir as homedir9 } from "os";
 function generateAiSkill() {
   const version = VERSION;
   let systemState = "";
-  if (existsSync21(DB_PATH)) {
+  if (existsSync25(DB_PATH)) {
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = (init_store5(), __toCommonJS(store_exports5));
       const readDb = openDatabaseReadOnly2();
@@ -21719,11 +23426,11 @@ function installAiSkill() {
   const failed = [];
   for (const [backend2, dirs] of Object.entries(BACKEND_SKILL_DIRS2)) {
     for (const dir of dirs) {
-      const skillDir = join23(dir, "cc-claw-cli");
-      const skillPath = join23(skillDir, "SKILL.md");
+      const skillDir = join27(dir, "cc-claw-cli");
+      const skillPath = join27(skillDir, "SKILL.md");
       try {
         mkdirSync10(skillDir, { recursive: true });
-        writeFileSync7(skillPath, skill, "utf-8");
+        writeFileSync8(skillPath, skill, "utf-8");
         installed.push(skillPath);
       } catch {
         failed.push(skillPath);
@@ -21739,11 +23446,11 @@ var init_ai_skill = __esm({
     init_paths();
     init_version();
     BACKEND_SKILL_DIRS2 = {
-      "cc-claw": [join23(homedir7(), ".cc-claw", "workspace", "skills")],
-      claude: [join23(homedir7(), ".claude", "skills")],
-      gemini: [join23(homedir7(), ".gemini", "skills")],
-      codex: [join23(homedir7(), ".agents", "skills")],
-      cursor: [join23(homedir7(), ".cursor", "skills"), join23(homedir7(), ".cursor", "skills-cursor")]
+      "cc-claw": [join27(homedir9(), ".cc-claw", "workspace", "skills")],
+      claude: [join27(homedir9(), ".claude", "skills")],
+      gemini: [join27(homedir9(), ".gemini", "skills")],
+      codex: [join27(homedir9(), ".agents", "skills")],
+      cursor: [join27(homedir9(), ".cursor", "skills"), join27(homedir9(), ".cursor", "skills-cursor")]
     };
   }
 });
@@ -21753,21 +23460,21 @@ var index_exports = {};
 __export(index_exports, {
   main: () => main
 });
-import { mkdirSync as mkdirSync11, existsSync as existsSync22, renameSync as renameSync2, statSync as statSync6, readFileSync as readFileSync12 } from "fs";
-import { join as join24 } from "path";
+import { mkdirSync as mkdirSync11, existsSync as existsSync26, renameSync as renameSync2, statSync as statSync7, readFileSync as readFileSync16 } from "fs";
+import { join as join28 } from "path";
 import dotenv from "dotenv";
 function migrateLayout() {
   const moves = [
-    [join24(CC_CLAW_HOME, "cc-claw.db"), join24(DATA_PATH, "cc-claw.db")],
-    [join24(CC_CLAW_HOME, "cc-claw.db-shm"), join24(DATA_PATH, "cc-claw.db-shm")],
-    [join24(CC_CLAW_HOME, "cc-claw.db-wal"), join24(DATA_PATH, "cc-claw.db-wal")],
-    [join24(CC_CLAW_HOME, "cc-claw.log"), join24(LOGS_PATH, "cc-claw.log")],
-    [join24(CC_CLAW_HOME, "cc-claw.log.1"), join24(LOGS_PATH, "cc-claw.log.1")],
-    [join24(CC_CLAW_HOME, "cc-claw.error.log"), join24(LOGS_PATH, "cc-claw.error.log")],
-    [join24(CC_CLAW_HOME, "cc-claw.error.log.1"), join24(LOGS_PATH, "cc-claw.error.log.1")]
+    [join28(CC_CLAW_HOME, "cc-claw.db"), join28(DATA_PATH, "cc-claw.db")],
+    [join28(CC_CLAW_HOME, "cc-claw.db-shm"), join28(DATA_PATH, "cc-claw.db-shm")],
+    [join28(CC_CLAW_HOME, "cc-claw.db-wal"), join28(DATA_PATH, "cc-claw.db-wal")],
+    [join28(CC_CLAW_HOME, "cc-claw.log"), join28(LOGS_PATH, "cc-claw.log")],
+    [join28(CC_CLAW_HOME, "cc-claw.log.1"), join28(LOGS_PATH, "cc-claw.log.1")],
+    [join28(CC_CLAW_HOME, "cc-claw.error.log"), join28(LOGS_PATH, "cc-claw.error.log")],
+    [join28(CC_CLAW_HOME, "cc-claw.error.log.1"), join28(LOGS_PATH, "cc-claw.error.log.1")]
   ];
   for (const [from, to] of moves) {
-    if (existsSync22(from) && !existsSync22(to)) {
+    if (existsSync26(from) && !existsSync26(to)) {
       try {
         renameSync2(from, to);
       } catch {
@@ -21778,7 +23485,7 @@ function migrateLayout() {
 function rotateLogs() {
   for (const file of [LOG_PATH, ERROR_LOG_PATH]) {
     try {
-      const { size } = statSync6(file);
+      const { size } = statSync7(file);
       if (size > LOG_MAX_BYTES) {
         const archivePath = `${file}.1`;
         try {
@@ -21796,7 +23503,7 @@ async function main() {
   let version = "unknown";
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    version = JSON.parse(readFileSync12(pkgPath, "utf-8")).version;
+    version = JSON.parse(readFileSync16(pkgPath, "utf-8")).version;
   } catch {
   }
   log(`[cc-claw] Starting v${version}`);
@@ -21912,11 +23619,11 @@ async function main() {
   bootstrapSkills().catch((err) => error("[cc-claw] Skill bootstrap failed:", err));
   try {
     const { generateAiSkill: generateAiSkill2 } = await Promise.resolve().then(() => (init_ai_skill(), ai_skill_exports));
-    const { writeFileSync: writeFileSync12, mkdirSync: mkdirSync18 } = await import("fs");
-    const { join: join30 } = await import("path");
-    const skillDir = join30(SKILLS_PATH, "cc-claw-cli");
+    const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync18 } = await import("fs");
+    const { join: join34 } = await import("path");
+    const skillDir = join34(SKILLS_PATH, "cc-claw-cli");
     mkdirSync18(skillDir, { recursive: true });
-    writeFileSync12(join30(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
+    writeFileSync13(join34(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
     log("[cc-claw] AI skill updated");
   } catch {
   }
@@ -21989,10 +23696,10 @@ var init_index = __esm({
     init_health3();
     init_image_gen();
     for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-      if (!existsSync22(dir)) mkdirSync11(dir, { recursive: true });
+      if (!existsSync26(dir)) mkdirSync11(dir, { recursive: true });
     }
     migrateLayout();
-    if (existsSync22(ENV_PATH)) {
+    if (existsSync26(ENV_PATH)) {
       dotenv.config({ path: ENV_PATH });
     } else {
       console.error(`[cc-claw] Config not found at ${ENV_PATH} \u2014 run 'cc-claw setup' first`);
@@ -22013,12 +23720,12 @@ __export(api_client_exports, {
   apiPost: () => apiPost,
   isDaemonRunning: () => isDaemonRunning
 });
-import { readFileSync as readFileSync13, existsSync as existsSync23 } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync27 } from "fs";
 import { request as httpRequest, Agent } from "http";
 function getToken() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync23(TOKEN_PATH)) return readFileSync13(TOKEN_PATH, "utf-8").trim();
+    if (existsSync27(TOKEN_PATH)) return readFileSync17(TOKEN_PATH, "utf-8").trim();
   } catch {
   }
   return null;
@@ -22117,10 +23824,10 @@ __export(service_exports, {
   serviceStatus: () => serviceStatus,
   uninstallService: () => uninstallService
 });
-import { existsSync as existsSync24, mkdirSync as mkdirSync12, writeFileSync as writeFileSync8, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync12, writeFileSync as writeFileSync9, unlinkSync as unlinkSync6 } from "fs";
 import { execFileSync as execFileSync3, execSync as execSync6 } from "child_process";
-import { homedir as homedir8, platform } from "os";
-import { join as join25, dirname as dirname5 } from "path";
+import { homedir as homedir10, platform } from "os";
+import { join as join29, dirname as dirname6 } from "path";
 function xmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -22129,23 +23836,23 @@ function resolveExecutable2(name) {
     return execFileSync3("which", [name], { encoding: "utf-8" }).trim();
   } catch {
     const fallback = process.argv[1];
-    if (fallback && existsSync24(fallback)) return fallback;
+    if (fallback && existsSync28(fallback)) return fallback;
     throw new Error(`Cannot find '${name}' executable. Install globally: npm install -g cc-claw`);
   }
 }
 function getPathDirs() {
-  const nodeBin = dirname5(process.execPath);
-  const home = homedir8();
+  const nodeBin = dirname6(process.execPath);
+  const home = homedir10();
   const dirs = /* @__PURE__ */ new Set([
     nodeBin,
-    join25(home, ".local", "bin"),
+    join29(home, ".local", "bin"),
     "/usr/local/bin",
     "/usr/bin",
     "/bin"
   ]);
   try {
     const prefix = execSync6("npm config get prefix", { encoding: "utf-8" }).trim();
-    if (prefix) dirs.add(join25(prefix, "bin"));
+    if (prefix) dirs.add(join29(prefix, "bin"));
   } catch {
   }
   return [...dirs].join(":");
@@ -22153,7 +23860,7 @@ function getPathDirs() {
 function generatePlist() {
   const ccClawBin = resolveExecutable2("cc-claw");
   const pathDirs = getPathDirs();
-  const home = homedir8();
+  const home = homedir10();
   const safeBin = xmlEscape(ccClawBin);
   const safePaths = xmlEscape(pathDirs);
   const safeHome = xmlEscape(home);
@@ -22203,22 +23910,22 @@ function generatePlist() {
 </plist>`;
 }
 function installMacOS() {
-  const agentsDir = dirname5(PLIST_PATH);
-  if (!existsSync24(agentsDir)) mkdirSync12(agentsDir, { recursive: true });
-  if (!existsSync24(LOGS_PATH)) mkdirSync12(LOGS_PATH, { recursive: true });
-  if (existsSync24(PLIST_PATH)) {
+  const agentsDir = dirname6(PLIST_PATH);
+  if (!existsSync28(agentsDir)) mkdirSync12(agentsDir, { recursive: true });
+  if (!existsSync28(LOGS_PATH)) mkdirSync12(LOGS_PATH, { recursive: true });
+  if (existsSync28(PLIST_PATH)) {
     try {
       execFileSync3("launchctl", ["unload", PLIST_PATH]);
     } catch {
     }
   }
-  writeFileSync8(PLIST_PATH, generatePlist());
+  writeFileSync9(PLIST_PATH, generatePlist());
   console.log(`  Installed: ${PLIST_PATH}`);
   execFileSync3("launchctl", ["load", PLIST_PATH]);
   console.log("  Service loaded and starting.");
 }
 function uninstallMacOS() {
-  if (!existsSync24(PLIST_PATH)) {
+  if (!existsSync28(PLIST_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
@@ -22286,16 +23993,16 @@ Restart=on-failure
 RestartSec=10
 WorkingDirectory=${CC_CLAW_HOME}
 Environment=PATH=${pathDirs}
-Environment=HOME=${homedir8()}
+Environment=HOME=${homedir10()}
 
 [Install]
 WantedBy=default.target
 `;
 }
 function installLinux() {
-  if (!existsSync24(SYSTEMD_DIR)) mkdirSync12(SYSTEMD_DIR, { recursive: true });
-  if (!existsSync24(LOGS_PATH)) mkdirSync12(LOGS_PATH, { recursive: true });
-  writeFileSync8(UNIT_PATH, generateUnit());
+  if (!existsSync28(SYSTEMD_DIR)) mkdirSync12(SYSTEMD_DIR, { recursive: true });
+  if (!existsSync28(LOGS_PATH)) mkdirSync12(LOGS_PATH, { recursive: true });
+  writeFileSync9(UNIT_PATH, generateUnit());
   console.log(`  Installed: ${UNIT_PATH}`);
   execFileSync3("systemctl", ["--user", "daemon-reload"]);
   execFileSync3("systemctl", ["--user", "enable", "cc-claw"]);
@@ -22303,7 +24010,7 @@ function installLinux() {
   console.log("  Service enabled and started.");
 }
 function uninstallLinux() {
-  if (!existsSync24(UNIT_PATH)) {
+  if (!existsSync28(UNIT_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
@@ -22328,7 +24035,7 @@ function statusLinux() {
   }
 }
 function installService() {
-  if (!existsSync24(join25(CC_CLAW_HOME, ".env"))) {
+  if (!existsSync28(join29(CC_CLAW_HOME, ".env"))) {
     console.error(`  Config not found at ${CC_CLAW_HOME}/.env`);
     console.error("  Run 'cc-claw setup' before installing the service.");
     process.exitCode = 1;
@@ -22357,9 +24064,9 @@ var init_service = __esm({
     "use strict";
     init_paths();
     PLIST_LABEL = "com.cc-claw";
-    PLIST_PATH = join25(homedir8(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-    SYSTEMD_DIR = join25(homedir8(), ".config", "systemd", "user");
-    UNIT_PATH = join25(SYSTEMD_DIR, "cc-claw.service");
+    PLIST_PATH = join29(homedir10(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+    SYSTEMD_DIR = join29(homedir10(), ".config", "systemd", "user");
+    UNIT_PATH = join29(SYSTEMD_DIR, "cc-claw.service");
   }
 });
 
@@ -22526,13 +24233,13 @@ var init_daemon = __esm({
 });
 
 // src/cli/resolve-chat.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 function resolveChatId(globalOpts) {
   const explicit = globalOpts.chat;
   if (explicit) return explicit;
   if (_cachedDefault) return _cachedDefault;
   try {
-    const content = readFileSync15(ENV_PATH, "utf-8");
+    const content = readFileSync19(ENV_PATH, "utf-8");
     const match = content.match(/^ALLOWED_CHAT_ID=(.+)$/m);
     if (match) {
       _cachedDefault = match[1].split(",")[0].trim();
@@ -22556,7 +24263,7 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import { existsSync as existsSync25, statSync as statSync7 } from "fs";
+import { existsSync as existsSync29, statSync as statSync8 } from "fs";
 async function statusCommand(globalOpts, localOpts) {
   try {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
@@ -22596,7 +24303,7 @@ async function statusCommand(globalOpts, localOpts) {
     const cwdRow = readDb.prepare("SELECT cwd FROM chat_cwd WHERE chat_id = ?").get(chatId);
     const voiceRow = readDb.prepare("SELECT enabled FROM chat_voice WHERE chat_id = ?").get(chatId);
     const usageRow = readDb.prepare("SELECT * FROM chat_usage WHERE chat_id = ?").get(chatId);
-    const dbStat = existsSync25(DB_PATH) ? statSync7(DB_PATH) : null;
+    const dbStat = existsSync29(DB_PATH) ? statSync8(DB_PATH) : null;
     let daemonRunning = false;
     let daemonInfo = {};
     try {
@@ -22685,12 +24392,12 @@ var doctor_exports = {};
 __export(doctor_exports, {
   doctorCommand: () => doctorCommand
 });
-import { existsSync as existsSync26, statSync as statSync8, accessSync, constants } from "fs";
+import { existsSync as existsSync30, statSync as statSync9, accessSync, constants } from "fs";
 import { execFileSync as execFileSync4 } from "child_process";
 async function doctorCommand(globalOpts, localOpts) {
   const checks = [];
-  if (existsSync26(DB_PATH)) {
-    const size = statSync8(DB_PATH).size;
+  if (existsSync30(DB_PATH)) {
+    const size = statSync9(DB_PATH).size;
     checks.push({ name: "Database", status: "ok", message: `${DB_PATH} (${(size / 1024).toFixed(0)}KB)` });
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
@@ -22719,7 +24426,7 @@ async function doctorCommand(globalOpts, localOpts) {
   } else {
     checks.push({ name: "Database", status: "error", message: `Not found at ${DB_PATH}`, fix: "cc-claw setup" });
   }
-  if (existsSync26(ENV_PATH)) {
+  if (existsSync30(ENV_PATH)) {
     checks.push({ name: "Environment", status: "ok", message: `.env loaded` });
   } else {
     checks.push({ name: "Environment", status: "error", message: "No .env found", fix: "cc-claw setup" });
@@ -22774,7 +24481,7 @@ async function doctorCommand(globalOpts, localOpts) {
   } catch {
   }
   const tokenPath = `${DATA_PATH}/api-token`;
-  if (existsSync26(tokenPath)) {
+  if (existsSync30(tokenPath)) {
     try {
       accessSync(tokenPath, constants.R_OK);
       checks.push({ name: "API token", status: "ok", message: "token file readable" });
@@ -22799,10 +24506,10 @@ async function doctorCommand(globalOpts, localOpts) {
     }
   } catch {
   }
-  if (existsSync26(ERROR_LOG_PATH)) {
+  if (existsSync30(ERROR_LOG_PATH)) {
     try {
-      const { readFileSync: readFileSync22 } = await import("fs");
-      const logContent = readFileSync22(ERROR_LOG_PATH, "utf-8");
+      const { readFileSync: readFileSync26 } = await import("fs");
+      const logContent = readFileSync26(ERROR_LOG_PATH, "utf-8");
       const recentLines = logContent.split("\n").filter(Boolean).slice(-100);
       const last24h = Date.now() - 864e5;
       const recentErrors = recentLines.filter((line) => {
@@ -22925,15 +24632,15 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import { existsSync as existsSync27, readFileSync as readFileSync16, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync20, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
 async function logsCommand(opts) {
   const logFile = opts.error ? ERROR_LOG_PATH : LOG_PATH;
-  if (!existsSync27(logFile)) {
+  if (!existsSync31(logFile)) {
     outputError("LOG_NOT_FOUND", `Log file not found: ${logFile}`);
     process.exit(1);
   }
   const maxLines = parseInt(opts.lines ?? "100", 10);
-  const content = readFileSync16(logFile, "utf-8");
+  const content = readFileSync20(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`));
@@ -22943,7 +24650,7 @@ async function logsCommand(opts) {
     let lastLength = content.length;
     watchFile2(logFile, { interval: 500 }, () => {
       try {
-        const newContent = readFileSync16(logFile, "utf-8");
+        const newContent = readFileSync20(logFile, "utf-8");
         if (newContent.length > lastLength) {
           const newPart = newContent.slice(lastLength);
           process.stdout.write(newPart);
@@ -22980,11 +24687,11 @@ __export(gemini_exports, {
   geminiReorder: () => geminiReorder,
   geminiRotation: () => geminiRotation
 });
-import { existsSync as existsSync28, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, readFileSync as readFileSync17, chmodSync } from "fs";
-import { join as join26 } from "path";
-import { createInterface as createInterface5 } from "readline";
+import { existsSync as existsSync32, mkdirSync as mkdirSync13, writeFileSync as writeFileSync10, readFileSync as readFileSync21, chmodSync } from "fs";
+import { join as join30 } from "path";
+import { createInterface as createInterface6 } from "readline";
 function requireDb() {
-  if (!existsSync28(DB_PATH)) {
+  if (!existsSync32(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -23009,9 +24716,9 @@ async function resolveSlotId(idOrLabel) {
 function resolveOAuthEmail(configHome) {
   if (!configHome) return null;
   try {
-    const accountsPath = join26(configHome, ".gemini", "google_accounts.json");
-    if (!existsSync28(accountsPath)) return null;
-    const accounts = JSON.parse(readFileSync17(accountsPath, "utf-8"));
+    const accountsPath = join30(configHome, ".gemini", "google_accounts.json");
+    if (!existsSync32(accountsPath)) return null;
+    const accounts = JSON.parse(readFileSync21(accountsPath, "utf-8"));
     return accounts.active || null;
   } catch {
     return null;
@@ -23055,7 +24762,7 @@ async function geminiList(globalOpts) {
 }
 async function geminiAddKey(globalOpts, opts) {
   await requireWriteDb();
-  const rl2 = createInterface5({ input: process.stdin, output: process.stdout });
+  const rl2 = createInterface6({ input: process.stdin, output: process.stdout });
   const ask2 = (q) => new Promise((r) => rl2.question(q, r));
   const key = await ask2("Paste your Gemini API key: ");
   rl2.close();
@@ -23093,14 +24800,14 @@ async function geminiAddKey(globalOpts, opts) {
 }
 async function geminiAddAccount(globalOpts, opts) {
   await requireWriteDb();
-  const slotsDir = join26(CC_CLAW_HOME, "gemini-slots");
-  if (!existsSync28(slotsDir)) mkdirSync13(slotsDir, { recursive: true });
+  const slotsDir = join30(CC_CLAW_HOME, "gemini-slots");
+  if (!existsSync32(slotsDir)) mkdirSync13(slotsDir, { recursive: true });
   const { addGeminiSlot: addGeminiSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const tempId = Date.now();
-  const slotDir = join26(slotsDir, `slot-${tempId}`);
+  const slotDir = join30(slotsDir, `slot-${tempId}`);
   mkdirSync13(slotDir, { recursive: true, mode: 448 });
-  mkdirSync13(join26(slotDir, ".gemini"), { recursive: true });
-  writeFileSync9(join26(slotDir, ".gemini", "settings.json"), JSON.stringify({
+  mkdirSync13(join30(slotDir, ".gemini"), { recursive: true });
+  writeFileSync10(join30(slotDir, ".gemini", "settings.json"), JSON.stringify({
     security: { auth: { selectedType: "oauth-personal" } }
   }, null, 2));
   console.log("");
@@ -23117,8 +24824,8 @@ async function geminiAddAccount(globalOpts, opts) {
     });
   } catch {
   }
-  const oauthPath = join26(slotDir, ".gemini", "oauth_creds.json");
-  if (!existsSync28(oauthPath)) {
+  const oauthPath = join30(slotDir, ".gemini", "oauth_creds.json");
+  if (!existsSync32(oauthPath)) {
     console.log(error2("\n  No OAuth credentials found. Sign-in may have failed."));
     console.log("  The slot directory is preserved at: " + slotDir);
     console.log("  Re-run: cc-claw gemini add-account\n");
@@ -23126,7 +24833,7 @@ async function geminiAddAccount(globalOpts, opts) {
   }
   let accountEmail = "unknown";
   try {
-    const accounts = JSON.parse(__require("fs").readFileSync(join26(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(__require("fs").readFileSync(join30(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
     accountEmail = accounts.active || accountEmail;
   } catch {
   }
@@ -23245,11 +24952,11 @@ __export(backend_cmd_factory_exports, {
   makeReorder: () => makeReorder,
   registerBackendSlotCommands: () => registerBackendSlotCommands
 });
-import { existsSync as existsSync29, mkdirSync as mkdirSync14, readFileSync as readFileSync18 } from "fs";
-import { join as join27 } from "path";
-import { createInterface as createInterface6 } from "readline";
+import { existsSync as existsSync33, mkdirSync as mkdirSync14, readFileSync as readFileSync22 } from "fs";
+import { join as join31 } from "path";
+import { createInterface as createInterface7 } from "readline";
 function requireDb2() {
-  if (!existsSync29(DB_PATH)) {
+  if (!existsSync33(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -23308,7 +25015,7 @@ Add one with: cc-claw ${backend2} add-account  or  cc-claw ${backend2} add-key`)
 function makeAddKey(backend2, displayName) {
   return async function addKey(_globalOpts, opts) {
     await requireWriteDb2();
-    const rl2 = createInterface6({ input: process.stdin, output: process.stdout });
+    const rl2 = createInterface7({ input: process.stdin, output: process.stdout });
     const ask2 = (q) => new Promise((r) => rl2.question(q, r));
     const key = await ask2(`Paste your ${displayName} API key: `);
     rl2.close();
@@ -23338,10 +25045,10 @@ function makeAddAccount(backend2, displayName) {
       process.exit(1);
     }
     await requireWriteDb2();
-    const slotsDir = join27(CC_CLAW_HOME, config2.slotsSubdir);
-    if (!existsSync29(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
+    const slotsDir = join31(CC_CLAW_HOME, config2.slotsSubdir);
+    if (!existsSync33(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
     const tempId = Date.now();
-    const slotDir = join27(slotsDir, `slot-${tempId}`);
+    const slotDir = join31(slotsDir, `slot-${tempId}`);
     mkdirSync14(slotDir, { recursive: true, mode: 448 });
     if (config2.preSetup) config2.preSetup(slotDir);
     console.log("");
@@ -23510,22 +25217,22 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { ANTHROPIC_API_KEY: void 0 },
         preSetup: (slotDir) => {
-          mkdirSync14(join27(slotDir, ".claude"), { recursive: true });
+          mkdirSync14(join31(slotDir, ".claude"), { recursive: true });
         },
         verifyCredentials: (slotDir) => {
-          const claudeJson = join27(slotDir, ".claude.json");
-          const claudeJsonNested = join27(slotDir, ".claude", ".claude.json");
-          if (existsSync29(claudeJson)) {
+          const claudeJson = join31(slotDir, ".claude.json");
+          const claudeJsonNested = join31(slotDir, ".claude", ".claude.json");
+          if (existsSync33(claudeJson)) {
             try {
-              const data = JSON.parse(readFileSync18(claudeJson, "utf-8"));
+              const data = JSON.parse(readFileSync22(claudeJson, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
             }
           }
-          if (existsSync29(claudeJsonNested)) {
+          if (existsSync33(claudeJsonNested)) {
             try {
-              const data = JSON.parse(readFileSync18(claudeJsonNested, "utf-8"));
+              const data = JSON.parse(readFileSync22(claudeJsonNested, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
@@ -23546,9 +25253,9 @@ var init_backend_cmd_factory = __esm({
           } catch {
           }
           try {
-            const claudeJson = join27(slotDir, ".claude.json");
-            if (existsSync29(claudeJson)) {
-              const data = JSON.parse(readFileSync18(claudeJson, "utf-8"));
+            const claudeJson = join31(slotDir, ".claude.json");
+            if (existsSync33(claudeJson)) {
+              const data = JSON.parse(readFileSync22(claudeJson, "utf-8"));
               if (data.oauthAccount?.emailAddress) return data.oauthAccount.emailAddress;
             }
           } catch {
@@ -23563,11 +25270,11 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { OPENAI_API_KEY: void 0 },
         verifyCredentials: (slotDir) => {
-          return existsSync29(join27(slotDir, "auth.json"));
+          return existsSync33(join31(slotDir, "auth.json"));
         },
         extractLabel: (slotDir) => {
           try {
-            const authData = JSON.parse(readFileSync18(join27(slotDir, "auth.json"), "utf-8"));
+            const authData = JSON.parse(readFileSync22(join31(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;
@@ -23587,12 +25294,12 @@ __export(backend_exports, {
   backendList: () => backendList,
   backendSet: () => backendSet
 });
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 async function backendList(globalOpts) {
   const { getAvailableAdapters: getAvailableAdapters3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   const chatId = resolveChatId(globalOpts);
   let activeBackend = null;
-  if (existsSync30(DB_PATH)) {
+  if (existsSync34(DB_PATH)) {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     try {
@@ -23623,7 +25330,7 @@ async function backendList(globalOpts) {
 }
 async function backendGet(globalOpts) {
   const chatId = resolveChatId(globalOpts);
-  if (!existsSync30(DB_PATH)) {
+  if (!existsSync34(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -23667,13 +25374,13 @@ __export(model_exports, {
   modelList: () => modelList,
   modelSet: () => modelSet
 });
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 async function modelList(globalOpts) {
   const chatId = resolveChatId(globalOpts);
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const { getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   let backendId = "claude";
-  if (existsSync31(DB_PATH)) {
+  if (existsSync35(DB_PATH)) {
     const readDb = openDatabaseReadOnly2();
     try {
       const row = readDb.prepare("SELECT backend FROM chat_backend WHERE chat_id = ?").get(chatId);
@@ -23706,7 +25413,7 @@ async function modelList(globalOpts) {
 }
 async function modelGet(globalOpts) {
   const chatId = resolveChatId(globalOpts);
-  if (!existsSync31(DB_PATH)) {
+  if (!existsSync35(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23750,9 +25457,9 @@ __export(memory_exports2, {
   memoryList: () => memoryList,
   memorySearch: () => memorySearch
 });
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 async function memoryList(globalOpts) {
-  if (!existsSync32(DB_PATH)) {
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -23776,7 +25483,7 @@ async function memoryList(globalOpts) {
   });
 }
 async function memorySearch(globalOpts, query) {
-  if (!existsSync32(DB_PATH)) {
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23798,7 +25505,7 @@ async function memorySearch(globalOpts, query) {
   });
 }
 async function memoryHistory(globalOpts, opts) {
-  if (!existsSync32(DB_PATH)) {
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23846,7 +25553,7 @@ __export(cron_exports2, {
   cronList: () => cronList,
   cronRuns: () => cronRuns
 });
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 function parseFallbacks(raw) {
   return raw.slice(0, 3).map((f) => {
     const [backend2, ...rest] = f.split(":");
@@ -23867,7 +25574,7 @@ function parseAndValidateTimeout(raw) {
   return val;
 }
 async function cronList(globalOpts) {
-  if (!existsSync33(DB_PATH)) {
+  if (!existsSync37(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23905,7 +25612,7 @@ async function cronList(globalOpts) {
   });
 }
 async function cronHealth(globalOpts) {
-  if (!existsSync33(DB_PATH)) {
+  if (!existsSync37(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24064,7 +25771,7 @@ async function cronEdit(globalOpts, id, opts) {
   }
 }
 async function cronRuns(globalOpts, jobId, opts) {
-  if (!existsSync33(DB_PATH)) {
+  if (!existsSync37(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24111,9 +25818,9 @@ __export(agents_exports, {
   runnersList: () => runnersList,
   tasksList: () => tasksList
 });
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 async function agentsList(globalOpts) {
-  if (!existsSync34(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24144,7 +25851,7 @@ async function agentsList(globalOpts) {
   });
 }
 async function tasksList(globalOpts) {
-  if (!existsSync34(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24272,18 +25979,18 @@ __export(db_exports, {
   dbPath: () => dbPath,
   dbStats: () => dbStats
 });
-import { existsSync as existsSync35, statSync as statSync9, copyFileSync as copyFileSync3, mkdirSync as mkdirSync15 } from "fs";
-import { dirname as dirname6 } from "path";
+import { existsSync as existsSync39, statSync as statSync10, copyFileSync as copyFileSync3, mkdirSync as mkdirSync15 } from "fs";
+import { dirname as dirname7 } from "path";
 async function dbStats(globalOpts) {
-  if (!existsSync35(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const mainSize = statSync9(DB_PATH).size;
+  const mainSize = statSync10(DB_PATH).size;
   const walPath = DB_PATH + "-wal";
-  const walSize = existsSync35(walPath) ? statSync9(walPath).size : 0;
+  const walSize = existsSync39(walPath) ? statSync10(walPath).size : 0;
   const tableNames = readDb.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts%' ORDER BY name"
   ).all();
@@ -24317,17 +26024,17 @@ async function dbPath(globalOpts) {
   output({ path: DB_PATH }, (d) => d.path);
 }
 async function dbBackup(globalOpts, destPath) {
-  if (!existsSync35(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
   const dest = destPath ?? `${DB_PATH}.backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
   try {
-    mkdirSync15(dirname6(dest), { recursive: true });
+    mkdirSync15(dirname7(dest), { recursive: true });
     copyFileSync3(DB_PATH, dest);
     const walPath = DB_PATH + "-wal";
-    if (existsSync35(walPath)) copyFileSync3(walPath, dest + "-wal");
-    output({ path: dest, sizeBytes: statSync9(dest).size }, (d) => {
+    if (existsSync39(walPath)) copyFileSync3(walPath, dest + "-wal");
+    output({ path: dest, sizeBytes: statSync10(dest).size }, (d) => {
       const b = d;
       return `
   ${success("Backup created:")} ${b.path} (${(b.sizeBytes / 1024).toFixed(0)}KB)
@@ -24355,9 +26062,9 @@ __export(usage_exports, {
   usageCost: () => usageCost,
   usageTokens: () => usageTokens
 });
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 function ensureDb() {
-  if (!existsSync36(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -24547,9 +26254,9 @@ __export(config_exports2, {
   configList: () => configList,
   configSet: () => configSet
 });
-import { existsSync as existsSync37, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync23 } from "fs";
 async function configList(globalOpts) {
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24583,7 +26290,7 @@ async function configGet(globalOpts, key) {
     outputError("INVALID_KEY", `Unknown config key "${key}". Valid keys: ${RUNTIME_KEYS.join(", ")}`);
     process.exit(1);
   }
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24629,11 +26336,11 @@ async function configSet(globalOpts, key, value) {
   }
 }
 async function configEnv(_globalOpts) {
-  if (!existsSync37(ENV_PATH)) {
+  if (!existsSync41(ENV_PATH)) {
     outputError("ENV_NOT_FOUND", `No .env file at ${ENV_PATH}. Run cc-claw setup.`);
     process.exit(1);
   }
-  const content = readFileSync19(ENV_PATH, "utf-8");
+  const content = readFileSync23(ENV_PATH, "utf-8");
   const entries = {};
   const secretPatterns = /TOKEN|KEY|SECRET|PASSWORD|CREDENTIALS/i;
   for (const line of content.split("\n")) {
@@ -24683,9 +26390,9 @@ __export(session_exports, {
   sessionGet: () => sessionGet,
   sessionNew: () => sessionNew
 });
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 async function sessionGet(globalOpts) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24746,9 +26453,9 @@ __export(permissions_exports, {
   verboseGet: () => verboseGet,
   verboseSet: () => verboseSet
 });
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 function ensureDb2() {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24895,9 +26602,9 @@ __export(cwd_exports, {
   cwdGet: () => cwdGet,
   cwdSet: () => cwdSet
 });
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 async function cwdGet(globalOpts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24959,9 +26666,9 @@ __export(voice_exports, {
   voiceGet: () => voiceGet,
   voiceSet: () => voiceSet
 });
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 async function voiceGet(globalOpts) {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -25010,9 +26717,9 @@ __export(heartbeat_exports, {
   heartbeatGet: () => heartbeatGet,
   heartbeatSet: () => heartbeatSet
 });
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 async function heartbeatGet(globalOpts) {
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync46(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -25121,9 +26828,9 @@ __export(summarizer_exports, {
   summarizerGet: () => summarizerGet,
   summarizerSet: () => summarizerSet
 });
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 async function summarizerGet(globalOpts) {
-  if (!existsSync43(DB_PATH)) {
+  if (!existsSync47(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -25167,9 +26874,9 @@ __export(thinking_exports, {
   thinkingGet: () => thinkingGet,
   thinkingSet: () => thinkingSet
 });
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 async function thinkingGet(globalOpts) {
-  if (!existsSync44(DB_PATH)) {
+  if (!existsSync48(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -25213,9 +26920,9 @@ __export(chats_exports, {
   chatsList: () => chatsList,
   chatsRemoveAlias: () => chatsRemoveAlias
 });
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 async function chatsList(_globalOpts) {
-  if (!existsSync45(DB_PATH)) {
+  if (!existsSync49(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -25343,9 +27050,9 @@ var mcps_exports2 = {};
 __export(mcps_exports2, {
   mcpsList: () => mcpsList
 });
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 async function mcpsList(_globalOpts) {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync50(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -25382,11 +27089,11 @@ __export(chat_exports2, {
   chatSend: () => chatSend
 });
 import { request as httpRequest2 } from "http";
-import { readFileSync as readFileSync20, existsSync as existsSync47 } from "fs";
+import { readFileSync as readFileSync24, existsSync as existsSync51 } from "fs";
 function getToken2() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync47(TOKEN_PATH2)) return readFileSync20(TOKEN_PATH2, "utf-8").trim();
+    if (existsSync51(TOKEN_PATH2)) return readFileSync24(TOKEN_PATH2, "utf-8").trim();
   } catch {
   }
   return null;
@@ -25523,7 +27230,7 @@ var tui_exports = {};
 __export(tui_exports, {
   tuiCommand: () => tuiCommand
 });
-import { createInterface as createInterface7 } from "readline";
+import { createInterface as createInterface8 } from "readline";
 import pc2 from "picocolors";
 async function tuiCommand(globalOpts, cmdOpts) {
   const { isDaemonRunning: isDaemonRunning2, apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
@@ -25533,7 +27240,7 @@ async function tuiCommand(globalOpts, cmdOpts) {
   }
   const chatId = resolveChatId(globalOpts);
   const { chatSend: chatSend2 } = await Promise.resolve().then(() => (init_chat2(), chat_exports2));
-  const rl2 = createInterface7({
+  const rl2 = createInterface8({
     input: process.stdin,
     output: process.stdout,
     prompt: pc2.cyan("you > "),
@@ -25665,9 +27372,9 @@ var completion_exports = {};
 __export(completion_exports, {
   completionCommand: () => completionCommand
 });
-import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync16 } from "fs";
-import { join as join28 } from "path";
-import { homedir as homedir9 } from "os";
+import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync16 } from "fs";
+import { join as join32 } from "path";
+import { homedir as homedir11 } from "os";
 async function completionCommand(opts) {
   const shell = opts.shell ?? detectShell();
   let script;
@@ -25682,11 +27389,11 @@ async function completionCommand(opts) {
     process.exit(1);
   }
   if (opts.install) {
-    const dir = join28(homedir9(), ".config", "cc-claw", "completions");
+    const dir = join32(homedir11(), ".config", "cc-claw", "completions");
     mkdirSync16(dir, { recursive: true });
     const filename = shell === "zsh" ? "_cc-claw" : shell === "fish" ? "cc-claw.fish" : "cc-claw.bash";
-    const filepath = join28(dir, filename);
-    writeFileSync10(filepath, script, "utf-8");
+    const filepath = join32(dir, filename);
+    writeFileSync11(filepath, script, "utf-8");
     console.log(`\u2713 Completion script written to ${filepath}
 `);
     if (shell === "zsh") {
@@ -25856,9 +27563,9 @@ __export(evolve_exports2, {
   evolveStatus: () => evolveStatus,
   evolveUndo: () => evolveUndo
 });
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync52 } from "fs";
 function ensureDb3() {
-  if (!existsSync48(DB_PATH)) {
+  if (!existsSync52(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -26272,12 +27979,70 @@ var init_evolve3 = __esm({
   }
 });
 
+// src/cli/commands/optimize.ts
+var optimize_exports = {};
+__export(optimize_exports, {
+  optimizeSkills: () => optimizeSkills,
+  optimizeStatus: () => optimizeStatus
+});
+async function optimizeStatus() {
+  const { listCcClawSkills: listCcClawSkills2 } = await Promise.resolve().then(() => (init_analyze2(), analyze_exports2));
+  const skills2 = listCcClawSkills2();
+  output({
+    status: "ok",
+    description: "Run identity and skill audits via Telegram with /optimize",
+    availableSkills: skills2.length,
+    skillNames: skills2.map((s) => s.name)
+  }, () => {
+    const lines = [
+      box("\u{1F527} CC-Claw Optimizer"),
+      "",
+      "  Use /optimize in Telegram for the interactive audit experience.",
+      "",
+      divider("CLI subcommands"),
+      kvLine("skills", "List available CC-Claw skills"),
+      "",
+      muted(`  \u{1F4CA} ${skills2.length} skill(s) available for audit`),
+      ""
+    ];
+    return lines.join("\n");
+  });
+}
+async function optimizeSkills() {
+  const { listCcClawSkills: listCcClawSkills2 } = await Promise.resolve().then(() => (init_analyze2(), analyze_exports2));
+  const skills2 = listCcClawSkills2();
+  output({
+    status: "ok",
+    skills: skills2.map((s) => ({ name: s.name, path: s.path, description: s.description })),
+    count: skills2.length
+  }, () => {
+    if (skills2.length === 0) {
+      return "  No CC-Claw skills found in ~/.cc-claw/workspace/skills/";
+    }
+    const lines = [
+      box("\u{1F9E9} CC-Claw Skills"),
+      "",
+      ...skills2.map((s) => kvLine(s.name, s.description)),
+      "",
+      muted(`  ${skills2.length} skill(s) \u2014 use /optimize in Telegram to audit`),
+      ""
+    ];
+    return lines.join("\n");
+  });
+}
+var init_optimize2 = __esm({
+  "src/cli/commands/optimize.ts"() {
+    "use strict";
+    init_format2();
+  }
+});
+
 // src/setup.ts
 var setup_exports = {};
-import { existsSync as existsSync49, writeFileSync as writeFileSync11, readFileSync as readFileSync21, copyFileSync as copyFileSync4, mkdirSync as mkdirSync17, statSync as statSync10 } from "fs";
+import { existsSync as existsSync53, writeFileSync as writeFileSync12, readFileSync as readFileSync25, copyFileSync as copyFileSync4, mkdirSync as mkdirSync17, statSync as statSync11 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
-import { createInterface as createInterface8 } from "readline";
-import { join as join29 } from "path";
+import { createInterface as createInterface9 } from "readline";
+import { join as join33 } from "path";
 function divider2() {
   console.log(dim("\u2500".repeat(55)));
 }
@@ -26352,22 +28117,22 @@ async function setup() {
   }
   console.log("");
   for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-    if (!existsSync49(dir)) mkdirSync17(dir, { recursive: true });
+    if (!existsSync53(dir)) mkdirSync17(dir, { recursive: true });
   }
   const env = {};
-  const envSource = existsSync49(ENV_PATH) ? ENV_PATH : existsSync49(".env") ? ".env" : null;
+  const envSource = existsSync53(ENV_PATH) ? ENV_PATH : existsSync53(".env") ? ".env" : null;
   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 = readFileSync21(envSource, "utf-8");
+    const existing = readFileSync25(envSource, "utf-8");
     for (const line of existing.split("\n")) {
       const match = line.match(/^([^#=]+)=(.*)$/);
       if (match) env[match[1].trim()] = match[2].trim();
     }
   }
-  const cwdDb = join29(process.cwd(), "cc-claw.db");
-  if (existsSync49(cwdDb) && !existsSync49(DB_PATH)) {
-    const { size } = statSync10(cwdDb);
+  const cwdDb = join33(process.cwd(), "cc-claw.db");
+  if (existsSync53(cwdDb) && !existsSync53(DB_PATH)) {
+    const { size } = statSync11(cwdDb);
     console.log(yellow(`  Found existing database at ${cwdDb} (${(size / 1024).toFixed(0)}KB)`));
     const migrate = await confirm("Copy database to ~/.cc-claw/? (preserves memories & history)", true);
     if (migrate) {
@@ -26583,7 +28348,7 @@ async function setup() {
     envLines.push("", "# Video Analysis", `GEMINI_API_KEY=${env.GEMINI_API_KEY}`);
   }
   const envContent = envLines.join("\n") + "\n";
-  writeFileSync11(ENV_PATH, envContent, { mode: 384 });
+  writeFileSync12(ENV_PATH, envContent, { mode: 384 });
   console.log(green(`  Config saved to ${ENV_PATH} (permissions: owner-only)`));
   header(6, TOTAL_STEPS, "Run on Startup (Daemon)");
   console.log("  CC-Claw can run automatically in the background, starting");
@@ -26639,7 +28404,7 @@ var init_setup = __esm({
   "src/setup.ts"() {
     "use strict";
     init_paths();
-    rl = createInterface8({ input: process.stdin, output: process.stdout });
+    rl = createInterface9({ input: process.stdin, output: process.stdout });
     ask = (q) => new Promise((resolve) => rl.question(q, resolve));
     bold = (s) => `\x1B[1m${s}\x1B[0m`;
     green = (s) => `\x1B[32m${s}\x1B[0m`;
@@ -27164,6 +28929,15 @@ evolve.command("settings").description("View or update reflection settings").opt
   const { evolveSettings: evolveSettings2 } = await Promise.resolve().then(() => (init_evolve3(), evolve_exports2));
   await evolveSettings2(program.opts(), opts);
 });
+var optimize = program.command("optimize").description("Audit identity files and skills");
+optimize.action(async () => {
+  const { optimizeStatus: optimizeStatus2 } = await Promise.resolve().then(() => (init_optimize2(), optimize_exports));
+  await optimizeStatus2();
+});
+optimize.command("skills").description("List available CC-Claw skills").action(async () => {
+  const { optimizeSkills: optimizeSkills2 } = await Promise.resolve().then(() => (init_optimize2(), optimize_exports));
+  await optimizeSkills2();
+});
 program.command("start", { hidden: true }).description("Run the bot in the foreground (use 'service start' for background daemon)").action(async () => {
   await Promise.resolve().then(() => (init_index(), index_exports));
 });