cc-claw 0.19.3 → 0.20.1

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.19.3" : (() => {
+    VERSION = true ? "0.20.1" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -1774,6 +1774,12 @@ function initSchema(db3) {
       value INTEGER NOT NULL DEFAULT 0
     );
   `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS chat_skill_suggestions (
+      chat_id TEXT PRIMARY KEY,
+      value INTEGER NOT NULL DEFAULT 1
+    );
+  `);
   db3.exec(`
     CREATE TABLE IF NOT EXISTS chat_session_log (
       chat_id TEXT PRIMARY KEY,
@@ -2543,6 +2549,7 @@ __export(chat_settings_exports, {
   getRecentBookmarks: () => getRecentBookmarks,
   getSessionLogEnabled: () => getSessionLogEnabled,
   getShowThinkingUi: () => getShowThinkingUi,
+  getSkillSuggestionsEnabled: () => getSkillSuggestionsEnabled,
   getSummarizer: () => getSummarizer,
   getThinkingLevel: () => getThinkingLevel,
   getToolsMap: () => getToolsMap,
@@ -2559,6 +2566,7 @@ __export(chat_settings_exports, {
   setModel: () => setModel,
   setSessionLogEnabled: () => setSessionLogEnabled,
   setShowThinkingUi: () => setShowThinkingUi,
+  setSkillSuggestionsEnabled: () => setSkillSuggestionsEnabled,
   setSummarizer: () => setSummarizer,
   setThinkingLevel: () => setThinkingLevel,
   setVerboseLevel: () => setVerboseLevel,
@@ -2686,6 +2694,19 @@ function toggleShowThinkingUi(chatId) {
   setShowThinkingUi(chatId, next);
   return next;
 }
+function getSkillSuggestionsEnabled(chatId) {
+  const row = getDb().prepare(
+    "SELECT value FROM chat_skill_suggestions WHERE chat_id = ?"
+  ).get(chatId);
+  return (row?.value ?? 1) === 1;
+}
+function setSkillSuggestionsEnabled(chatId, enabled) {
+  getDb().prepare(`
+    INSERT INTO chat_skill_suggestions (chat_id, value)
+    VALUES (?, ?)
+    ON CONFLICT(chat_id) DO UPDATE SET value = ?
+  `).run(chatId, enabled ? 1 : 0, enabled ? 1 : 0);
+}
 function getMode(chatId) {
   const row = getDb().prepare(
     "SELECT mode FROM chat_mode WHERE chat_id = ?"
@@ -3677,6 +3698,9 @@ function setGeminiSlotEnabled(id, enabled) {
 function reorderGeminiSlot(id, priority) {
   getDb().prepare("UPDATE gemini_credentials SET priority = ? WHERE id = ?").run(priority, id);
 }
+function renameGeminiSlot(id, label2) {
+  return getDb().prepare("UPDATE gemini_credentials SET label = ? WHERE id = ?").run(label2, id).changes > 0;
+}
 function getGeminiRotationMode() {
   const row = getDb().prepare("SELECT value FROM meta WHERE key = 'gemini_rotation_mode'").get();
   return row?.value ?? "all";
@@ -3775,6 +3799,9 @@ function setBackendSlotEnabled(id, enabled) {
 function reorderBackendSlot(id, priority) {
   getDb().prepare("UPDATE backend_credentials SET priority = ? WHERE id = ?").run(priority, id);
 }
+function renameBackendSlot(id, label2) {
+  return getDb().prepare("UPDATE backend_credentials SET label = ? WHERE id = ?").run(label2, id).changes > 0;
+}
 function reenableBackendSlot(slotId) {
   getDb().prepare(`
     UPDATE backend_credentials
@@ -3891,6 +3918,7 @@ __export(store_exports5, {
   getSessionSummaries: () => getSessionSummaries,
   getSessionSummariesWithoutEmbeddings: () => getSessionSummariesWithoutEmbeddings,
   getShowThinkingUi: () => getShowThinkingUi,
+  getSkillSuggestionsEnabled: () => getSkillSuggestionsEnabled,
   getSummarizer: () => getSummarizer,
   getThinkingLevel: () => getThinkingLevel,
   getToolsMap: () => getToolsMap,
@@ -3923,6 +3951,8 @@ __export(store_exports5, {
   removeGeminiSlot: () => removeGeminiSlot,
   removeHeartbeatWatch: () => removeHeartbeatWatch,
   removePendingEscalation: () => removePendingEscalation,
+  renameBackendSlot: () => renameBackendSlot,
+  renameGeminiSlot: () => renameGeminiSlot,
   reorderBackendSlot: () => reorderBackendSlot,
   reorderGeminiSlot: () => reorderGeminiSlot,
   resetJobFailures: () => resetJobFailures,
@@ -3957,6 +3987,7 @@ __export(store_exports5, {
   setSessionLogEnabled: () => setSessionLogEnabled,
   setSessionStartedAt: () => setSessionStartedAt,
   setShowThinkingUi: () => setShowThinkingUi,
+  setSkillSuggestionsEnabled: () => setSkillSuggestionsEnabled,
   setSummarizer: () => setSummarizer,
   setThinkingLevel: () => setThinkingLevel,
   setVerboseLevel: () => setVerboseLevel,
@@ -6540,8 +6571,8 @@ var init_ndjson = __esm({
 
 // src/memory/inject.ts
 function getTopK(query) {
-  const wordCount = query.split(/\s+/).length;
-  const scale = wordCount <= 3 ? 0.5 : wordCount <= 8 ? 0.75 : 1;
+  const wordCount2 = query.split(/\s+/).length;
+  const scale = wordCount2 <= 3 ? 0.5 : wordCount2 <= 8 ? 0.75 : 1;
   return {
     vectorK: Math.max(5, Math.round(BASE_VECTOR_TOP_K * scale)),
     ftsK: Math.max(5, Math.round(BASE_FTS_TOP_K * scale))
@@ -7094,7 +7125,7 @@ function searchContext(userMessage) {
   }
   return null;
 }
-async function assembleBootstrapPrompt(userMessage, tier = "full", chatId, permMode, responseStyle, agentMode, sideQuestContext, planningDirective) {
+async function assembleBootstrapPrompt(userMessage, tier = "full", chatId, permMode, responseStyle, agentMode, sideQuestContext, planningDirective, chatContext) {
   const sections = [];
   if (planningDirective) {
     sections.push(planningDirective);
@@ -7113,6 +7144,19 @@ async function assembleBootstrapPrompt(userMessage, tier = "full", chatId, permM
       sections.push("[Response Style]\nYou should be detailed and thorough in your responses. Explain concepts fully and provide comprehensive answers.");
     }
   }
+  if (chatId && tier !== "slim") {
+    const parts = [`Chat ID: ${chatId}`];
+    if (chatContext?.chatTitle) parts.push(`Group: ${chatContext.chatTitle}`);
+    if (chatContext?.threadId) parts.push(`Forum topic thread: ${chatContext.threadId}`);
+    try {
+      const { getAllChatAliases: getAllChatAliases3 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+      const match = getAllChatAliases3().find((a) => a.chatId === chatId);
+      if (match) parts.push(`Alias: ${match.alias}`);
+    } catch {
+    }
+    sections.push(`[Current chat]
+${parts.join("\n")}`);
+  }
   if (tier === "full") {
     const ctx = searchContext(userMessage);
     if (ctx) {
@@ -9325,6 +9369,19 @@ var init_agent_log = __esm({
 });
 
 // src/agents/orchestrator.ts
+var orchestrator_exports = {};
+__export(orchestrator_exports, {
+  cancelAgent: () => cancelAgent,
+  cancelAllAgents: () => cancelAllAgents,
+  diagnoseSpawnError: () => diagnoseSpawnError,
+  getActiveProcessCount: () => getActiveProcessCount,
+  getOrCreateOrchestration: () => getOrCreateOrchestration,
+  getRunningAgentCount: () => getRunningAgentCount,
+  initOrchestrator: () => initOrchestrator,
+  setNotifyCallback: () => setNotifyCallback,
+  shutdownOrchestrator: () => shutdownOrchestrator,
+  spawnSubAgent: () => spawnSubAgent
+});
 import { existsSync as existsSync10 } from "fs";
 async function withRunnerLock(runnerId, fn) {
   const prev = runnerLocks.get(runnerId) ?? Promise.resolve();
@@ -9964,6 +10021,9 @@ function cancelAllAgents(chatId, reason = "user_cancelled") {
   updateOrchestrationStatus(db3, orch.id, "abandoned");
   return count;
 }
+function getActiveProcessCount() {
+  return activeProcesses.size;
+}
 function shutdownOrchestrator() {
   for (const [agentId, proc] of activeProcesses) {
     try {
@@ -12503,12 +12563,12 @@ 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: join35 } = await import("path");
+        const { join: join36 } = await import("path");
         const { CC_CLAW_HOME: home } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const chatId = resolveChatId(body);
         if (!chatId) return jsonResponse(res, { error: "No chatId provided and ALLOWED_CHAT_ID is not set" }, 400);
-        const soulPath = join35(home, "identity/SOUL.md");
-        const userPath = join35(home, "identity/USER.md");
+        const soulPath = join36(home, "identity/SOUL.md");
+        const userPath = join36(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);
@@ -12867,9 +12927,9 @@ function matchPatterns(message, patterns, signalType) {
   return matches;
 }
 function classifySignals(userMessage, _agentResponse) {
-  const wordCount = userMessage.trim().split(/\s+/).filter(Boolean).length;
+  const wordCount2 = userMessage.trim().split(/\s+/).filter(Boolean).length;
   const results = [];
-  if (wordCount >= 3) {
+  if (wordCount2 >= 3) {
     for (const m of matchPatterns(userMessage, CORRECTION_PATTERNS, "correction")) {
       results.push({ ...m, source: "auto_detect" });
     }
@@ -13549,12 +13609,12 @@ async function askAgentImpl(chatId, userMessage, opts) {
   const adapter = backend2 ? getAdapter(backend2) : getAdapterForChat(settingsChat);
   const mode = permMode ?? getMode(settingsChat);
   const responseStyle = getResponseStyle(settingsChat);
-  const thinkingLevel = getThinkingLevel(settingsChat);
+  const thinkingLevel = opts?.thinkingLevel ?? getThinkingLevel(settingsChat);
   const resolvedCwd = cwd ?? WORKSPACE_PATH;
   const tier = bootstrapTier ?? "full";
   const effectiveAgentMode = optsAgentMode ?? getAgentMode(settingsChat);
   const sideQuestCtx = settingsSourceChatId ? { parentChatId: settingsSourceChatId, actualChatId: chatId } : void 0;
-  const fullPrompt = await assembleBootstrapPrompt(userMessage, tier, settingsChat, mode, responseStyle, effectiveAgentMode, sideQuestCtx, planningDirective);
+  const fullPrompt = await assembleBootstrapPrompt(userMessage, tier, settingsChat, mode, responseStyle, effectiveAgentMode, sideQuestCtx, planningDirective, opts?.chatContext);
   if (adapter.streamDirect) {
     const resolvedModel2 = model2 ?? adapter.defaultModel;
     const abortController = new AbortController();
@@ -16451,8 +16511,8 @@ async function mp3ToOgg(mp3Buffer) {
   const id = crypto.randomUUID();
   const tmpMp3 = `/tmp/cc-claw-tts-${id}.mp3`;
   const tmpOgg = `/tmp/cc-claw-tts-${id}.ogg`;
-  const { writeFile: writeFile5 } = await import("fs/promises");
-  await writeFile5(tmpMp3, mp3Buffer);
+  const { writeFile: writeFile6 } = await import("fs/promises");
+  await writeFile6(tmpMp3, mp3Buffer);
   await execFileAsync2("ffmpeg", ["-y", "-i", tmpMp3, "-c:a", "libopus", "-b:a", "64k", tmpOgg]);
   const oggBuffer = await readFile2(tmpOgg);
   unlink(tmpMp3).catch((err) => {
@@ -19227,10 +19287,10 @@ async function handleEvolveCallback(chatId, data, channel) {
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
         const { readFileSync: readFileSync28, existsSync: existsSync56 } = await import("fs");
-        const { join: join35 } = await import("path");
+        const { join: join36 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const soulPath = join35(CC_CLAW_HOME3, "identity/SOUL.md");
-        const userPath = join35(CC_CLAW_HOME3, "identity/USER.md");
+        const soulPath = join36(CC_CLAW_HOME3, "identity/SOUL.md");
+        const userPath = join36(CC_CLAW_HOME3, "identity/USER.md");
         const soul = existsSync56(soulPath) ? readFileSync28(soulPath, "utf-8") : "";
         const user = existsSync56(userPath) ? readFileSync28(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
@@ -20580,6 +20640,133 @@ var init_optimize = __esm({
   }
 });
 
+// src/council/types.ts
+var COUNCIL_MIN_PARTICIPANTS, COUNCIL_MAX_ROUNDS, COUNCIL_WIZARD_TIMEOUT_MS;
+var init_types4 = __esm({
+  "src/council/types.ts"() {
+    "use strict";
+    COUNCIL_MIN_PARTICIPANTS = 2;
+    COUNCIL_MAX_ROUNDS = 3;
+    COUNCIL_WIZARD_TIMEOUT_MS = 10 * 60 * 1e3;
+  }
+});
+
+// src/council/wizard.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  buildSelectKeyboard: () => buildSelectKeyboard,
+  cancelCouncil: () => cancelCouncil,
+  getCouncilState: () => getCouncilState,
+  hasPendingCouncil: () => hasPendingCouncil,
+  setCouncilQuestion: () => setCouncilQuestion,
+  startCouncilWizard: () => startCouncilWizard,
+  toggleParticipant: () => toggleParticipant
+});
+function resetCouncilTimeout(chatId) {
+  const existing = councilTimers.get(chatId);
+  if (existing) clearTimeout(existing);
+  councilTimers.set(chatId, setTimeout(() => {
+    pendingCouncils.delete(chatId);
+    councilTimers.delete(chatId);
+    log(`[council] Auto-cancelled stale council wizard for chat ${chatId}`);
+  }, COUNCIL_WIZARD_TIMEOUT_MS));
+}
+function startCouncilWizard(chatId) {
+  if (pendingCouncils.has(chatId)) {
+    cancelCouncil(chatId);
+  }
+  pendingCouncils.set(chatId, {
+    step: "select",
+    selected: /* @__PURE__ */ new Map()
+  });
+  resetCouncilTimeout(chatId);
+}
+function hasPendingCouncil(chatId) {
+  return pendingCouncils.has(chatId);
+}
+function getCouncilState(chatId) {
+  return pendingCouncils.get(chatId);
+}
+function cancelCouncil(chatId) {
+  pendingCouncils.delete(chatId);
+  const timer = councilTimers.get(chatId);
+  if (timer) {
+    clearTimeout(timer);
+    councilTimers.delete(chatId);
+  }
+}
+function toggleParticipant(chatId, backend2, model2, label2) {
+  const state = pendingCouncils.get(chatId);
+  if (!state) return;
+  resetCouncilTimeout(chatId);
+  const key = `${backend2}:${model2}`;
+  if (state.selected.has(key)) {
+    state.selected.delete(key);
+  } else {
+    state.selected.set(key, { backend: backend2, model: model2, label: label2 });
+  }
+}
+function setCouncilQuestion(chatId, question) {
+  const state = pendingCouncils.get(chatId);
+  if (!state) return { error: "No active council wizard." };
+  resetCouncilTimeout(chatId);
+  if (state.selected.size < COUNCIL_MIN_PARTICIPANTS) {
+    return { error: `Select at least ${COUNCIL_MIN_PARTICIPANTS} models before starting.` };
+  }
+  state.question = question;
+  state.step = "running";
+  return {};
+}
+function buildSelectKeyboard(chatId) {
+  const state = pendingCouncils.get(chatId);
+  if (!state) {
+    return { text: "No active council wizard.", buttons: [] };
+  }
+  const adapters2 = getAvailableAdapters();
+  const buttons = [];
+  for (const adapter of adapters2) {
+    for (const [modelId, modelInfo] of Object.entries(adapter.availableModels)) {
+      const key = `${adapter.id}:${modelId}`;
+      const isSelected = state.selected.has(key);
+      const checkmark = isSelected ? "\u2713 " : "  ";
+      const row = [{
+        label: `${checkmark}${modelInfo.label}`,
+        data: `council:toggle:${adapter.id}:${modelId}:${modelInfo.label}`,
+        ...isSelected ? { style: "success" } : {}
+      }];
+      buttons.push(row);
+    }
+  }
+  const count = state.selected.size;
+  const canStart = count >= COUNCIL_MIN_PARTICIPANTS;
+  buttons.push([
+    {
+      label: canStart ? `\u25B6 Start Council (${count} models)` : `\u25B6 Start Council (${count} models)`,
+      data: canStart ? "council:start" : "council:noop",
+      ...canStart ? {} : {}
+    },
+    {
+      label: "\u2715 Cancel",
+      data: "council:cancel"
+    }
+  ]);
+  return {
+    text: `Select models for the council debate (${count} selected):`,
+    buttons
+  };
+}
+var pendingCouncils, councilTimers;
+var init_wizard2 = __esm({
+  "src/council/wizard.ts"() {
+    "use strict";
+    init_types4();
+    init_backends();
+    init_log();
+    pendingCouncils = /* @__PURE__ */ new Map();
+    councilTimers = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/router/command-handlers.ts
 import { readFile as readFile6 } from "fs/promises";
 async function handleStopCommand(chatId, commandArgs, msg, channel) {
@@ -21186,6 +21373,12 @@ async function handleModelCommand(chatId, commandArgs, msg, channel) {
         ...id === current ? { style: "primary" } : {}
       }];
     });
+    const isAuto = getModel(chatId) === "auto";
+    buttons.unshift([{
+      label: `${isAuto ? "\u2713 " : ""}\u{1F916} Auto (smart routing)`,
+      data: "model:auto",
+      ...isAuto ? { style: "primary" } : {}
+    }]);
     await channel.sendKeyboard(chatId, `Models for ${adapter.displayName}:`, buttons);
   } else {
     const lines = Object.entries(models).map(
@@ -22095,6 +22288,20 @@ async function handleCronCommand(chatId, commandArgs, msg, channel) {
       await startWizard(chatId, commandArgs, channel);
   }
 }
+async function handleCouncilCommand(chatId, commandArgs, msg, channel) {
+  if (process.env.DASHBOARD_ENABLED !== "1") {
+    await channel.sendText(chatId, "Council requires DASHBOARD_ENABLED=1 (uses the agent orchestrator).", { parseMode: "plain" });
+    return;
+  }
+  const { startCouncilWizard: startCouncilWizard2, buildSelectKeyboard: buildSelectKeyboard2 } = await Promise.resolve().then(() => (init_wizard2(), wizard_exports));
+  startCouncilWizard2(chatId);
+  if (typeof channel.sendKeyboard === "function") {
+    const { text, buttons } = buildSelectKeyboard2(chatId);
+    await channel.sendKeyboard(chatId, text, buttons);
+  } else {
+    await channel.sendText(chatId, "Council requires Telegram (needs inline keyboards).", { parseMode: "plain" });
+  }
+}
 var init_command_handlers = __esm({
   "src/router/command-handlers.ts"() {
     "use strict";
@@ -22303,6 +22510,10 @@ async function handleCommand(msg, channel) {
     case "intent":
       await handleIntentCommand(chatId, commandArgs, msg, channel);
       break;
+    case "council":
+    case "debate":
+      await handleCouncilCommand(chatId, commandArgs, msg, channel);
+      break;
     case "evolve":
       await handleEvolveCommandWrapper(chatId, commandArgs, msg, channel);
       break;
@@ -22345,6 +22556,120 @@ var init_commands = __esm({
   }
 });
 
+// src/skills/auto-create.ts
+var auto_create_exports = {};
+__export(auto_create_exports, {
+  buildSkillExtractionPrompt: () => buildSkillExtractionPrompt,
+  clearPendingDraft: () => clearPendingDraft,
+  getPendingDraft: () => getPendingDraft,
+  isSkillWorthy: () => isSkillWorthy,
+  parseExtractedSkill: () => parseExtractedSkill,
+  saveSkill: () => saveSkill,
+  storePendingDraft: () => storePendingDraft
+});
+import { join as join25 } from "path";
+import { writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+function isSkillWorthy(signals) {
+  const { toolUseCount, tokenOutput, elapsedMs, userMessage } = signals;
+  if (toolUseCount < 8) return false;
+  const supplementary = [
+    tokenOutput >= 3e3,
+    // substantial output
+    elapsedMs >= 45e3
+    // took real effort (45s+)
+  ].filter(Boolean).length;
+  if (supplementary < 1) return false;
+  const words = userMessage.split(/\s+/).length;
+  if (words < 5) return false;
+  log(`[auto-skill] Skill-worthy: tools=${toolUseCount}, tokens=${tokenOutput}, elapsed=${elapsedMs}ms`);
+  return true;
+}
+function buildSkillExtractionPrompt(userMessage, assistantResponse) {
+  const cappedResponse = assistantResponse.length > 8e3 ? assistantResponse.slice(0, 8e3) + "\n\n[...truncated...]" : assistantResponse;
+  return [
+    "You are a skill extraction assistant. Analyze the following completed task and create a reusable SKILL.md file.",
+    "",
+    "A skill is a set of instructions that an AI agent can follow to accomplish a similar task in the future.",
+    "Focus on the PROCESS and APPROACH, not the specific details of this particular task.",
+    "",
+    "## Completed Task",
+    "",
+    `**User request:** ${userMessage}`,
+    "",
+    `**Assistant response:**`,
+    cappedResponse,
+    "",
+    "## Output Format",
+    "",
+    "Output ONLY the SKILL.md content with this exact format:",
+    "",
+    "```",
+    "---",
+    'name: "skill-name-in-kebab-case"',
+    'description: "What this skill does and when to use it"',
+    "---",
+    "",
+    "## [Skill Title]",
+    "",
+    "[Step-by-step instructions for accomplishing this type of task]",
+    "[Include decision points, best practices, and common pitfalls]",
+    "[Keep it general enough to be reusable, specific enough to be helpful]",
+    "```",
+    "",
+    "Rules:",
+    "- The skill name should be descriptive and kebab-case",
+    "- The description should explain WHAT it does AND WHEN to use it",
+    "- Instructions should be general (not tied to specific file names or projects)",
+    "- Include any important caveats or prerequisites",
+    "- Keep it under 100 lines"
+  ].join("\n");
+}
+function parseExtractedSkill(llmResponse) {
+  let content = llmResponse;
+  const fenceMatch = llmResponse.match(/```(?:markdown|md)?\s*\n([\s\S]*?)```/);
+  if (fenceMatch) content = fenceMatch[1].trim();
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    warn("[auto-skill] No frontmatter found in extracted skill");
+    return null;
+  }
+  const nameMatch = fmMatch[1].match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m);
+  if (!nameMatch) {
+    warn("[auto-skill] No name field in skill frontmatter");
+    return null;
+  }
+  const name = nameMatch[1].trim().toLowerCase().replace(/\s+/g, "-");
+  return { name, content };
+}
+async function saveSkill(name, content) {
+  const dir = join25(SKILLS_PATH, name);
+  await mkdir3(dir, { recursive: true });
+  const filePath = join25(dir, "SKILL.md");
+  await writeFile4(filePath, content, "utf-8");
+  invalidateSkillCache();
+  log(`[auto-skill] Saved skill "${name}" to ${filePath}`);
+  return { path: filePath };
+}
+function storePendingDraft(chatId, draft) {
+  pendingDrafts.set(chatId, draft);
+}
+function getPendingDraft(chatId) {
+  return pendingDrafts.get(chatId);
+}
+function clearPendingDraft(chatId) {
+  pendingDrafts.delete(chatId);
+}
+var pendingDrafts;
+var init_auto_create = __esm({
+  "src/skills/auto-create.ts"() {
+    "use strict";
+    init_paths();
+    init_discover();
+    init_log();
+    pendingDrafts = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/router/callbacks.ts
 import { readFile as readFile7 } from "fs/promises";
 async function handleCallback(chatId, data, channel, messageId) {
@@ -22404,6 +22729,12 @@ async function handleCallback(chatId, data, channel, messageId) {
     await channel.sendText(chatId, `Using ${adapter.displayName} with default model. Ready!`, { parseMode: "plain" });
   } else if (data.startsWith("model:")) {
     const chosen = data.slice(6);
+    if (chosen === "auto") {
+      setModel(chatId, "auto");
+      clearThinkingLevel(chatId);
+      await channel.sendText(chatId, "\u{1F916} Smart routing enabled \u2014 model and thinking level will be chosen per message based on complexity.", { parseMode: "plain" });
+      return;
+    }
     let adapter;
     try {
       adapter = getAdapterForChat(chatId);
@@ -23043,6 +23374,47 @@ ${rotationNote}`, { parseMode: "html" });
   } else if (data.startsWith("reflect:")) {
     await handleReflectCallback(chatId, data, channel);
     return;
+  } else if (data.startsWith("council:")) {
+    const parts = data.split(":");
+    const action = parts[1];
+    if (action === "toggle") {
+      const backend2 = parts[2];
+      const model2 = parts[3];
+      const label2 = parts.slice(4).join(":");
+      const { toggleParticipant: toggleParticipant2, buildSelectKeyboard: buildSelectKeyboard2, hasPendingCouncil: hasPendingCouncil2 } = await Promise.resolve().then(() => (init_wizard2(), wizard_exports));
+      if (!hasPendingCouncil2(chatId)) {
+        await channel.sendText(chatId, "No council wizard active. Use /council to start.", { parseMode: "plain" });
+        return;
+      }
+      toggleParticipant2(chatId, backend2, model2, label2);
+      if (typeof channel.sendKeyboard === "function") {
+        const { text, buttons } = buildSelectKeyboard2(chatId);
+        await channel.sendKeyboard(chatId, text, buttons);
+      }
+      return;
+    }
+    if (action === "start") {
+      const { getCouncilState: getCouncilState2 } = await Promise.resolve().then(() => (init_wizard2(), wizard_exports));
+      const state = getCouncilState2(chatId);
+      if (!state || state.selected.size < 2) {
+        await channel.sendText(chatId, "Select at least 2 models first.", { parseMode: "plain" });
+        return;
+      }
+      state.step = "question";
+      const names = [...state.selected.values()].map((p) => p.label).join(", ");
+      await channel.sendText(chatId, `\u{1F3DB}\uFE0F Council members: ${names}
+
+Now type the question you want them to debate.`, { parseMode: "plain" });
+      return;
+    }
+    if (action === "cancel") {
+      const { cancelCouncil: cancelCouncil2 } = await Promise.resolve().then(() => (init_wizard2(), wizard_exports));
+      cancelCouncil2(chatId);
+      await channel.sendText(chatId, "Council cancelled.", { parseMode: "plain" });
+      return;
+    }
+    if (action === "noop") return;
+    return;
   } else if (data.startsWith("opt:")) {
     await handleOptimizeCallback(chatId, data, channel);
     return;
@@ -23322,6 +23694,45 @@ Example: /limits ${bid} daily 500000`, { parseMode: "plain" });
     const page = parseInt(data.slice(12), 10);
     const skills2 = await discoverAllSkills();
     await sendSkillsPage(chatId, channel, skills2, page, messageId);
+  } else if (data === "skill:extract") {
+    const { getPendingDraft: getPendingDraft2, clearPendingDraft: clearPendingDraft2, buildSkillExtractionPrompt: buildSkillExtractionPrompt2, parseExtractedSkill: parseExtractedSkill2, saveSkill: saveSkill2 } = await Promise.resolve().then(() => (init_auto_create(), auto_create_exports));
+    const draft = getPendingDraft2(chatId);
+    if (!draft) {
+      await channel.sendText(chatId, "No pending skill draft.", { parseMode: "plain" });
+      return;
+    }
+    await channel.sendText(chatId, "\u{1F50D} Extracting skill from conversation...", { parseMode: "plain" });
+    await channel.sendTyping?.(chatId);
+    try {
+      const { askAgent: askAgent3 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
+      const extractionPrompt = buildSkillExtractionPrompt2(draft.userMessage, draft.assistantResponse);
+      const extractionResponse = await askAgent3(chatId, extractionPrompt, {
+        bootstrapTier: "slim",
+        maxTurns: 1,
+        timeoutMs: 3e4
+      });
+      const parsed = parseExtractedSkill2(extractionResponse.text);
+      if (parsed) {
+        const { path } = await saveSkill2(parsed.name, parsed.content);
+        clearPendingDraft2(chatId);
+        await channel.sendText(chatId, `\u2705 Skill "${parsed.name}" saved.
+Path: ${path}
+
+Use /skills to see all available skills.`, { parseMode: "plain" });
+      } else {
+        clearPendingDraft2(chatId);
+        await channel.sendText(chatId, "Could not extract a well-formed skill from this conversation. Try /remember to save key steps manually.", { parseMode: "plain" });
+      }
+    } catch (e) {
+      clearPendingDraft2(chatId);
+      await channel.sendText(chatId, `Skill extraction failed: ${e.message}`, { parseMode: "plain" });
+    }
+    return;
+  } else if (data === "skill:discard") {
+    const { clearPendingDraft: clearPendingDraft2 } = await Promise.resolve().then(() => (init_auto_create(), auto_create_exports));
+    clearPendingDraft2(chatId);
+    if (messageId) await replaceWithText("\u{1F44C} Noted.");
+    return;
   } else if (data.startsWith("skill:")) {
     const parts = data.slice(6).split(":");
     let skillName;
@@ -23396,6 +23807,399 @@ var init_callbacks = __esm({
   }
 });
 
+// src/channels/thread-wrapper.ts
+var thread_wrapper_exports = {};
+__export(thread_wrapper_exports, {
+  withThread: () => withThread
+});
+function withThread(channel, threadId) {
+  return {
+    get name() {
+      return channel.name;
+    },
+    start: channel.start.bind(channel),
+    stop: channel.stop.bind(channel),
+    getCapabilities: channel.getCapabilities.bind(channel),
+    downloadFile: channel.downloadFile.bind(channel),
+    isAuthorized: channel.isAuthorized.bind(channel),
+    sendText(chatId, text, opts) {
+      return channel.sendText(chatId, text, { ...opts, threadId: opts?.threadId ?? threadId });
+    },
+    sendVoice(chatId, audioBuffer, fileName) {
+      return channel.sendVoice(chatId, audioBuffer, fileName, threadId);
+    },
+    sendFile(chatId, buffer, fileName, mimeType) {
+      return channel.sendFile(chatId, buffer, fileName, mimeType, threadId);
+    },
+    sendTyping: channel.sendTyping ? (chatId) => channel.sendTyping(chatId, threadId) : void 0,
+    sendKeyboard: channel.sendKeyboard ? (chatId, text, buttons) => channel.sendKeyboard(chatId, text, buttons, threadId) : void 0,
+    sendTextReturningId: channel.sendTextReturningId ? (chatId, text, parseMode) => channel.sendTextReturningId(chatId, text, parseMode, threadId) : void 0,
+    // These operate on existing messages — no threadId needed
+    editText: channel.editText?.bind(channel),
+    editKeyboard: channel.editKeyboard?.bind(channel),
+    reactToMessage: channel.reactToMessage?.bind(channel)
+  };
+}
+var init_thread_wrapper = __esm({
+  "src/channels/thread-wrapper.ts"() {
+    "use strict";
+  }
+});
+
+// src/intent/complexity.ts
+var complexity_exports = {};
+__export(complexity_exports, {
+  classifyComplexity: () => classifyComplexity
+});
+function wordCount(text) {
+  return text.trim().split(/\s+/).filter(Boolean).length;
+}
+function classifyComplexity(text) {
+  const trimmed = text.trim();
+  const lower = trimmed.toLowerCase();
+  const words = wordCount(trimmed);
+  if (TRIVIAL_EXACT.has(lower)) {
+    log(`[complexity] "${lower}" -> trivial (exact match)`);
+    return "trivial";
+  }
+  if (trimmed.length <= 4 && /^[\p{Emoji}\s]+$/u.test(trimmed)) {
+    log(`[complexity] "${trimmed}" -> trivial (emoji-only)`);
+    return "trivial";
+  }
+  if (COMPLEX_SIGNALS.test(trimmed) && (words > 15 || trimmed.length > 200)) {
+    log(`[complexity] "${trimmed.slice(0, 40)}..." -> complex (signal words + length)`);
+    return "complex";
+  }
+  if (MUTATION_VERBS.test(trimmed)) {
+    const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
+    log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (mutation verb)`);
+    return tier;
+  }
+  for (const pattern of CODE_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
+      log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (code pattern)`);
+      return tier;
+    }
+  }
+  if (trimmed.length > 200 || words > 25) {
+    const tier = words > 30 || trimmed.length > 300 ? "complex" : "moderate";
+    log(`[complexity] "${trimmed.slice(0, 40)}..." -> ${tier} (long message)`);
+    return tier;
+  }
+  for (const pattern of QUESTION_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      log(`[complexity] "${trimmed.slice(0, 40)}..." -> simple (question)`);
+      return "simple";
+    }
+  }
+  log(`[complexity] "${trimmed.slice(0, 40)}..." -> moderate (default)`);
+  return "moderate";
+}
+var TRIVIAL_EXACT, COMPLEX_SIGNALS, MUTATION_VERBS, CODE_PATTERNS, QUESTION_PATTERNS;
+var init_complexity = __esm({
+  "src/intent/complexity.ts"() {
+    "use strict";
+    init_log();
+    TRIVIAL_EXACT = /* @__PURE__ */ new Set([
+      "hey",
+      "hi",
+      "hello",
+      "yo",
+      "sup",
+      "howdy",
+      "hiya",
+      "thanks",
+      "thank you",
+      "thx",
+      "ty",
+      "thank u",
+      "ok",
+      "okay",
+      "k",
+      "kk",
+      "cool",
+      "nice",
+      "great",
+      "awesome",
+      "perfect",
+      "good morning",
+      "good night",
+      "good evening",
+      "gm",
+      "gn",
+      "bye",
+      "goodbye",
+      "later",
+      "see ya",
+      "cya",
+      "lol",
+      "lmao",
+      "haha",
+      "heh",
+      "np",
+      "no problem",
+      "no worries",
+      "nw",
+      "got it",
+      "understood",
+      "roger",
+      "copy",
+      "good",
+      "fine",
+      "alright",
+      "sure",
+      "yes",
+      "no",
+      "yep",
+      "nope",
+      "yeah",
+      "nah"
+    ]);
+    COMPLEX_SIGNALS = /\b(architect|design|research|plan|strategy|migration|microservice|distributed|end-to-end|trade-offs|pros\s+and\s+cons)\b/i;
+    MUTATION_VERBS = /\b(fix|create|build|deploy|refactor|implement|write|add|update|edit|test|debug)\b/i;
+    CODE_PATTERNS = [
+      /```/,
+      // code blocks
+      /\.[a-z]{1,5}\b/,
+      // file extensions (.ts, .py, .json)
+      /[/\\][\w.-]+/
+      // file paths (/src/foo, .\bar)
+    ];
+    QUESTION_PATTERNS = [
+      /^(?:what|which|where|when|why|how)\b/i,
+      /^(?:show|tell|list|explain)\b/i,
+      /^(?:is|are)\b/i
+    ];
+  }
+});
+
+// src/intent/auto-route.ts
+var auto_route_exports = {};
+__export(auto_route_exports, {
+  resolveAutoRoute: () => resolveAutoRoute
+});
+function tieredModels(adapter) {
+  const modelIds = Object.keys(adapter.availableModels);
+  if (modelIds.length <= 1) {
+    const only = modelIds[0] ?? adapter.defaultModel;
+    return { cheap: only, mid: only, best: only };
+  }
+  const pricingEntries = modelIds.filter((id) => adapter.pricing[id]).map((id) => ({ id, out: adapter.pricing[id].out }));
+  if (pricingEntries.length >= 2) {
+    pricingEntries.sort((a, b) => a.out - b.out);
+    const cheap = pricingEntries[0].id;
+    const best = pricingEntries[pricingEntries.length - 1].id;
+    const midIdx = Math.floor(pricingEntries.length / 2);
+    const mid = pricingEntries.length === 2 ? pricingEntries[1].id : pricingEntries[midIdx].id;
+    return { cheap, mid, best };
+  }
+  return {
+    cheap: adapter.summarizerModel,
+    mid: adapter.defaultModel,
+    best: modelIds[0]
+  };
+}
+function pickThinking(model2, adapter, desired) {
+  const info = adapter.availableModels[model2];
+  if (!info || info.thinking !== "adjustable") {
+    return "auto";
+  }
+  const levels = info.thinkingLevels;
+  if (!levels || levels.length === 0) {
+    return "auto";
+  }
+  if (levels.includes(desired)) {
+    return desired;
+  }
+  const desiredIdx = THINKING_ORDER.indexOf(desired);
+  if (desiredIdx === -1) return levels[0];
+  let closest = levels[0];
+  let closestDist = Infinity;
+  for (const lvl of levels) {
+    const idx = THINKING_ORDER.indexOf(lvl);
+    if (idx === -1) continue;
+    const dist = Math.abs(idx - desiredIdx);
+    if (dist < closestDist) {
+      closestDist = dist;
+      closest = lvl;
+    }
+  }
+  return closest;
+}
+function resolveAutoRoute(tier, adapter) {
+  const models = tieredModels(adapter);
+  const mapping = TIER_MAP[tier];
+  const model2 = models[mapping.tier];
+  const thinkingLevel = pickThinking(model2, adapter, mapping.thinking);
+  log(
+    `[auto-route] ${tier} -> ${model2} (${mapping.tier}), thinking=${thinkingLevel} [${adapter.id}]`
+  );
+  return { model: model2, thinkingLevel };
+}
+var THINKING_ORDER, TIER_MAP;
+var init_auto_route = __esm({
+  "src/intent/auto-route.ts"() {
+    "use strict";
+    init_log();
+    THINKING_ORDER = ["off", "low", "medium", "high", "extra_high"];
+    TIER_MAP = {
+      trivial: { tier: "cheap", thinking: "off" },
+      simple: { tier: "cheap", thinking: "low" },
+      moderate: { tier: "mid", thinking: "medium" },
+      complex: { tier: "best", thinking: "high" }
+    };
+  }
+});
+
+// src/council/executor.ts
+var executor_exports = {};
+__export(executor_exports, {
+  anonymizeSubmissions: () => anonymizeSubmissions,
+  buildRoundPrompt: () => buildRoundPrompt,
+  executeCouncil: () => executeCouncil,
+  waitForAgent: () => waitForAgent
+});
+function anonymizeSubmissions(submissions) {
+  const entries = [...submissions.entries()].map(([, response]) => response);
+  for (let i = entries.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [entries[i], entries[j]] = [entries[j], entries[i]];
+  }
+  const labels = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  return entries.map((response, idx) => ({
+    label: `Participant ${labels[idx] ?? String(idx + 1)}`,
+    response
+  }));
+}
+function buildRoundPrompt(question, roundNumber, priorSubmissions) {
+  if (roundNumber === 1 || !priorSubmissions?.length) {
+    return [
+      "You are participating in a council debate. Provide your best answer to the following question.",
+      "",
+      `Question: ${question}`
+    ].join("\n");
+  }
+  const submissionBlock = priorSubmissions.map((s) => `--- ${s.label} ---
+${s.response}`).join("\n\n");
+  return [
+    "You are participating in a council debate (round " + roundNumber + ").",
+    "Review the positions below, address any disagreements, and refine your answer.",
+    "Evaluate each position on merit only. You do NOT know which model produced which submission.",
+    "",
+    `Question: ${question}`,
+    "",
+    "Previous submissions:",
+    submissionBlock
+  ].join("\n");
+}
+async function waitForAgent(agentId, maxWaitMs = 3e5) {
+  const { getAgent: getAgent3 } = await Promise.resolve().then(() => (init_store(), store_exports));
+  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const db3 = getDb2();
+  const deadline = Date.now() + maxWaitMs;
+  const terminalStatuses = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+  while (Date.now() < deadline) {
+    const agent = getAgent3(db3, agentId);
+    if (!agent) {
+      return { resultSummary: null, tokenInput: 0, tokenOutput: 0, status: "not_found" };
+    }
+    if (terminalStatuses.has(agent.status)) {
+      return {
+        resultSummary: agent.resultSummary,
+        tokenInput: agent.tokenInput,
+        tokenOutput: agent.tokenOutput,
+        status: agent.status
+      };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+  return { resultSummary: null, tokenInput: 0, tokenOutput: 0, status: "timeout" };
+}
+function checkConvergence(submissions) {
+  const wordSets = [...submissions.values()].map((text) => {
+    const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3);
+    return new Set(words);
+  });
+  if (wordSets.length < 2) return true;
+  for (let i = 0; i < wordSets.length; i++) {
+    for (let j = i + 1; j < wordSets.length; j++) {
+      const a = wordSets[i];
+      const b = wordSets[j];
+      const intersection = new Set([...a].filter((w) => b.has(w)));
+      const union = /* @__PURE__ */ new Set([...a, ...b]);
+      if (union.size === 0) continue;
+      const overlap = intersection.size / union.size;
+      if (overlap < 0.6) return false;
+    }
+  }
+  return true;
+}
+async function executeCouncil(chatId, participants, question, onProgress) {
+  const { spawnSubAgent: spawnSubAgent2 } = await Promise.resolve().then(() => (init_orchestrator(), orchestrator_exports));
+  const startTime = Date.now();
+  const rounds = [];
+  const totalTokens = { input: 0, output: 0 };
+  let lastAnonymized = [];
+  for (let round = 1; round <= COUNCIL_MAX_ROUNDS; round++) {
+    onProgress?.(`Round ${round}/${COUNCIL_MAX_ROUNDS}: spawning ${participants.length} agents...`);
+    const prompt = buildRoundPrompt(question, round, round > 1 ? lastAnonymized : void 0);
+    const submissions = /* @__PURE__ */ new Map();
+    const spawnPromises = participants.map(async (p) => {
+      const key = `${p.backend}:${p.model}`;
+      const { agentId } = await spawnSubAgent2(chatId, {
+        runner: p.backend,
+        task: prompt,
+        name: `council-${p.label}-r${round}`,
+        model: p.model,
+        permMode: "readonly",
+        role: "worker"
+      });
+      return { key, agentId };
+    });
+    const spawned = await Promise.all(spawnPromises);
+    const resultPromises = spawned.map(async ({ key, agentId }) => {
+      const result = await waitForAgent(agentId);
+      totalTokens.input += result.tokenInput;
+      totalTokens.output += result.tokenOutput;
+      if (result.resultSummary) {
+        submissions.set(key, result.resultSummary);
+      } else {
+        submissions.set(key, "(No response)");
+      }
+    });
+    await Promise.all(resultPromises);
+    rounds.push({ roundNumber: round, submissions });
+    lastAnonymized = anonymizeSubmissions(submissions);
+    onProgress?.(`Round ${round} complete: ${submissions.size} responses collected.`);
+    if (round >= 2 && checkConvergence(submissions)) {
+      log(`[council] Convergence reached after round ${round}`);
+      onProgress?.(`Convergence reached after round ${round}.`);
+      break;
+    }
+  }
+  const finalParts = lastAnonymized.map(
+    (s) => `### ${s.label}
+${s.response}`
+  );
+  const finalAnswer = finalParts.join("\n\n");
+  const elapsedMs = Date.now() - startTime;
+  return {
+    rounds,
+    finalAnswer,
+    participants,
+    totalTokens,
+    elapsedMs
+  };
+}
+var init_executor = __esm({
+  "src/council/executor.ts"() {
+    "use strict";
+    init_types4();
+    init_log();
+  }
+});
+
 // src/router.ts
 var router_exports = {};
 __export(router_exports, {
@@ -23432,6 +24236,10 @@ __export(router_exports, {
 });
 async function handleMessage(msg, channel) {
   const { chatId } = msg;
+  if (msg.threadId) {
+    const { withThread: withThread2 } = await Promise.resolve().then(() => (init_thread_wrapper(), thread_wrapper_exports));
+    channel = withThread2(channel, msg.threadId);
+  }
   if (msg.messageId && typeof channel.reactToMessage === "function" && msg.type !== "text" && msg.type !== "command") {
     channel.reactToMessage(chatId, msg.messageId, pickReactionEmoji(msg)).catch(() => {
     });
@@ -23509,6 +24317,20 @@ async function handleText(msg, channel) {
     return;
   }
   const model2 = resolveModel(chatId);
+  let autoRouted = false;
+  let effectiveModel = model2;
+  let effectiveThinking;
+  if (model2 === "auto") {
+    const { classifyComplexity: classifyComplexity2 } = await Promise.resolve().then(() => (init_complexity(), complexity_exports));
+    const { resolveAutoRoute: resolveAutoRoute2 } = await Promise.resolve().then(() => (init_auto_route(), auto_route_exports));
+    const adapter = getAdapterForChat(chatId);
+    const tier = classifyComplexity2(text);
+    const route = resolveAutoRoute2(tier, adapter);
+    effectiveModel = route.model;
+    effectiveThinking = route.thinkingLevel;
+    autoRouted = true;
+    log(`[router] Auto-route: "${text.slice(0, 40)}..." -> ${tier} -> model=${effectiveModel}, thinking=${effectiveThinking}`);
+  }
   const backendId = settings.getBackend() ?? "claude";
   const limitMsg = checkBackendLimits(backendId);
   if (limitMsg) {
@@ -23632,6 +24454,43 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
       return;
     }
   }
+  {
+    const { hasPendingCouncil: hasPendingCouncil2, getCouncilState: getCouncilState2, setCouncilQuestion: setCouncilQuestion2, cancelCouncil: cancelCouncil2 } = await Promise.resolve().then(() => (init_wizard2(), wizard_exports));
+    if (hasPendingCouncil2(chatId)) {
+      const state = getCouncilState2(chatId);
+      if (state?.step === "question") {
+        const result = setCouncilQuestion2(chatId, text);
+        if (result.error) {
+          await channel.sendText(chatId, result.error, { parseMode: "plain" });
+          return;
+        }
+        const participants = [...state.selected.values()];
+        const question = state.question;
+        cancelCouncil2(chatId);
+        await channel.sendText(chatId, `\u{1F3DB}\uFE0F Council convened \u2014 ${participants.length} models, up to 3 rounds.
+
+Debating: "${question.slice(0, 100)}${question.length > 100 ? "\u2026" : ""}"`, { parseMode: "plain" });
+        await channel.sendTyping?.(chatId);
+        try {
+          const { executeCouncil: executeCouncil2 } = await Promise.resolve().then(() => (init_executor(), executor_exports));
+          const councilResult = await executeCouncil2(
+            chatId,
+            participants,
+            question,
+            (msg2) => {
+              channel.sendText(chatId, msg2, { parseMode: "plain" }).catch(() => {
+              });
+            }
+          );
+          await sendResponse(chatId, channel, councilResult.finalAnswer, msg.messageId);
+        } catch (e) {
+          const errMsg = e.message ?? String(e);
+          await channel.sendText(chatId, `Council failed: ${errMsg}`, { parseMode: "plain" });
+        }
+        return;
+      }
+    }
+  }
   if (isChatBusy(chatId) && !bypassBusyCheck.delete(chatId)) {
     if (typeof channel.sendKeyboard === "function") {
       pendingInterrupts.set(chatId, { msg, channel });
@@ -23741,6 +24600,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
       liveStatus = ls.liveStatus;
       const baseCb = tVerbose !== "off" ? ls.toolCb : void 0;
       tToolCb = async (toolName, input, result) => {
+        if (result === void 0) toolUseCount++;
         if (baseCb) await baseCb(toolName, input, result);
         if (sessionLog) {
           if (result === void 0) {
@@ -23756,6 +24616,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
       }
     } else if (sessionLog) {
       tToolCb = async (toolName, input, result) => {
+        if (result === void 0) toolUseCount++;
         if (result === void 0) {
           sessionLog.logToolStart(toolName, input);
         } else {
@@ -23763,15 +24624,18 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         }
       };
     }
+    let toolUseCount = 0;
     const sigT0 = Date.now();
     const response = await askAgent(chatId, cleanText || text, {
       cwd: settings.getCwd(),
-      model: model2,
+      model: effectiveModel,
       permMode: tMode,
       onToolAction: tToolCb,
       bootstrapTier,
       maxTurns,
       agentMode: effectiveAgentMode,
+      ...effectiveThinking ? { thinkingLevel: effectiveThinking } : {},
+      chatContext: { chatTitle: msg.chatTitle, threadId: msg.threadId },
       onThinking: liveStatus || sessionLog ? (chunk) => {
         if (liveStatus) liveStatus.addThinking(chunk);
         if (sessionLog) sessionLog.logThinking(chunk);
@@ -23821,7 +24685,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
     const sigEnabled = settings.getModelSignature();
     if (sigEnabled === "on" && responseText && !responseText.startsWith("(No response")) {
       const adapter2 = getAdapterForChat(chatId);
-      const modelId = response.resolvedModel ?? model2 ?? adapter2.defaultModel;
+      const modelId = response.resolvedModel ?? effectiveModel ?? adapter2.defaultModel;
       const thinking2 = settings.getThinkingLevel() || "auto";
       const shortModel = formatModelShort(modelId);
       let slotTag = "";
@@ -23876,6 +24740,42 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
     } catch (e) {
       log(`[reflection] Signal detection error: ${e}`);
     }
+    try {
+      const { getSkillSuggestionsEnabled: getSkillSuggestionsEnabled2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+      if (intent === "agentic" && toolUseCount > 0 && getSkillSuggestionsEnabled2(chatId)) {
+        const { isSkillWorthy: isSkillWorthy2 } = await Promise.resolve().then(() => (init_auto_create(), auto_create_exports));
+        const signals = {
+          toolUseCount,
+          tokenOutput: response.usage?.output ?? 0,
+          elapsedMs,
+          userMessage: cleanText || text
+        };
+        if (isSkillWorthy2(signals) && typeof channel.sendKeyboard === "function") {
+          const { storePendingDraft: storePendingDraft2 } = await Promise.resolve().then(() => (init_auto_create(), auto_create_exports));
+          const taskSummary = (cleanText || text).slice(0, 120) + ((cleanText || text).length > 120 ? "\u2026" : "");
+          storePendingDraft2(chatId, {
+            name: "",
+            content: "",
+            userMessage: cleanText || text,
+            assistantResponse: response.text
+          });
+          await channel.sendKeyboard(
+            chatId,
+            `\u{1F4A1} That looked like a reusable workflow:
+
+"${taskSummary}"
+
+Want me to extract it as a reusable skill? (${toolUseCount} tools used, ${elapsedSec}s)`,
+            [[
+              { label: "\u2705 Extract Skill", data: "skill:extract", style: "success" },
+              { label: "\u2715 No thanks", data: "skill:discard" }
+            ]]
+          );
+        }
+      }
+    } catch (e) {
+      log(`[auto-skill] Evaluation error: ${e}`);
+    }
   } catch (err) {
     error("[router] Error:", err);
     const errMsg = errorMessage(err);
@@ -24368,7 +25268,7 @@ var init_cron = __esm({
 });
 
 // src/agents/runners/wrap-backend.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function buildMcpCommands(backendId) {
   const exe = backendId === BACKEND.CURSOR ? "agent" : backendId;
   return {
@@ -24462,7 +25362,7 @@ function wrapBackendAdapter(adapter) {
       const configPath = writeMcpConfigFile(server);
       return ["--mcp-config", configPath];
     },
-    getSkillPath: () => join25(SKILLS_PATH, `agent-${adapter.id}.md`)
+    getSkillPath: () => join26(SKILLS_PATH, `agent-${adapter.id}.md`)
   };
 }
 var BACKEND_CAPABILITIES;
@@ -24515,7 +25415,7 @@ var init_wrap_backend = __esm({
 
 // src/agents/runners/config-loader.ts
 import { readFileSync as readFileSync14, readdirSync as readdirSync14, existsSync as existsSync23, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 function resolveExecutable2(config2) {
   if (existsSync23(config2.executable)) return config2.executable;
@@ -24651,7 +25551,7 @@ function configToRunner(config2) {
     prepareMcpInjection() {
       return [];
     },
-    getSkillPath: () => join26(SKILLS_PATH, `agent-${config2.id}.md`)
+    getSkillPath: () => join27(SKILLS_PATH, `agent-${config2.id}.md`)
   };
 }
 function loadRunnerConfig(filePath) {
@@ -24671,7 +25571,7 @@ function loadAllRunnerConfigs() {
   const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   const configs = [];
   for (const file of files) {
-    const config2 = loadRunnerConfig(join26(RUNNERS_PATH, file));
+    const config2 = loadRunnerConfig(join27(RUNNERS_PATH, file));
     if (config2) configs.push(config2);
   }
   return configs;
@@ -24701,7 +25601,7 @@ function watchRunnerConfigs(onChange) {
   }
   const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   for (const file of files) {
-    const fullPath = join26(RUNNERS_PATH, file);
+    const fullPath = join27(RUNNERS_PATH, file);
     if (watchedFiles.has(fullPath)) continue;
     watchedFiles.add(fullPath);
     watchFile(fullPath, { interval: 5e3 }, () => {
@@ -25321,9 +26221,11 @@ var init_telegram2 = __esm({
       async stop() {
         await this.bot.stop();
       }
-      async sendTyping(chatId) {
+      async sendTyping(chatId, threadId) {
         try {
-          await this.bot.api.sendChatAction(numericChatId(chatId), "typing");
+          await this.bot.api.sendChatAction(numericChatId(chatId), "typing", {
+            ...threadId ? { message_thread_id: threadId } : {}
+          });
         } catch {
         }
       }
@@ -25370,21 +26272,23 @@ var init_telegram2 = __esm({
           }
         }
       }
-      async sendVoice(chatId, audioBuffer, fileName) {
+      async sendVoice(chatId, audioBuffer, fileName, threadId) {
         await withRetry(
           "sendVoice",
           () => this.bot.api.sendVoice(
             numericChatId(chatId),
-            new InputFile(audioBuffer, fileName ?? "response.ogg")
+            new InputFile(audioBuffer, fileName ?? "response.ogg"),
+            { ...threadId ? { message_thread_id: threadId } : {} }
           )
         );
       }
-      async sendFile(chatId, buffer, fileName) {
+      async sendFile(chatId, buffer, fileName, _mimeType, threadId) {
         await withRetry(
           "sendFile",
           () => this.bot.api.sendDocument(
             numericChatId(chatId),
-            new InputFile(buffer, fileName)
+            new InputFile(buffer, fileName),
+            { ...threadId ? { message_thread_id: threadId } : {} }
           )
         );
       }
@@ -25394,10 +26298,11 @@ var init_telegram2 = __esm({
         const response = await fetch(fileUrl);
         return Buffer.from(await response.arrayBuffer());
       }
-      async sendTextReturningId(chatId, text, parseMode) {
+      async sendTextReturningId(chatId, text, parseMode, threadId) {
         try {
           const formatted = sanitizeForTelegram(parseMode === "html" ? text : parseMode === "plain" ? text : formatForTelegram(text));
-          const opts = parseMode === "plain" ? {} : { parse_mode: "HTML" };
+          const threadOpts = threadId ? { message_thread_id: threadId } : {};
+          const opts = parseMode === "plain" ? { ...threadOpts } : { parse_mode: "HTML", ...threadOpts };
           const msg = await withRetry(
             "sendTextReturningId",
             () => this.bot.api.sendMessage(numericChatId(chatId), formatted, opts)
@@ -25485,7 +26390,7 @@ var init_telegram2 = __esm({
       onReaction(handler) {
         this.reactionHandlers.push(handler);
       }
-      async sendKeyboard(chatId, text, buttons) {
+      async sendKeyboard(chatId, text, buttons, threadId) {
         const keyboard = new InlineKeyboard();
         for (const row of buttons) {
           for (const btn of row) {
@@ -25499,12 +26404,14 @@ 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;
         const formatted = sanitizeForTelegram(formatForTelegram(safeText));
+        const threadOpts = threadId ? { message_thread_id: threadId } : {};
         try {
           const msg = await withRetry(
             "sendKeyboard",
             () => this.bot.api.sendMessage(numericChatId(chatId), formatted, {
               parse_mode: "HTML",
-              reply_markup: keyboard
+              reply_markup: keyboard,
+              ...threadOpts
             })
           );
           return msg.message_id.toString();
@@ -25519,7 +26426,8 @@ var init_telegram2 = __esm({
             const retryMsg = await withRetry(
               "sendKeyboard:plain",
               () => this.bot.api.sendMessage(numericChatId(chatId), escaped, {
-                reply_markup: keyboard
+                reply_markup: keyboard,
+                ...threadOpts
               })
             );
             return retryMsg.message_id.toString();
@@ -25532,7 +26440,7 @@ var init_telegram2 = __esm({
             if (plainText.trim()) {
               await withRetry(
                 "sendKeyboard:text-rescue",
-                () => this.bot.api.sendMessage(numericChatId(chatId), plainText, {})
+                () => this.bot.api.sendMessage(numericChatId(chatId), plainText, { ...threadOpts })
               );
             }
           } catch {
@@ -25541,7 +26449,8 @@ var init_telegram2 = __esm({
             const fallbackMsg = await withRetry(
               "sendKeyboard:fallback",
               () => this.bot.api.sendMessage(numericChatId(chatId), "\u2B06\uFE0F (see above for details)", {
-                reply_markup: keyboard
+                reply_markup: keyboard,
+                ...threadOpts
               })
             );
             return fallbackMsg.message_id.toString();
@@ -25633,6 +26542,7 @@ var init_telegram2 = __esm({
         const fwdOrigin = ctx.message?.forward_origin;
         const fwdFromChat = ctx.message?.forward_from_chat;
         const forwardedFrom = fwdOrigin?.chat?.title ?? fwdOrigin?.sender_chat?.title ?? fwdOrigin?.sender_user?.first_name ?? fwdOrigin?.sender_user_name ?? fwdFromChat?.title ?? void 0;
+        const threadId = ctx.message?.message_thread_id;
         if (ctx.message?.voice) {
           return {
             chatId,
@@ -25646,6 +26556,7 @@ var init_telegram2 = __esm({
             chatTitle,
             replyToText,
             forwardedFrom,
+            threadId,
             raw: ctx
           };
         }
@@ -25665,6 +26576,7 @@ var init_telegram2 = __esm({
             chatTitle,
             replyToText,
             forwardedFrom,
+            threadId,
             raw: ctx
           };
         }
@@ -25682,6 +26594,7 @@ var init_telegram2 = __esm({
             chatTitle,
             replyToText,
             forwardedFrom,
+            threadId,
             raw: ctx
           };
         }
@@ -25708,6 +26621,7 @@ var init_telegram2 = __esm({
             chatTitle,
             replyToText,
             forwardedFrom,
+            threadId,
             raw: ctx
           };
         }
@@ -25729,6 +26643,7 @@ var init_telegram2 = __esm({
               chatTitle,
               replyToText,
               forwardedFrom,
+              threadId,
               raw: ctx
             };
           }
@@ -25742,6 +26657,7 @@ var init_telegram2 = __esm({
             chatTitle,
             replyToText,
             forwardedFrom,
+            threadId,
             raw: ctx
           };
         }
@@ -25753,8 +26669,8 @@ var init_telegram2 = __esm({
 
 // src/skills/bootstrap.ts
 import { existsSync as existsSync24 } from "fs";
-import { readdir as readdir5, readFile as readFile8, writeFile as writeFile4, copyFile } from "fs/promises";
-import { join as join27, dirname as dirname5 } from "path";
+import { readdir as readdir5, readFile as readFile8, writeFile as writeFile5, copyFile } from "fs/promises";
+import { join as join28, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function copyAgentManifestSkills() {
   if (!existsSync24(PKG_SKILLS)) return;
@@ -25762,8 +26678,8 @@ async function copyAgentManifestSkills() {
     const entries = await readdir5(PKG_SKILLS, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.startsWith("agent-") || !entry.name.endsWith(".md")) continue;
-      const src = join27(PKG_SKILLS, entry.name);
-      const dest = join27(SKILLS_PATH, entry.name);
+      const src = join28(PKG_SKILLS, entry.name);
+      const dest = join28(SKILLS_PATH, entry.name);
       if (existsSync24(dest)) continue;
       await copyFile(src, dest);
       log(`[skills] Bootstrapped ${entry.name} to ${SKILLS_PATH}`);
@@ -25774,7 +26690,7 @@ async function copyAgentManifestSkills() {
 }
 async function bootstrapSkills() {
   await copyAgentManifestSkills();
-  const usmDir = join27(SKILLS_PATH, USM_DIR_NAME);
+  const usmDir = join28(SKILLS_PATH, USM_DIR_NAME);
   if (existsSync24(usmDir)) return;
   try {
     const entries = await readdir5(SKILLS_PATH);
@@ -25798,7 +26714,7 @@ async function bootstrapSkills() {
   }
 }
 async function patchUsmForCcClaw(usmDir) {
-  const skillPath = join27(usmDir, "SKILL.md");
+  const skillPath = join28(usmDir, "SKILL.md");
   if (!existsSync24(skillPath)) return;
   try {
     let content = await readFile8(skillPath, "utf-8");
@@ -25827,7 +26743,7 @@ async function patchUsmForCcClaw(usmDir) {
       }
     }
     if (patched) {
-      await writeFile4(skillPath, content, "utf-8");
+      await writeFile5(skillPath, content, "utf-8");
       log("[skills] Patched USM SKILL.md with CC-Claw support");
     }
   } catch (err) {
@@ -25844,8 +26760,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 = join27(dirname5(fileURLToPath2(import.meta.url)), "..", "..");
-    PKG_SKILLS = join27(PKG_ROOT, "skills");
+    PKG_ROOT = join28(dirname5(fileURLToPath2(import.meta.url)), "..", "..");
+    PKG_SKILLS = join28(PKG_ROOT, "skills");
   }
 });
 
@@ -26068,7 +26984,7 @@ __export(ai_skill_exports, {
   installAiSkill: () => installAiSkill
 });
 import { existsSync as existsSync25, writeFileSync as writeFileSync8, mkdirSync as mkdirSync11 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { homedir as homedir9 } from "os";
 function generateAiSkill() {
   const version = VERSION;
@@ -26488,8 +27404,8 @@ function installAiSkill() {
   const failed = [];
   for (const [backend2, dirs] of Object.entries(BACKEND_SKILL_DIRS2)) {
     for (const dir of dirs) {
-      const skillDir = join28(dir, "cc-claw-cli");
-      const skillPath = join28(skillDir, "SKILL.md");
+      const skillDir = join29(dir, "cc-claw-cli");
+      const skillPath = join29(skillDir, "SKILL.md");
       try {
         mkdirSync11(skillDir, { recursive: true });
         writeFileSync8(skillPath, skill, "utf-8");
@@ -26508,11 +27424,11 @@ var init_ai_skill = __esm({
     init_paths();
     init_version();
     BACKEND_SKILL_DIRS2 = {
-      "cc-claw": [join28(homedir9(), ".cc-claw", "workspace", "skills")],
-      claude: [join28(homedir9(), ".claude", "skills")],
-      gemini: [join28(homedir9(), ".gemini", "skills")],
-      codex: [join28(homedir9(), ".agents", "skills")],
-      cursor: [join28(homedir9(), ".cursor", "skills"), join28(homedir9(), ".cursor", "skills-cursor")]
+      "cc-claw": [join29(homedir9(), ".cc-claw", "workspace", "skills")],
+      claude: [join29(homedir9(), ".claude", "skills")],
+      gemini: [join29(homedir9(), ".gemini", "skills")],
+      codex: [join29(homedir9(), ".agents", "skills")],
+      cursor: [join29(homedir9(), ".cursor", "skills"), join29(homedir9(), ".cursor", "skills-cursor")]
     };
   }
 });
@@ -26523,17 +27439,17 @@ __export(index_exports, {
   main: () => main
 });
 import { mkdirSync as mkdirSync12, existsSync as existsSync26, renameSync as renameSync2, statSync as statSync8, readFileSync as readFileSync16 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import dotenv from "dotenv";
 function migrateLayout() {
   const moves = [
-    [join29(CC_CLAW_HOME, "cc-claw.db"), join29(DATA_PATH, "cc-claw.db")],
-    [join29(CC_CLAW_HOME, "cc-claw.db-shm"), join29(DATA_PATH, "cc-claw.db-shm")],
-    [join29(CC_CLAW_HOME, "cc-claw.db-wal"), join29(DATA_PATH, "cc-claw.db-wal")],
-    [join29(CC_CLAW_HOME, "cc-claw.log"), join29(LOGS_PATH, "cc-claw.log")],
-    [join29(CC_CLAW_HOME, "cc-claw.log.1"), join29(LOGS_PATH, "cc-claw.log.1")],
-    [join29(CC_CLAW_HOME, "cc-claw.error.log"), join29(LOGS_PATH, "cc-claw.error.log")],
-    [join29(CC_CLAW_HOME, "cc-claw.error.log.1"), join29(LOGS_PATH, "cc-claw.error.log.1")]
+    [join30(CC_CLAW_HOME, "cc-claw.db"), join30(DATA_PATH, "cc-claw.db")],
+    [join30(CC_CLAW_HOME, "cc-claw.db-shm"), join30(DATA_PATH, "cc-claw.db-shm")],
+    [join30(CC_CLAW_HOME, "cc-claw.db-wal"), join30(DATA_PATH, "cc-claw.db-wal")],
+    [join30(CC_CLAW_HOME, "cc-claw.log"), join30(LOGS_PATH, "cc-claw.log")],
+    [join30(CC_CLAW_HOME, "cc-claw.log.1"), join30(LOGS_PATH, "cc-claw.log.1")],
+    [join30(CC_CLAW_HOME, "cc-claw.error.log"), join30(LOGS_PATH, "cc-claw.error.log")],
+    [join30(CC_CLAW_HOME, "cc-claw.error.log.1"), join30(LOGS_PATH, "cc-claw.error.log.1")]
   ];
   for (const [from, to] of moves) {
     if (existsSync26(from) && !existsSync26(to)) {
@@ -26713,10 +27629,10 @@ async function main() {
   try {
     const { generateAiSkill: generateAiSkill2 } = await Promise.resolve().then(() => (init_ai_skill(), ai_skill_exports));
     const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync19 } = await import("fs");
-    const { join: join35 } = await import("path");
-    const skillDir = join35(SKILLS_PATH, "cc-claw-cli");
+    const { join: join36 } = await import("path");
+    const skillDir = join36(SKILLS_PATH, "cc-claw-cli");
     mkdirSync19(skillDir, { recursive: true });
-    writeFileSync13(join35(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
+    writeFileSync13(join36(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
     log("[cc-claw] AI skill updated");
   } catch {
   }
@@ -26947,7 +27863,7 @@ __export(service_exports2, {
 import { existsSync as existsSync28, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8 } from "fs";
 import { execFileSync as execFileSync3, execSync as execSync4 } from "child_process";
 import { homedir as homedir10, platform } from "os";
-import { join as join30, dirname as dirname6 } from "path";
+import { join as join31, 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;");
 }
@@ -26965,14 +27881,14 @@ function getPathDirs() {
   const home = homedir10();
   const dirs = /* @__PURE__ */ new Set([
     nodeBin,
-    join30(home, ".local", "bin"),
+    join31(home, ".local", "bin"),
     "/usr/local/bin",
     "/usr/bin",
     "/bin"
   ]);
   try {
     const prefix = execSync4("npm config get prefix", { encoding: "utf-8" }).trim();
-    if (prefix) dirs.add(join30(prefix, "bin"));
+    if (prefix) dirs.add(join31(prefix, "bin"));
   } catch {
   }
   return [...dirs].join(":");
@@ -27155,7 +28071,7 @@ function statusLinux() {
   }
 }
 function installService() {
-  if (!existsSync28(join30(CC_CLAW_HOME, ".env"))) {
+  if (!existsSync28(join31(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;
@@ -27184,9 +28100,9 @@ var init_service2 = __esm({
     "use strict";
     init_paths();
     PLIST_LABEL = "com.cc-claw";
-    PLIST_PATH = join30(homedir10(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-    SYSTEMD_DIR = join30(homedir10(), ".config", "systemd", "user");
-    UNIT_PATH = join30(SYSTEMD_DIR, "cc-claw.service");
+    PLIST_PATH = join31(homedir10(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+    SYSTEMD_DIR = join31(homedir10(), ".config", "systemd", "user");
+    UNIT_PATH = join31(SYSTEMD_DIR, "cc-claw.service");
   }
 });
 
@@ -28086,12 +29002,14 @@ __export(gemini_exports, {
   geminiDisable: () => geminiDisable,
   geminiEnable: () => geminiEnable,
   geminiList: () => geminiList,
+  geminiRelogin: () => geminiRelogin,
   geminiRemove: () => geminiRemove,
+  geminiRename: () => geminiRename,
   geminiReorder: () => geminiReorder,
   geminiRotation: () => geminiRotation
 });
 import { existsSync as existsSync33, mkdirSync as mkdirSync14, writeFileSync as writeFileSync10, readFileSync as readFileSync23, chmodSync } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import { createInterface as createInterface8 } from "readline";
 function requireDb() {
   if (!existsSync33(DB_PATH)) {
@@ -28119,7 +29037,7 @@ async function resolveSlotId(idOrLabel) {
 function resolveOAuthEmail(configHome) {
   if (!configHome) return null;
   try {
-    const accountsPath = join31(configHome, ".gemini", "google_accounts.json");
+    const accountsPath = join32(configHome, ".gemini", "google_accounts.json");
     if (!existsSync33(accountsPath)) return null;
     const accounts = JSON.parse(readFileSync23(accountsPath, "utf-8"));
     return accounts.active || null;
@@ -28203,14 +29121,14 @@ async function geminiAddKey(globalOpts, opts) {
 }
 async function geminiAddAccount(globalOpts, opts) {
   await requireWriteDb();
-  const slotsDir = join31(CC_CLAW_HOME, "gemini-slots");
+  const slotsDir = join32(CC_CLAW_HOME, "gemini-slots");
   if (!existsSync33(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
   const { addGeminiSlot: addGeminiSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const tempId = Date.now();
-  const slotDir = join31(slotsDir, `slot-${tempId}`);
+  const slotDir = join32(slotsDir, `slot-${tempId}`);
   mkdirSync14(slotDir, { recursive: true, mode: 448 });
-  mkdirSync14(join31(slotDir, ".gemini"), { recursive: true });
-  writeFileSync10(join31(slotDir, ".gemini", "settings.json"), JSON.stringify({
+  mkdirSync14(join32(slotDir, ".gemini"), { recursive: true });
+  writeFileSync10(join32(slotDir, ".gemini", "settings.json"), JSON.stringify({
     security: { auth: { selectedType: "oauth-personal" } }
   }, null, 2));
   console.log("");
@@ -28227,7 +29145,7 @@ async function geminiAddAccount(globalOpts, opts) {
     });
   } catch {
   }
-  const oauthPath = join31(slotDir, ".gemini", "oauth_creds.json");
+  const oauthPath = join32(slotDir, ".gemini", "oauth_creds.json");
   if (!existsSync33(oauthPath)) {
     console.log(error2("\n  No OAuth credentials found. Sign-in may have failed."));
     console.log("  The slot directory is preserved at: " + slotDir);
@@ -28236,7 +29154,7 @@ async function geminiAddAccount(globalOpts, opts) {
   }
   let accountEmail = "unknown";
   try {
-    const accounts = JSON.parse(__require("fs").readFileSync(join31(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(__require("fs").readFileSync(join32(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
     accountEmail = accounts.active || accountEmail;
   } catch {
   }
@@ -28311,6 +29229,92 @@ async function geminiReorder(globalOpts, idOrLabel, priority) {
     () => success(`Slot "${idOrLabel}" (#${slotId}) priority set to ${priority}`)
   );
 }
+async function geminiRename(globalOpts, idOrLabel, newLabel) {
+  await requireWriteDb();
+  const slotId = await resolveSlotId(idOrLabel);
+  if (!slotId) {
+    outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+    return;
+  }
+  const { renameGeminiSlot: renameGeminiSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const updated = renameGeminiSlot2(slotId, newLabel);
+  if (updated) {
+    output({ id: slotId, label: newLabel }, () => success(`Renamed slot #${slotId} \u2192 "${newLabel}"`));
+  } else {
+    outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+  }
+}
+async function geminiRelogin(globalOpts, idOrLabel) {
+  await requireWriteDb();
+  const slotId = await resolveSlotId(idOrLabel);
+  if (!slotId) {
+    outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+    return;
+  }
+  const { getGeminiSlots: getGeminiSlots2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const slot = getGeminiSlots2().find((s) => s.id === slotId);
+  if (!slot) {
+    outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+    return;
+  }
+  if (slot.slotType !== "oauth") {
+    outputError("NOT_OAUTH", `Slot "${idOrLabel}" is an API key slot \u2014 re-login only works for OAuth slots.`);
+    return;
+  }
+  if (!slot.configHome) {
+    outputError("NO_CONFIG", `Slot "${idOrLabel}" has no config directory \u2014 cannot re-login.`);
+    return;
+  }
+  const settingsPath = join32(slot.configHome, ".gemini", "settings.json");
+  if (!existsSync33(settingsPath)) {
+    mkdirSync14(join32(slot.configHome, ".gemini"), { recursive: true });
+    writeFileSync10(settingsPath, JSON.stringify({
+      security: { auth: { selectedType: "oauth-personal" } }
+    }, null, 2));
+  }
+  console.log("");
+  console.log(`  Re-authenticating Gemini slot "${slot.label || `#${slot.id}`}"...`);
+  console.log("  Sign in with the same Google account when prompted.");
+  console.log("  After sign-in, type /quit to return here.");
+  console.log("");
+  const { execSync: execSync6 } = await import("child_process");
+  try {
+    execSync6(`gemini`, {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        GEMINI_CLI_HOME: slot.configHome,
+        GEMINI_API_KEY: void 0,
+        GOOGLE_API_KEY: void 0
+      },
+      cwd: slot.configHome
+    });
+  } catch {
+  }
+  const oauthPath = join32(slot.configHome, ".gemini", "oauth_creds.json");
+  if (!existsSync33(oauthPath)) {
+    console.log(error2("\n  Re-login failed \u2014 no OAuth credentials found."));
+    console.log(`  Try again: cc-claw gemini re-login ${idOrLabel}
+`);
+    process.exit(1);
+  }
+  const { setGeminiSlotEnabled: setGeminiSlotEnabled2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  setGeminiSlotEnabled2(slotId, true);
+  let accountEmail = slot.label;
+  try {
+    const accounts = JSON.parse(readFileSync23(join32(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
+    if (accounts.active) accountEmail = accounts.active;
+  } catch {
+  }
+  if (accountEmail && accountEmail !== slot.label) {
+    const { renameGeminiSlot: renameGeminiSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    renameGeminiSlot2(slotId, accountEmail);
+  }
+  output(
+    { id: slotId, label: accountEmail, refreshed: true },
+    () => success(`Re-authenticated Gemini slot #${slotId} (${accountEmail})`)
+  );
+}
 async function geminiRotation(globalOpts, mode) {
   const validModes = ["off", "all", "accounts", "keys"];
   if (!mode) {
@@ -28351,12 +29355,14 @@ __export(backend_cmd_factory_exports, {
   makeEnable: () => makeEnable,
   makeList: () => makeList,
   makeRefresh: () => makeRefresh,
+  makeRelogin: () => makeRelogin,
   makeRemove: () => makeRemove,
+  makeRename: () => makeRename,
   makeReorder: () => makeReorder,
   registerBackendSlotCommands: () => registerBackendSlotCommands
 });
 import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync24 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 import { createInterface as createInterface9 } from "readline";
 function requireDb2() {
   if (!existsSync34(DB_PATH)) {
@@ -28448,10 +29454,10 @@ function makeAddAccount(backend2, displayName) {
       process.exit(1);
     }
     await requireWriteDb2();
-    const slotsDir = join32(CC_CLAW_HOME, config2.slotsSubdir);
+    const slotsDir = join33(CC_CLAW_HOME, config2.slotsSubdir);
     if (!existsSync34(slotsDir)) mkdirSync15(slotsDir, { recursive: true });
     const tempId = Date.now();
-    const slotDir = join32(slotsDir, `slot-${tempId}`);
+    const slotDir = join33(slotsDir, `slot-${tempId}`);
     mkdirSync15(slotDir, { recursive: true, mode: 448 });
     if (config2.preSetup) config2.preSetup(slotDir);
     console.log("");
@@ -28562,6 +29568,88 @@ function makeReorder(backend2, _displayName) {
     );
   };
 }
+function makeRename(backend2, _displayName) {
+  return async function rename(_globalOpts, idOrLabel, newLabel) {
+    await requireWriteDb2();
+    const slotId = await resolveSlotId2(backend2, idOrLabel);
+    if (!slotId) {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+      return;
+    }
+    const { renameBackendSlot: renameBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const updated = renameBackendSlot2(slotId, newLabel);
+    if (updated) {
+      output({ id: slotId, label: newLabel }, () => success(`Renamed slot #${slotId} \u2192 "${newLabel}"`));
+    } else {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+    }
+  };
+}
+function makeRelogin(backend2, displayName) {
+  return async function relogin(_globalOpts, idOrLabel) {
+    const config2 = ADD_ACCOUNT_CONFIGS[backend2];
+    if (!config2) {
+      outputError("UNSUPPORTED", `re-login is not supported for ${displayName}. Only OAuth/subscription slots can be re-logged.`);
+      process.exit(1);
+    }
+    await requireWriteDb2();
+    const slotId = await resolveSlotId2(backend2, idOrLabel);
+    if (!slotId) {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+      return;
+    }
+    const { getBackendSlots: getBackendSlots2, reenableBackendSlot: reenableBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const slot = getBackendSlots2(backend2).find((s) => s.id === slotId);
+    if (!slot) {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+      return;
+    }
+    if (slot.slotType !== "oauth") {
+      outputError("NOT_OAUTH", `Slot "${idOrLabel}" is an API key slot \u2014 re-login only works for OAuth/subscription slots.`);
+      return;
+    }
+    if (!slot.configHome) {
+      outputError("NO_CONFIG", `Slot "${idOrLabel}" has no config directory \u2014 cannot re-login.`);
+      return;
+    }
+    if (config2.preSetup) config2.preSetup(slot.configHome);
+    console.log("");
+    console.log(`  Re-authenticating ${displayName} slot "${slot.label || `#${slot.id}`}"...`);
+    console.log(`  Sign in with the same account when the browser opens.`);
+    console.log("");
+    const { execSync: execSync6 } = await import("child_process");
+    const loginEnv = {
+      ...process.env,
+      [config2.envKey]: config2.envValue(slot.configHome),
+      ...config2.envOverrides
+    };
+    try {
+      execSync6(config2.loginCommand.join(" "), {
+        stdio: "inherit",
+        env: loginEnv,
+        cwd: slot.configHome
+      });
+    } catch {
+    }
+    if (!config2.verifyCredentials(slot.configHome)) {
+      console.log(error2(`
+  Re-login failed \u2014 no credentials found.`));
+      console.log(`  Try again: cc-claw ${backend2} re-login ${idOrLabel}
+`);
+      process.exit(1);
+    }
+    reenableBackendSlot2(slotId);
+    const newLabel = config2.extractLabel(slot.configHome);
+    if (newLabel && newLabel !== slot.label && newLabel !== "subscription") {
+      const { renameBackendSlot: renameBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+      renameBackendSlot2(slotId, newLabel);
+    }
+    output(
+      { id: slotId, label: newLabel || slot.label, refreshed: true },
+      () => success(`Re-authenticated ${displayName} slot #${slotId} (${newLabel || slot.label})`)
+    );
+  };
+}
 function makeRefresh(backend2, displayName) {
   return async function refresh(_globalOpts) {
     await requireWriteDb2();
@@ -28620,11 +29708,11 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { ANTHROPIC_API_KEY: void 0 },
         preSetup: (slotDir) => {
-          mkdirSync15(join32(slotDir, ".claude"), { recursive: true });
+          mkdirSync15(join33(slotDir, ".claude"), { recursive: true });
         },
         verifyCredentials: (slotDir) => {
-          const claudeJson = join32(slotDir, ".claude.json");
-          const claudeJsonNested = join32(slotDir, ".claude", ".claude.json");
+          const claudeJson = join33(slotDir, ".claude.json");
+          const claudeJsonNested = join33(slotDir, ".claude", ".claude.json");
           if (existsSync34(claudeJson)) {
             try {
               const data = JSON.parse(readFileSync24(claudeJson, "utf-8"));
@@ -28656,7 +29744,7 @@ var init_backend_cmd_factory = __esm({
           } catch {
           }
           try {
-            const claudeJson = join32(slotDir, ".claude.json");
+            const claudeJson = join33(slotDir, ".claude.json");
             if (existsSync34(claudeJson)) {
               const data = JSON.parse(readFileSync24(claudeJson, "utf-8"));
               if (data.oauthAccount?.emailAddress) return data.oauthAccount.emailAddress;
@@ -28673,11 +29761,11 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { OPENAI_API_KEY: void 0 },
         verifyCredentials: (slotDir) => {
-          return existsSync34(join32(slotDir, "auth.json"));
+          return existsSync34(join33(slotDir, "auth.json"));
         },
         extractLabel: (slotDir) => {
           try {
-            const authData = JSON.parse(readFileSync24(join32(slotDir, "auth.json"), "utf-8"));
+            const authData = JSON.parse(readFileSync24(join33(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;
@@ -31041,7 +32129,7 @@ __export(completion_exports, {
   completionCommand: () => completionCommand
 });
 import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync17 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 import { homedir as homedir11 } from "os";
 async function completionCommand(opts) {
   const shell = opts.shell ?? detectShell();
@@ -31057,10 +32145,10 @@ async function completionCommand(opts) {
     process.exit(1);
   }
   if (opts.install) {
-    const dir = join33(homedir11(), ".config", "cc-claw", "completions");
+    const dir = join34(homedir11(), ".config", "cc-claw", "completions");
     mkdirSync17(dir, { recursive: true });
     const filename = shell === "zsh" ? "_cc-claw" : shell === "fish" ? "cc-claw.fish" : "cc-claw.bash";
-    const filepath = join33(dir, filename);
+    const filepath = join34(dir, filename);
     writeFileSync11(filepath, script, "utf-8");
     console.log(`\u2713 Completion script written to ${filepath}
 `);
@@ -31710,7 +32798,7 @@ var setup_exports = {};
 import { existsSync as existsSync55, writeFileSync as writeFileSync12, readFileSync as readFileSync27, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
 import { createInterface as createInterface11 } from "readline";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function divider2() {
   console.log(dim("\u2500".repeat(55)));
 }
@@ -31798,7 +32886,7 @@ async function setup() {
       if (match) env[match[1].trim()] = match[2].trim();
     }
   }
-  const cwdDb = join34(process.cwd(), "cc-claw.db");
+  const cwdDb = join35(process.cwd(), "cc-claw.db");
   if (existsSync55(cwdDb) && !existsSync55(DB_PATH)) {
     const { size } = statSync12(cwdDb);
     console.log(yellow(`  Found existing database at ${cwdDb} (${(size / 1024).toFixed(0)}KB)`));
@@ -32188,6 +33276,14 @@ gemini.command("reorder <id-or-label> <priority>").description("Set slot priorit
   const { geminiReorder: geminiReorder2 } = await Promise.resolve().then(() => (init_gemini2(), gemini_exports));
   await geminiReorder2(program.opts(), id, priority);
 });
+gemini.command("rename <id-or-label> <new-label>").description("Rename a credential slot").action(async (id, newLabel) => {
+  const { geminiRename: geminiRename2 } = await Promise.resolve().then(() => (init_gemini2(), gemini_exports));
+  await geminiRename2(program.opts(), id, newLabel);
+});
+gemini.command("re-login <id-or-label>").alias("relogin").description("Re-authenticate an OAuth slot (refreshes expired token in-place)").action(async (id) => {
+  const { geminiRelogin: geminiRelogin2 } = await Promise.resolve().then(() => (init_gemini2(), gemini_exports));
+  await geminiRelogin2(program.opts(), id);
+});
 gemini.command("rotation [mode]").description("Get or set rotation mode (off, all, accounts, keys)").action(async (mode) => {
   const { geminiRotation: geminiRotation2 } = await Promise.resolve().then(() => (init_gemini2(), gemini_exports));
   await geminiRotation2(program.opts(), mode);
@@ -32226,6 +33322,14 @@ function registerUnifiedSlotCommands(parentCmd, backendId, displayName) {
     const { makeRefresh: makeRefresh2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
     await makeRefresh2(backendId, displayName)(program.opts());
   });
+  cmd.command("rename <id-or-label> <new-label>").description("Rename a credential slot").action(async (id, newLabel) => {
+    const { makeRename: makeRename2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeRename2(backendId, displayName)(program.opts(), id, newLabel);
+  });
+  cmd.command("re-login <id-or-label>").alias("relogin").description("Re-authenticate an OAuth/subscription slot (refreshes expired token in-place)").action(async (id) => {
+    const { makeRelogin: makeRelogin2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeRelogin2(backendId, displayName)(program.opts(), id);
+  });
 }
 registerUnifiedSlotCommands(program, "claude", "Claude");
 registerUnifiedSlotCommands(program, "codex", "Codex");
@@ -32653,6 +33757,11 @@ optimize.command("skills").description("List available CC-Claw skills").action(a
   const { optimizeSkills: optimizeSkills2 } = await Promise.resolve().then(() => (init_optimize2(), optimize_exports));
   await optimizeSkills2();
 });
+program.command("council").alias("debate").description("Multi-model council debate (Telegram interactive)").action(async () => {
+  console.log("Council is an interactive Telegram command.");
+  console.log("Use /council in Telegram to start a multi-model debate wizard.");
+  console.log("Select 2+ models, pose a question, and they debate anonymously for up to 3 rounds.");
+});
 program.command("start", { hidden: true }).description("Run the bot in the foreground (use 'service start' for background daemon)").action(async () => {
   await Promise.resolve().then(() => (init_index(), index_exports));
 });