cc-claw 0.18.2 → 0.18.4

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.18.2" : (() => {
+    VERSION = true ? "0.18.4" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -9717,6 +9717,14 @@ function parseAnalysisOutput(raw) {
     if (!VALID_CATEGORIES.includes(category)) continue;
     const confidence = confidenceMatch ? parseFloat(confidenceMatch[1].trim()) : 0.5;
     if (isNaN(confidence)) continue;
+    let proposedDiff = diffMatch?.[1]?.trim() ?? "";
+    if (proposedDiff.startsWith("```")) {
+      proposedDiff = proposedDiff.replace(/^```[a-zA-Z0-9-]*\r?\n/, "");
+      if (proposedDiff.endsWith("```")) {
+        proposedDiff = proposedDiff.replace(/\r?\n```$/, "");
+      }
+      proposedDiff = proposedDiff.trim();
+    }
     results.push({
       insight: insightMatch[1].trim(),
       category,
@@ -9724,7 +9732,7 @@ function parseAnalysisOutput(raw) {
       targetFile: targetMatch?.[1]?.trim() ?? "",
       confidence: Math.max(0, Math.min(1, confidence)),
       proposedAction: actionMatch?.[1]?.trim() ?? "",
-      proposedDiff: diffMatch?.[1]?.trim() ?? "",
+      proposedDiff,
       conflictsWith: conflictsMatch?.[1]?.trim() ?? "none"
     });
   }
@@ -10128,6 +10136,181 @@ var init_analyze = __esm({
   }
 });
 
+// src/reflection/ai-apply.ts
+var ai_apply_exports = {};
+__export(ai_apply_exports, {
+  applyWithAI: () => applyWithAI
+});
+import { spawn as spawn5 } from "child_process";
+import { createInterface as createInterface4 } from "readline";
+function buildApplyPrompt(originalContent, instruction, proposedDiff, targetFile) {
+  return `You are a precise markdown document editor. Your ONLY job is to apply the requested change to the document while preserving its structural integrity.
+
+=== CURRENT FILE: ${targetFile} ===
+${originalContent}
+=== END FILE ===
+
+=== CHANGE TO APPLY ===
+Instruction: ${instruction}
+
+Diff guidance:
+${proposedDiff}
+=== END CHANGE ===
+
+Rules:
+1. Place new content under the semantically correct section heading (## heading)
+2. Maintain consistent formatting (bullet style, indentation) with the target section
+3. Do NOT add, remove, or modify any content other than what the change requires
+4. Do NOT wrap your output in markdown code fences
+5. Do NOT add explanations, commentary, or notes
+6. Preserve all existing headings and their order
+7. Return ONLY the complete updated file content
+
+Output the complete updated file now:`;
+}
+async function spawnApplyLLM(adapter, model2, prompt) {
+  const config2 = adapter.buildSpawnConfig({
+    prompt,
+    model: model2,
+    permMode: "yolo",
+    allowedTools: []
+  });
+  const env = adapter.getEnv();
+  let resultText = "";
+  let accumulatedText = "";
+  await new Promise((resolve) => {
+    const proc = spawn5(config2.executable, config2.args, {
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...config2.cwd ? { cwd: config2.cwd } : {}
+    });
+    proc.stderr?.resume();
+    const rl2 = createInterface4({ input: proc.stdout });
+    const timeout = setTimeout(() => {
+      warn("[ai-apply] LLM spawn timeout");
+      rl2.close();
+      proc.kill("SIGTERM");
+      setTimeout(() => proc.kill("SIGKILL"), 2e3);
+    }, AI_APPLY_TIMEOUT_MS);
+    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 resolveApplyAdapter(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 extractHeadings(content) {
+  return content.split("\n").filter((line) => /^#{1,6}\s/.test(line)).map((line) => line.trim());
+}
+function validateOutput(original, output2) {
+  if (!output2.trim()) {
+    return { valid: false, reason: "LLM returned empty output" };
+  }
+  const originalLines = original.split("\n").length;
+  const outputLines = output2.split("\n").length;
+  if (originalLines > 5 && outputLines < originalLines * MIN_LINE_RETENTION) {
+    return {
+      valid: false,
+      reason: `Output has ${outputLines} lines vs original ${originalLines} (${Math.round(outputLines / originalLines * 100)}% retained, min ${MIN_LINE_RETENTION * 100}%)`
+    };
+  }
+  const originalHeadings = extractHeadings(original);
+  const outputHeadings = extractHeadings(output2);
+  for (const heading4 of originalHeadings) {
+    if (!outputHeadings.includes(heading4)) {
+      return {
+        valid: false,
+        reason: `Missing heading: "${heading4}"`
+      };
+    }
+  }
+  if (output2.trim() === original.trim()) {
+    return { valid: false, reason: "Output is identical to original (no changes applied)" };
+  }
+  return { valid: true };
+}
+function stripMarkdownFences(text) {
+  const fencePattern = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/;
+  const match = text.match(fencePattern);
+  if (match) return match[1];
+  return text;
+}
+async function applyWithAI(chatId, originalContent, instruction, proposedDiff, targetFile) {
+  const resolved = resolveApplyAdapter(chatId);
+  if (!resolved) {
+    return { success: false, newContent: "", error: "No backend adapter available" };
+  }
+  const { adapter, model: model2 } = resolved;
+  log(`[ai-apply] Using ${adapter.id}:${model2} for structural apply on ${targetFile}`);
+  try {
+    const prompt = buildApplyPrompt(originalContent, instruction, proposedDiff, targetFile);
+    const rawOutput = await spawnApplyLLM(adapter, model2, prompt);
+    if (!rawOutput.trim()) {
+      return { success: false, newContent: "", error: "LLM returned empty response" };
+    }
+    const cleanOutput = stripMarkdownFences(rawOutput);
+    const validation = validateOutput(originalContent, cleanOutput);
+    if (!validation.valid) {
+      return { success: false, newContent: "", error: `Validation failed: ${validation.reason}` };
+    }
+    log(`[ai-apply] Successfully applied change to ${targetFile}`);
+    return { success: true, newContent: cleanOutput };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warn(`[ai-apply] LLM apply failed: ${msg}`);
+    return { success: false, newContent: "", error: msg };
+  }
+}
+var AI_APPLY_TIMEOUT_MS, MIN_LINE_RETENTION;
+var init_ai_apply = __esm({
+  "src/reflection/ai-apply.ts"() {
+    "use strict";
+    init_log();
+    init_text_utils();
+    init_backends();
+    AI_APPLY_TIMEOUT_MS = 6e4;
+    MIN_LINE_RETENTION = 0.7;
+  }
+});
+
 // src/reflection/apply.ts
 var apply_exports = {};
 __export(apply_exports, {
@@ -10258,7 +10441,31 @@ async function applyInsight(insightId) {
       writeFileSync5(backupPath, original, "utf-8");
       pruneBackups(absolutePath);
     }
-    const newContent = applyDiff(original, insight.proposedDiff, insight.proposedAction);
+    let newContent;
+    if (insight.proposedAction !== "create") {
+      try {
+        const { applyWithAI: applyWithAI2 } = await Promise.resolve().then(() => (init_ai_apply(), ai_apply_exports));
+        const aiResult = await applyWithAI2(
+          chatId,
+          original,
+          insight.insight,
+          insight.proposedDiff,
+          insight.targetFile
+        );
+        if (aiResult.success) {
+          newContent = aiResult.newContent;
+          log(`[reflection/apply] AI apply succeeded for insight #${insightId}`);
+        } else {
+          warn(`[reflection/apply] AI apply failed (${aiResult.error}), falling back to static diff`);
+          newContent = applyDiff(original, insight.proposedDiff, insight.proposedAction);
+        }
+      } catch (aiErr) {
+        warn(`[reflection/apply] AI apply threw (${aiErr}), falling back to static diff`);
+        newContent = applyDiff(original, insight.proposedDiff, insight.proposedAction);
+      }
+    } else {
+      newContent = applyDiff(original, insight.proposedDiff, insight.proposedAction);
+    }
     writeFileSync5(absolutePath, newContent, "utf-8");
     const rollbackData = JSON.stringify({ original, backupPath, appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
     updateInsightRollback(db3, insightId, rollbackData);
@@ -10947,6 +11154,7 @@ var init_detect = __esm({
 // src/agent.ts
 var agent_exports = {};
 __export(agent_exports, {
+  CONTENT_SILENCE_TIMEOUT_ERROR: () => CONTENT_SILENCE_TIMEOUT_ERROR,
   FIRST_RESPONSE_TIMEOUT_ERROR: () => FIRST_RESPONSE_TIMEOUT_ERROR,
   FREE_SLOTS_EXHAUSTED: () => FREE_SLOTS_EXHAUSTED,
   askAgent: () => askAgent,
@@ -10956,8 +11164,8 @@ __export(agent_exports, {
   stopAgent: () => stopAgent,
   stopAllActiveAgents: () => stopAllActiveAgents
 });
-import { spawn as spawn5 } from "child_process";
-import { createInterface as createInterface4 } from "readline";
+import { spawn as spawn6 } from "child_process";
+import { createInterface as createInterface5 } from "readline";
 function isSyntheticChatId(chatId) {
   return chatId.startsWith("sq:") || chatId.startsWith("cron:");
 }
@@ -11021,7 +11229,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     const env = opts?.envOverride ? thinkingConfig?.envOverrides ? { ...opts.envOverride, ...thinkingConfig.envOverrides } : opts.envOverride : adapter.getEnv(thinkingConfig?.envOverrides);
     const finalArgs = thinkingConfig?.extraArgs ? [...config2.args, ...thinkingConfig.extraArgs] : config2.args;
     log(`[agent:spawn] backend=${adapter.id} exe=${config2.executable} model=${model2} timeout=${effectiveTimeout / 1e3}s cwd=${config2.cwd ?? "(inherited)"}`);
-    const proc = spawn5(config2.executable, finalArgs, {
+    const proc = spawn6(config2.executable, finalArgs, {
       env,
       stdio: ["ignore", "pipe", "pipe"],
       detached: true,
@@ -11054,7 +11262,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     const pendingTools = /* @__PURE__ */ new Map();
     const stderrChunks = [];
     proc.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-    const rl2 = createInterface4({ input: proc.stdout });
+    const rl2 = createInterface5({ input: proc.stdout });
     let firstLine = true;
     const frTimeoutMs = adapter.id === "gemini" ? opts?.firstResponseTimeoutMs ?? FIRST_RESPONSE_TIMEOUT_MS : 0;
     let firstResponseTimer;
@@ -11070,6 +11278,20 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
         }
       }, frTimeoutMs);
     }
+    let contentSilenceTimer;
+    const silenceTimeoutMs = CONTENT_SILENCE_TIMEOUT_MS;
+    function resetContentSilenceTimer() {
+      if (silenceTimeoutMs <= 0) return;
+      if (contentSilenceTimer) clearTimeout(contentSilenceTimer);
+      contentSilenceTimer = setTimeout(() => {
+        if (cancelState.cancelled || timedOut) return;
+        warn(`[agent] Content silence timeout after ${silenceTimeoutMs / 1e3}s for ${adapter.id} \u2014 no content events, killing`);
+        timedOut = true;
+        cancelState.__contentSilenceTimeout = true;
+        killProcessGroup(proc, "SIGTERM");
+        sigkillTimer = setTimeout(() => killProcessGroup(proc, "SIGKILL"), 3e3);
+      }, silenceTimeoutMs);
+    }
     rl2.on("line", (line) => {
       if (!line.trim()) return;
       if (firstLine) {
@@ -11092,6 +11314,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
           case "init":
             log(`[agent] Session init at ${elapsed()}`);
             if (ev.sessionId) sessionId = ev.sessionId;
+            resetContentSilenceTimer();
             break;
           case "text":
             if (!gotModelContent) {
@@ -11101,6 +11324,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
                 firstResponseTimer = void 0;
               }
             }
+            resetContentSilenceTimer();
             if (ev.text) {
               accumulatedText = appendTextChunk(accumulatedText, ev.text);
               if (opts?.onStream) opts.onStream(ev.text);
@@ -11114,6 +11338,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
                 firstResponseTimer = void 0;
               }
             }
+            resetContentSilenceTimer();
             if (ev.text) {
               accumulatedThinking = appendTextChunk(accumulatedThinking, ev.text);
               if (opts?.onThinking) opts.onThinking(ev.text);
@@ -11127,6 +11352,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
                 firstResponseTimer = void 0;
               }
             }
+            resetContentSilenceTimer();
             sawToolEvents = true;
             if (opts?.onToolAction && ev.toolName) {
               const toolInput = ev.toolInput ?? {};
@@ -11153,6 +11379,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
             }
             break;
           case "tool_end":
+            resetContentSilenceTimer();
             if (opts?.onToolAction) {
               const pending = ev.toolId ? pendingTools.get(ev.toolId) : void 0;
               if (pending) {
@@ -11206,6 +11433,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     proc.on("error", (err) => {
       clearTimeout(spawnTimeout);
       if (firstResponseTimer) clearTimeout(firstResponseTimer);
+      if (contentSilenceTimer) clearTimeout(contentSilenceTimer);
       if (sigkillTimer) clearTimeout(sigkillTimer);
       rl2.close();
       cancelState.process = void 0;
@@ -11217,6 +11445,10 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
         clearTimeout(firstResponseTimer);
         firstResponseTimer = void 0;
       }
+      if (contentSilenceTimer) {
+        clearTimeout(contentSilenceTimer);
+        contentSilenceTimer = void 0;
+      }
       if (sigkillTimer) {
         clearTimeout(sigkillTimer);
         sigkillTimer = void 0;
@@ -11237,6 +11469,11 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
           reject(new Error(`${FIRST_RESPONSE_TIMEOUT_ERROR}: No response from ${adapter.id} within ${frTimeoutMs / 1e3}s${stderr ? ` \u2014 ${stderr.slice(-300)}` : ""}`));
           return;
         }
+        if (cancelState.__contentSilenceTimeout) {
+          delete cancelState.__contentSilenceTimeout;
+          reject(new Error(`${CONTENT_SILENCE_TIMEOUT_ERROR}: ${adapter.id} produced no content events for ${silenceTimeoutMs / 1e3}s after init`));
+          return;
+        }
         let msg = `Spawn timeout after ${effectiveTimeout / 1e3}s`;
         if (pendingTools.size > 0) {
           const tools2 = Array.from(pendingTools.values()).map((t) => typeof t === "string" ? t : t.name).join(", ");
@@ -11589,6 +11826,26 @@ async function askAgentImpl(chatId, userMessage, opts) {
         })();
         result = await spawnQuery(adapter, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
       }
+    } else if (errMsg.startsWith(CONTENT_SILENCE_TIMEOUT_ERROR) && existingSessionId) {
+      warn(`[agent] Content silence on ${adapter.id} \u2014 clearing session ${existingSessionId} and retrying fresh`);
+      clearSession(chatId);
+      if (useGeminiRotation) {
+        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+        const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
+        result = await spawnGeminiWithRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, geminiRotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
+      } else if (useBackendRotation) {
+        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+        result = await spawnWithSlotRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, backendRotationMode, allowPaid, spawnOpts, rotationCb);
+      } else {
+        const retryOpts = (() => {
+          if (adapter.id !== "gemini") return spawnOpts;
+          const geminiAdapter = adapter;
+          const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
+          if (slot) return { ...spawnOpts, envOverride: env };
+          return spawnOpts;
+        })();
+        result = await spawnQuery(adapter, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
+      }
     } else {
       if (!isSyntheticChatId(chatId)) {
         try {
@@ -11693,7 +11950,7 @@ function injectMcpConfig(adapterId, args, mcpConfigPath) {
   if (!flag) return args;
   return [...args, ...flag, mcpConfigPath];
 }
-var activeChats, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
+var activeChats, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
 var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
@@ -11718,6 +11975,8 @@ var init_agent = __esm({
     chatLocks = /* @__PURE__ */ new Map();
     SPAWN_TIMEOUT_MS = 10 * 60 * 1e3;
     FIRST_RESPONSE_TIMEOUT_MS = parseInt(process.env.GEMINI_FIRST_RESPONSE_TIMEOUT_MS ?? "30000", 10);
+    CONTENT_SILENCE_TIMEOUT_MS = parseInt(process.env.CONTENT_SILENCE_TIMEOUT_MS ?? "90000", 10);
+    CONTENT_SILENCE_TIMEOUT_ERROR = "CONTENT_SILENCE_TIMEOUT";
     FIRST_RESPONSE_TIMEOUT_ERROR = "FIRST_RESPONSE_TIMEOUT";
     FREE_SLOTS_EXHAUSTED = "FREE_SLOTS_EXHAUSTED";
     GEMINI_FALLBACK_CHAIN = {
@@ -17024,8 +17283,8 @@ __export(analyze_exports2, {
   runIdentityAudit: () => runIdentityAudit,
   runSkillAudit: () => runSkillAudit
 });
-import { spawn as spawn6 } from "child_process";
-import { createInterface as createInterface5 } from "readline";
+import { spawn as spawn7 } from "child_process";
+import { createInterface as createInterface6 } 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";
@@ -17047,6 +17306,14 @@ function parseOptimizeOutput(raw, validAreas) {
     if (!validAreas.includes(area)) continue;
     const severity = severityMatch?.[1]?.trim().toLowerCase() ?? "info";
     if (!VALID_SEVERITIES.includes(severity)) continue;
+    let proposedDiff = diffMatch?.[1]?.trim() ?? "";
+    if (proposedDiff.startsWith("```")) {
+      proposedDiff = proposedDiff.replace(/^```[a-zA-Z0-9-]*\r?\n/, "");
+      if (proposedDiff.endsWith("```")) {
+        proposedDiff = proposedDiff.replace(/\r?\n```$/, "");
+      }
+      proposedDiff = proposedDiff.trim();
+    }
     results.push({
       title: findingMatch[1].trim().slice(0, 80),
       area,
@@ -17054,7 +17321,7 @@ function parseOptimizeOutput(raw, validAreas) {
       detail: detailMatch?.[1]?.trim() ?? "",
       location: locationMatch?.[1]?.trim() ?? "",
       suggestion: suggestionMatch?.[1]?.trim() ?? "",
-      proposedDiff: diffMatch?.[1]?.trim() ?? ""
+      proposedDiff
     });
   }
   return results;
@@ -17070,13 +17337,13 @@ async function spawnAnalysis2(adapter, model2, prompt, timeoutMs = ANALYSIS_TIME
   let resultText = "";
   let accumulatedText = "";
   await new Promise((resolve) => {
-    const proc = spawn6(config2.executable, config2.args, {
+    const proc = spawn7(config2.executable, config2.args, {
       env,
       stdio: ["ignore", "pipe", "pipe"],
       ...config2.cwd ? { cwd: config2.cwd } : {}
     });
     proc.stderr?.resume();
-    const rl2 = createInterface5({ input: proc.stdout });
+    const rl2 = createInterface6({ input: proc.stdout });
     const timeout = setTimeout(() => {
       warn(`[optimizer] Analysis timeout (${adapter.id}:${model2})`);
       rl2.close();
@@ -17558,8 +17825,8 @@ var init_ui2 = __esm({
 });
 
 // src/router/optimize.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, existsSync as existsSync22 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, existsSync as existsSync22, readdirSync as readdirSync12, unlinkSync as unlinkSync6 } from "fs";
+import { join as join23, dirname as dirname4 } 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));
@@ -17664,13 +17931,38 @@ async function runIdentityAuditFlow(chatId, channel) {
   } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
   const modelInfo = getModelDisplayInfo2(chatId);
   if (!modelInfo) return;
-  await channel.sendText(
+  const progressMsgId = typeof channel.sendTextReturningId === "function" ? await channel.sendTextReturningId(
     chatId,
     buildProgressMessage2("identity files", modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel),
-    { parseMode: "plain" }
-  );
+    "plain"
+  ) : void 0;
+  if (!progressMsgId) {
+    await channel.sendText(
+      chatId,
+      buildProgressMessage2("identity files", modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel),
+      { parseMode: "plain" }
+    );
+  }
+  const startTime = Date.now();
+  const progressInterval = setInterval(async () => {
+    const elapsed = Math.round((Date.now() - startTime) / 1e3);
+    try {
+      if (channel.sendTyping) await channel.sendTyping(chatId);
+      if (progressMsgId && channel.editText) {
+        await channel.editText(
+          chatId,
+          progressMsgId,
+          buildProgressMessage2("identity files", modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel) + `
+\u23F3 Analyzing... (${elapsed}s)`,
+          "plain"
+        );
+      }
+    } catch {
+    }
+  }, 5e3);
   try {
     const result = await runIdentityAudit2(chatId);
+    clearInterval(progressInterval);
     activeSessions.set(chatId, {
       chatId,
       result,
@@ -17685,6 +17977,7 @@ async function runIdentityAuditFlow(chatId, channel) {
       await channel.sendText(chatId, summary, { parseMode: "plain" });
     }
   } catch (e) {
+    clearInterval(progressInterval);
     await channel.sendText(chatId, `Identity audit failed: ${e}`, { parseMode: "plain" });
   }
 }
@@ -17715,13 +18008,38 @@ async function runSkillAuditFlow(chatId, channel, skillName) {
   const modelInfo = getModelDisplayInfo2(chatId);
   if (!modelInfo) return;
   const skillPath = join23(homedir8(), ".cc-claw", "workspace", "skills", skillName, "SKILL.md");
-  await channel.sendText(
+  const progressMsgId = typeof channel.sendTextReturningId === "function" ? await channel.sendTextReturningId(
     chatId,
     buildProgressMessage2(`skill: ${skillName}`, modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel),
-    { parseMode: "plain" }
-  );
+    "plain"
+  ) : void 0;
+  if (!progressMsgId) {
+    await channel.sendText(
+      chatId,
+      buildProgressMessage2(`skill: ${skillName}`, modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel),
+      { parseMode: "plain" }
+    );
+  }
+  const startTime = Date.now();
+  const progressInterval = setInterval(async () => {
+    const elapsed = Math.round((Date.now() - startTime) / 1e3);
+    try {
+      if (channel.sendTyping) await channel.sendTyping(chatId);
+      if (progressMsgId && channel.editText) {
+        await channel.editText(
+          chatId,
+          progressMsgId,
+          buildProgressMessage2(`skill: ${skillName}`, modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel) + `
+\u23F3 Analyzing... (${elapsed}s)`,
+          "plain"
+        );
+      }
+    } catch {
+    }
+  }, 5e3);
   try {
     const result = await runSkillAudit2(chatId, skillPath);
+    clearInterval(progressInterval);
     activeSessions.set(chatId, {
       chatId,
       result,
@@ -17736,6 +18054,7 @@ async function runSkillAuditFlow(chatId, channel, skillName) {
       await channel.sendText(chatId, summary, { parseMode: "plain" });
     }
   } catch (e) {
+    clearInterval(progressInterval);
     await channel.sendText(chatId, `Skill audit failed: ${e}`, { parseMode: "plain" });
   }
 }
@@ -17787,8 +18106,28 @@ async function applyFinding(chatId, channel, index) {
     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");
+    let newContent;
+    try {
+      const { applyWithAI: applyWithAI2 } = await Promise.resolve().then(() => (init_ai_apply(), ai_apply_exports));
+      const aiResult = await applyWithAI2(
+        chatId,
+        original,
+        finding.suggestion || finding.title,
+        finding.proposedDiff,
+        finding.location.split(":")[0] || "unknown"
+      );
+      if (aiResult.success) {
+        newContent = aiResult.newContent;
+      } else {
+        warn(`[optimizer] AI apply failed (${aiResult.error}), falling back to static diff`);
+        const { applyDiff: applyDiff2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
+        newContent = applyDiff2(original, finding.proposedDiff, "replace");
+      }
+    } catch (aiErr) {
+      warn(`[optimizer] AI apply threw (${aiErr}), falling back to static diff`);
+      const { applyDiff: applyDiff2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
+      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);
@@ -17850,16 +18189,14 @@ function resolveTargetFile(location, auditTarget) {
   return null;
 }
 function pruneBackups2(absolutePath) {
-  const { readdirSync: readDir, unlinkSync: unlink4 } = __require("fs");
-  const { dirname: dirName } = __require("path");
-  const dir = dirName(absolutePath);
+  const dir = dirname4(absolutePath);
   const baseName = absolutePath.split("/").pop() ?? "";
   try {
-    const backups = readDir(dir).filter((f) => f.startsWith(baseName + ".bak.")).sort().map((f) => join23(dir, f));
+    const backups = readdirSync12(dir).filter((f) => f.startsWith(baseName + ".bak.")).sort().map((f) => join23(dir, f));
     while (backups.length > 3) {
       const oldest = backups.shift();
       try {
-        unlink4(oldest);
+        unlinkSync6(oldest);
       } catch {
       }
     }
@@ -17870,6 +18207,7 @@ var activeSessions;
 var init_optimize = __esm({
   "src/router/optimize.ts"() {
     "use strict";
+    init_log();
     activeSessions = /* @__PURE__ */ new Map();
   }
 });
@@ -19534,7 +19872,14 @@ var init_commands = __esm({
 
 // src/router/callbacks.ts
 import { readFile as readFile7 } from "fs/promises";
-async function handleCallback(chatId, data, channel) {
+async function handleCallback(chatId, data, channel, messageId) {
+  const replaceWithText = async (text) => {
+    if (messageId && channel.editText) {
+      await channel.editText(chatId, messageId, text, "plain");
+    } else {
+      await channel.sendText(chatId, text, { parseMode: "plain" });
+    }
+  };
   if (data.startsWith("menu:")) {
     const action = data.slice(5);
     const synth = { chatId, messageId: "", text: "", senderName: "User", type: "command", source: "telegram", command: "", commandArgs: "" };
@@ -19770,7 +20115,7 @@ ${PERM_MODES[chosen]}`,
       return;
     }
     removePendingPlan(chatId);
-    await channel.sendText(chatId, "\u2705 Approved. Executing...", { parseMode: "plain" });
+    await replaceWithText("\u2705 Approved. Executing...");
     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.]
@@ -20263,14 +20608,14 @@ ${rotationNote}`, { parseMode: "html" });
       }
     } else if (action === "discard") {
       pendingInterrupts.delete(targetChatId);
-      await channel.sendText(chatId, "\u{1F5D1} Message discarded.", { parseMode: "plain" });
+      await replaceWithText("\u{1F5D1} Message discarded.");
     } else {
       await channel.sendText(chatId, "Message already processed or expired.", { parseMode: "plain" });
     }
   } else if (data.startsWith("sq:cancel:")) {
     const sqId = data.slice("sq:cancel:".length);
     stopAgent(sqId);
-    await channel.sendText(chatId, "\u{1F5FA} Side quest cancelled.", { parseMode: "plain" });
+    await replaceWithText("\u{1F5FA} Side quest cancelled.");
   } else if (data.startsWith("fallback:")) {
     const parts = data.split(":");
     const targetBackend = parts[1];
@@ -20658,9 +21003,9 @@ __export(session_log_exports2, {
   startSessionLogCleanupTimer: () => startSessionLogCleanupTimer,
   tailSessionLog: () => tailSessionLog
 });
-import { existsSync as existsSync23, mkdirSync as mkdirSync9, appendFileSync, readdirSync as readdirSync12, unlinkSync as unlinkSync6, statSync as statSync7, createReadStream } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync9, appendFileSync, readdirSync as readdirSync13, unlinkSync as unlinkSync7, statSync as statSync7, createReadStream } from "fs";
 import { join as join24, basename as basename3 } from "path";
-import { createInterface as createInterface6 } from "readline";
+import { createInterface as createInterface7 } from "readline";
 function getRetentionDays() {
   const env = process.env.SESSION_LOG_RETENTION_DAYS;
   if (env) {
@@ -20675,13 +21020,13 @@ function cleanupSessionLogs(retentionDays) {
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
   let cleaned = 0;
   try {
-    for (const file of readdirSync12(SESSION_LOGS_PATH)) {
+    for (const file of readdirSync13(SESSION_LOGS_PATH)) {
       if (!file.startsWith("session-") || !file.endsWith(".log")) continue;
       const filePath = join24(SESSION_LOGS_PATH, file);
       try {
         const { mtimeMs } = statSync7(filePath);
         if (mtimeMs < cutoff) {
-          unlinkSync6(filePath);
+          unlinkSync7(filePath);
           cleaned++;
         }
       } catch {
@@ -20705,7 +21050,7 @@ function startSessionLogCleanupTimer() {
 function listSessionLogs() {
   if (!existsSync23(SESSION_LOGS_PATH)) return [];
   const logs = [];
-  for (const file of readdirSync12(SESSION_LOGS_PATH)) {
+  for (const file of readdirSync13(SESSION_LOGS_PATH)) {
     if (!file.startsWith("session-") || !file.endsWith(".log")) continue;
     const filePath = join24(SESSION_LOGS_PATH, file);
     try {
@@ -20731,7 +21076,7 @@ async function* tailSessionLog(filePath, lines = 50) {
     return;
   }
   const allLines = [];
-  const rl2 = createInterface6({
+  const rl2 = createInterface7({
     input: createReadStream(filePath, { encoding: "utf-8" }),
     crlfDelay: Infinity
   });
@@ -20897,13 +21242,14 @@ function makeLiveStatus(chatId, channel, modelLabel, verboseLevel, showThinking)
   };
   return { liveStatus, toolCb };
 }
-var FLUSH_INTERVAL_MS, MAX_THINKING_CHARS, TRIM_THRESHOLD, MAX_ENTRIES, LiveStatusMessage;
+var FLUSH_INTERVAL_DM_MS, FLUSH_INTERVAL_GROUP_MS, MAX_THINKING_CHARS, TRIM_THRESHOLD, MAX_ENTRIES, LiveStatusMessage;
 var init_live_status = __esm({
   "src/router/live-status.ts"() {
     "use strict";
     init_log();
     init_helpers();
-    FLUSH_INTERVAL_MS = 1e3;
+    FLUSH_INTERVAL_DM_MS = 1e3;
+    FLUSH_INTERVAL_GROUP_MS = 3e3;
     MAX_THINKING_CHARS = 800;
     TRIM_THRESHOLD = 3500;
     MAX_ENTRIES = 200;
@@ -20925,6 +21271,11 @@ var init_live_status = __esm({
       nextFlushAllowedAt = 0;
       /** Tracks whether entries have been trimmed at least once (for display hint). */
       hasTrimmed = false;
+      /** Resolve flush interval based on chat type (group chats are rate-limited more aggressively). */
+      get flushIntervalMs() {
+        const numericId = parseInt(this.chatId);
+        return numericId < 0 ? FLUSH_INTERVAL_GROUP_MS : FLUSH_INTERVAL_DM_MS;
+      }
       /** Send the initial status message. Must be called before adding entries. */
       async init() {
         if (!this.channel.sendTextReturningId) return;
@@ -20933,7 +21284,7 @@ var init_live_status = __esm({
           this.messageId = await this.channel.sendTextReturningId(this.chatId, initial, "plain") ?? null;
           if (this.messageId) {
             this.flushTimer = setInterval(() => this.flush().catch(() => {
-            }), FLUSH_INTERVAL_MS);
+            }), this.flushIntervalMs);
           }
         } catch (err) {
           log(`[live-status] init failed: ${err}`);
@@ -22158,7 +22509,7 @@ var init_wrap_backend = __esm({
 });
 
 // src/agents/runners/config-loader.ts
-import { readFileSync as readFileSync14, readdirSync as readdirSync13, existsSync as existsSync24, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
+import { readFileSync as readFileSync14, readdirSync as readdirSync14, existsSync as existsSync24, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
 import { join as join26 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 function resolveExecutable(config2) {
@@ -22312,7 +22663,7 @@ function loadAllRunnerConfigs() {
     mkdirSync10(RUNNERS_PATH, { recursive: true });
     return [];
   }
-  const files = readdirSync13(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
+  const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   const configs = [];
   for (const file of files) {
     const config2 = loadRunnerConfig(join26(RUNNERS_PATH, file));
@@ -22343,7 +22694,7 @@ function watchRunnerConfigs(onChange) {
       watchedFiles.delete(prev);
     }
   }
-  const files = readdirSync13(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
+  const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   for (const file of files) {
     const fullPath = join26(RUNNERS_PATH, file);
     if (watchedFiles.has(fullPath)) continue;
@@ -22646,7 +22997,26 @@ ${body.replace(/<[^>]*>/g, "").trim()}</code>
 });
 
 // src/channels/telegram.ts
-import { Bot, InlineKeyboard, InputFile } from "grammy";
+import { Bot, GrammyError, InlineKeyboard, InputFile } from "grammy";
+async function withRetry(label2, fn) {
+  for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (err instanceof GrammyError && err.error_code === 429) {
+        const retrySec = Math.min(err.parameters?.retry_after ?? FALLBACK_RETRY_SEC, MAX_RETRY_WAIT_SEC);
+        if (attempt < MAX_RETRIES2) {
+          warn(`[telegram] 429 on ${label2} (attempt ${attempt + 1}/${MAX_RETRIES2}) \u2014 retrying in ${retrySec}s`);
+          await new Promise((r) => setTimeout(r, retrySec * 1e3));
+          continue;
+        }
+        warn(`[telegram] 429 on ${label2} \u2014 exhausted ${MAX_RETRIES2} retries, giving up`);
+      }
+      throw err;
+    }
+  }
+  throw new Error(`withRetry: unreachable`);
+}
 function isFastPathMessage(msg) {
   if (msg.type === "command" && msg.command && FAST_PATH_COMMANDS.has(msg.command)) {
     return true;
@@ -22666,13 +23036,16 @@ function numericChatId(chatId) {
   const raw = chatId.includes(":") ? chatId.split(":").pop() : chatId;
   return parseInt(raw);
 }
-var FAST_PATH_COMMANDS, TelegramChannel;
+var MAX_RETRIES2, FALLBACK_RETRY_SEC, MAX_RETRY_WAIT_SEC, FAST_PATH_COMMANDS, TelegramChannel;
 var init_telegram2 = __esm({
   "src/channels/telegram.ts"() {
     "use strict";
     init_telegram();
     init_log();
     init_store5();
+    MAX_RETRIES2 = 3;
+    FALLBACK_RETRY_SEC = 3;
+    MAX_RETRY_WAIT_SEC = 30;
     FAST_PATH_COMMANDS = /* @__PURE__ */ new Set(["stop", "status", "new", "newchat"]);
     TelegramChannel = class {
       name = "telegram";
@@ -22823,11 +23196,12 @@ var init_telegram2 = __esm({
             return;
           }
           const data = ctx.callbackQuery.data;
+          const messageId = ctx.callbackQuery.message?.message_id?.toString();
           ctx.answerCallbackQuery().catch(() => {
           });
           (async () => {
             for (const handler2 of this.callbackHandlers) {
-              await handler2(chatId, data, this);
+              await handler2(chatId, data, this, messageId);
             }
           })().catch((err) => {
             error("[telegram] Callback handler error:", err);
@@ -22880,7 +23254,10 @@ var init_telegram2 = __esm({
         if (parseMode === "plain") {
           const plainChunks = splitMessage(text);
           for (const chunk of plainChunks) {
-            const sent = await this.bot.api.sendMessage(numericChatId(chatId), chunk, { ...threadOpts, ...replyOpts });
+            const sent = await withRetry(
+              "sendText:plain",
+              () => this.bot.api.sendMessage(numericChatId(chatId), chunk, { ...threadOpts, ...replyOpts })
+            );
             this.trackAgentMessage(sent.message_id, chatId);
           }
           return;
@@ -22889,32 +23266,44 @@ var init_telegram2 = __esm({
         const chunks = splitMessage(formatted);
         for (const chunk of chunks) {
           try {
-            const sent = await this.bot.api.sendMessage(numericChatId(chatId), chunk, {
-              parse_mode: "HTML",
-              ...threadOpts,
-              ...replyOpts
-            });
+            const sent = await withRetry(
+              "sendText:html",
+              () => this.bot.api.sendMessage(numericChatId(chatId), chunk, {
+                parse_mode: "HTML",
+                ...threadOpts,
+                ...replyOpts
+              })
+            );
             this.trackAgentMessage(sent.message_id, chatId);
           } catch {
-            const sent = await this.bot.api.sendMessage(
-              numericChatId(chatId),
-              chunk.replace(/<[^>]+>/g, ""),
-              { ...threadOpts, ...replyOpts }
+            const sent = await withRetry(
+              "sendText:fallback",
+              () => this.bot.api.sendMessage(
+                numericChatId(chatId),
+                chunk.replace(/<[^>]+>/g, ""),
+                { ...threadOpts, ...replyOpts }
+              )
             );
             this.trackAgentMessage(sent.message_id, chatId);
           }
         }
       }
       async sendVoice(chatId, audioBuffer, fileName) {
-        await this.bot.api.sendVoice(
-          numericChatId(chatId),
-          new InputFile(audioBuffer, fileName ?? "response.ogg")
+        await withRetry(
+          "sendVoice",
+          () => this.bot.api.sendVoice(
+            numericChatId(chatId),
+            new InputFile(audioBuffer, fileName ?? "response.ogg")
+          )
         );
       }
       async sendFile(chatId, buffer, fileName) {
-        await this.bot.api.sendDocument(
-          numericChatId(chatId),
-          new InputFile(buffer, fileName)
+        await withRetry(
+          "sendFile",
+          () => this.bot.api.sendDocument(
+            numericChatId(chatId),
+            new InputFile(buffer, fileName)
+          )
         );
       }
       async downloadFile(fileId) {
@@ -22927,7 +23316,10 @@ var init_telegram2 = __esm({
         try {
           const formatted = parseMode === "html" ? text : parseMode === "plain" ? text : formatForTelegram(text);
           const opts = parseMode === "plain" ? {} : { parse_mode: "HTML" };
-          const msg = await this.bot.api.sendMessage(numericChatId(chatId), formatted, opts);
+          const msg = await withRetry(
+            "sendTextReturningId",
+            () => this.bot.api.sendMessage(numericChatId(chatId), formatted, opts)
+          );
           return msg.message_id.toString();
         } catch {
           return void 0;
@@ -22936,16 +23328,22 @@ var init_telegram2 = __esm({
       async editText(chatId, messageId, text, parseMode) {
         const formatted = parseMode === "html" ? text : formatForTelegram(text);
         try {
-          await this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
-            parse_mode: "HTML"
-          });
+          await withRetry(
+            "editText:html",
+            () => this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
+              parse_mode: "HTML"
+            })
+          );
           return true;
         } catch {
           try {
-            await this.bot.api.editMessageText(
-              numericChatId(chatId),
-              parseInt(messageId),
-              formatted.replace(/<[^>]+>/g, "")
+            await withRetry(
+              "editText:fallback",
+              () => this.bot.api.editMessageText(
+                numericChatId(chatId),
+                parseInt(messageId),
+                formatted.replace(/<[^>]+>/g, "")
+              )
             );
             return true;
           } catch {
@@ -22975,16 +23373,22 @@ var init_telegram2 = __esm({
         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), safeText, {
-            reply_markup: keyboard
-          });
+          const msg = await withRetry(
+            "sendKeyboard",
+            () => this.bot.api.sendMessage(numericChatId(chatId), safeText, {
+              reply_markup: keyboard
+            })
+          );
           return msg.message_id.toString();
         } 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
-            });
+            const fallbackMsg = await withRetry(
+              "sendKeyboard:fallback",
+              () => 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);
@@ -24333,7 +24737,7 @@ __export(service_exports, {
   serviceStatus: () => serviceStatus,
   uninstallService: () => uninstallService
 });
-import { existsSync as existsSync29, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8 } from "fs";
 import { execFileSync as execFileSync3, execSync as execSync6 } from "child_process";
 import { homedir as homedir10, platform } from "os";
 import { join as join30, dirname as dirname6 } from "path";
@@ -24442,7 +24846,7 @@ function uninstallMacOS() {
     execFileSync3("launchctl", ["unload", PLIST_PATH]);
   } catch {
   }
-  unlinkSync7(PLIST_PATH);
+  unlinkSync8(PLIST_PATH);
   console.log("  Service uninstalled.");
 }
 function formatUptime(seconds) {
@@ -24531,7 +24935,7 @@ function uninstallLinux() {
     execFileSync3("systemctl", ["--user", "disable", "cc-claw"]);
   } catch {
   }
-  unlinkSync7(UNIT_PATH);
+  unlinkSync8(UNIT_PATH);
   execFileSync3("systemctl", ["--user", "daemon-reload"]);
   console.log("  Service uninstalled.");
 }
@@ -25297,7 +25701,7 @@ __export(gemini_exports, {
 });
 import { existsSync as existsSync34, mkdirSync as mkdirSync14, writeFileSync as writeFileSync10, readFileSync as readFileSync22, chmodSync } from "fs";
 import { join as join31 } from "path";
-import { createInterface as createInterface7 } from "readline";
+import { createInterface as createInterface8 } from "readline";
 function requireDb() {
   if (!existsSync34(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
@@ -25370,7 +25774,7 @@ async function geminiList(globalOpts) {
 }
 async function geminiAddKey(globalOpts, opts) {
   await requireWriteDb();
-  const rl2 = createInterface7({ input: process.stdin, output: process.stdout });
+  const rl2 = createInterface8({ 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();
@@ -25562,7 +25966,7 @@ __export(backend_cmd_factory_exports, {
 });
 import { existsSync as existsSync35, mkdirSync as mkdirSync15, readFileSync as readFileSync23 } from "fs";
 import { join as join32 } from "path";
-import { createInterface as createInterface8 } from "readline";
+import { createInterface as createInterface9 } from "readline";
 function requireDb2() {
   if (!existsSync35(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
@@ -25623,7 +26027,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 = createInterface8({ input: process.stdin, output: process.stdout });
+    const rl2 = createInterface9({ 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();
@@ -27838,7 +28242,7 @@ var tui_exports = {};
 __export(tui_exports, {
   tuiCommand: () => tuiCommand
 });
-import { createInterface as createInterface9 } from "readline";
+import { createInterface as createInterface10 } 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));
@@ -27848,7 +28252,7 @@ async function tuiCommand(globalOpts, cmdOpts) {
   }
   const chatId = resolveChatId(globalOpts);
   const { chatSend: chatSend2 } = await Promise.resolve().then(() => (init_chat2(), chat_exports2));
-  const rl2 = createInterface9({
+  const rl2 = createInterface10({
     input: process.stdin,
     output: process.stdout,
     prompt: pc2.cyan("you > "),
@@ -28649,7 +29053,7 @@ var init_optimize2 = __esm({
 var setup_exports = {};
 import { existsSync as existsSync55, writeFileSync as writeFileSync12, readFileSync as readFileSync26, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
-import { createInterface as createInterface10 } from "readline";
+import { createInterface as createInterface11 } from "readline";
 import { join as join34 } from "path";
 function divider2() {
   console.log(dim("\u2500".repeat(55)));
@@ -29012,7 +29416,7 @@ var init_setup = __esm({
   "src/setup.ts"() {
     "use strict";
     init_paths();
-    rl = createInterface10({ input: process.stdin, output: process.stdout });
+    rl = createInterface11({ 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`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-claw",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "CC-Claw: Personal AI assistant on Telegram — multi-backend (Claude, Gemini, Codex, Cursor), sub-agent orchestration, MCP management",
   "type": "module",
   "main": "dist/cli.js",