cc-claw 0.20.11 → 0.20.13

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.20.11" : (() => {
+    VERSION = true ? "0.20.13" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -827,8 +827,8 @@ function cleanupBackupFiles(ccClawHome, retentionDays = 7) {
         if (!file.includes(".bak.")) continue;
         const fullPath = join3(dir, file);
         try {
-          const stat3 = statSync(fullPath);
-          if (stat3.mtimeMs < cutoffMs) unlinkSync(fullPath);
+          const stat4 = statSync(fullPath);
+          if (stat4.mtimeMs < cutoffMs) unlinkSync(fullPath);
         } catch {
         }
       }
@@ -2722,7 +2722,7 @@ function getSkillSuggestionsEnabled(chatId) {
   const row = getDb().prepare(
     "SELECT value FROM chat_skill_suggestions WHERE chat_id = ?"
   ).get(SKILL_SUGGESTIONS_GLOBAL_KEY);
-  return (row?.value ?? 1) === 1;
+  return (row?.value ?? 0) === 1;
 }
 function setSkillSuggestionsEnabled(chatIdOrEnabled, enabled) {
   const value = typeof chatIdOrEnabled === "boolean" ? chatIdOrEnabled : enabled;
@@ -7501,8 +7501,21 @@ var init_loader = __esm({
 function appendTextChunk(accumulated, chunk) {
   if (!accumulated) return chunk;
   if (!chunk) return accumulated;
-  const needsSpace = !/\s$/.test(accumulated) && !/^\s/.test(chunk);
-  return needsSpace ? accumulated + " " + chunk : accumulated + chunk;
+  if (/\s$/.test(accumulated) || /^\s/.test(chunk)) {
+    return accumulated + chunk;
+  }
+  const tailChar = accumulated[accumulated.length - 1];
+  if ("/:@.=?&#%-_~+".includes(tailChar)) {
+    return accumulated + chunk;
+  }
+  const headChar = chunk[0];
+  if (`/:@.=?&#%-_~+,;)]}>'"`.includes(headChar)) {
+    return accumulated + chunk;
+  }
+  if (/\d$/.test(accumulated) && /^\d/.test(chunk)) {
+    return accumulated + chunk;
+  }
+  return accumulated + " " + chunk;
 }
 var init_text_utils = __esm({
   "src/text-utils.ts"() {
@@ -9471,8 +9484,8 @@ function pruneAgentLogs() {
     mkdirSync6(AGENTS_PATH, { recursive: true });
     const files = readdirSync6(AGENTS_PATH).filter((f) => f.endsWith(".log")).map((f) => {
       const fullPath = join11(AGENTS_PATH, f);
-      const stat3 = statSync4(fullPath);
-      return { path: fullPath, mtime: stat3.mtimeMs, size: stat3.size };
+      const stat4 = statSync4(fullPath);
+      return { path: fullPath, mtime: stat4.mtimeMs, size: stat4.size };
     });
     const now = Date.now();
     const remaining = files.filter((f) => {
@@ -12720,12 +12733,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: join36 } = await import("path");
+        const { join: join37 } = 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 = join36(home, "identity/SOUL.md");
-        const userPath = join36(home, "identity/USER.md");
+        const soulPath = join37(home, "identity/SOUL.md");
+        const userPath = join37(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);
@@ -12777,6 +12790,346 @@ var init_evolve = __esm({
   }
 });
 
+// src/dashboard/routes/files.ts
+import { createWriteStream, existsSync as existsSync14 } from "fs";
+import { readdir, stat, unlink, mkdir } from "fs/promises";
+import { join as join14, extname } from "path";
+function getUploadHtml(token, host) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>CC-Claw File Upload</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: -apple-system, system-ui, sans-serif; background: #0d1117; color: #e6edf3; display: flex; align-items: center; justify-content: center; min-height: 100vh; }
+    .container { max-width: 520px; width: 100%; padding: 24px; }
+    h1 { font-size: 1.4rem; margin-bottom: 8px; }
+    .subtitle { color: #8b949e; margin-bottom: 24px; font-size: 0.9rem; }
+    .drop-zone { border: 2px dashed #30363d; border-radius: 12px; padding: 48px 24px; text-align: center; cursor: pointer; transition: all 0.2s; }
+    .drop-zone:hover, .drop-zone.drag-over { border-color: #58a6ff; background: rgba(88,166,255,0.05); }
+    .drop-zone p { color: #8b949e; margin-top: 8px; font-size: 0.85rem; }
+    .drop-zone .icon { font-size: 2.5rem; margin-bottom: 8px; }
+    input[type="file"] { display: none; }
+    .progress-wrap { margin-top: 16px; display: none; }
+    .progress-bar { height: 6px; background: #21262d; border-radius: 3px; overflow: hidden; }
+    .progress-fill { height: 100%; width: 0%; background: #58a6ff; transition: width 0.3s; }
+    .progress-text { font-size: 0.8rem; color: #8b949e; margin-top: 6px; text-align: center; }
+    .result { margin-top: 16px; padding: 12px; border-radius: 8px; font-size: 0.85rem; display: none; }
+    .result.success { background: rgba(63,185,80,0.1); border: 1px solid #238636; color: #3fb950; }
+    .result.error { background: rgba(248,81,73,0.1); border: 1px solid #da3633; color: #f85149; }
+    .file-link { color: #58a6ff; text-decoration: none; word-break: break-all; }
+    .file-link:hover { text-decoration: underline; }
+    .files-list { margin-top: 24px; }
+    .files-list h3 { font-size: 0.9rem; color: #8b949e; margin-bottom: 8px; }
+    .files-list ul { list-style: none; }
+    .files-list li { padding: 6px 0; border-bottom: 1px solid #21262d; font-size: 0.85rem; }
+    .files-list li:last-child { border: none; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>CC-Claw Upload</h1>
+    <p class="subtitle">Upload files for CC-Claw to use. Max 200MB.</p>
+    <div class="drop-zone" id="dropZone">
+      <div class="icon">\u{1F4C1}</div>
+      <strong>Drop file here or click to browse</strong>
+      <p>Videos, images, documents \u2014 anything the bot needs</p>
+    </div>
+    <input type="file" id="fileInput">
+    <div class="progress-wrap" id="progressWrap">
+      <div class="progress-bar"><div class="progress-fill" id="progressFill"></div></div>
+      <div class="progress-text" id="progressText">Uploading...</div>
+    </div>
+    <div class="result" id="result"></div>
+    <div class="files-list" id="filesList"></div>
+  </div>
+  <script>
+    const TOKEN = "${token}";
+    const HOST = "${host}";
+    const dropZone = document.getElementById("dropZone");
+    const fileInput = document.getElementById("fileInput");
+    const progressWrap = document.getElementById("progressWrap");
+    const progressFill = document.getElementById("progressFill");
+    const progressText = document.getElementById("progressText");
+    const resultDiv = document.getElementById("result");
+
+    dropZone.addEventListener("click", () => fileInput.click());
+    dropZone.addEventListener("dragover", e => { e.preventDefault(); dropZone.classList.add("drag-over"); });
+    dropZone.addEventListener("dragleave", () => dropZone.classList.remove("drag-over"));
+    dropZone.addEventListener("drop", e => { e.preventDefault(); dropZone.classList.remove("drag-over"); if (e.dataTransfer.files.length) uploadFile(e.dataTransfer.files[0]); });
+    fileInput.addEventListener("change", () => { if (fileInput.files.length) uploadFile(fileInput.files[0]); });
+
+    function uploadFile(file) {
+      if (file.size > 200 * 1024 * 1024) { showResult("File too large (max 200MB)", true); return; }
+      progressWrap.style.display = "block";
+      resultDiv.style.display = "none";
+      progressFill.style.width = "0%";
+      progressText.textContent = "Uploading " + file.name + "...";
+
+      const xhr = new XMLHttpRequest();
+      xhr.open("POST", HOST + "/upload");
+      xhr.setRequestHeader("Authorization", "Bearer " + TOKEN);
+
+      xhr.upload.addEventListener("progress", e => {
+        if (e.lengthComputable) {
+          const pct = Math.round(e.loaded / e.total * 100);
+          progressFill.style.width = pct + "%";
+          progressText.textContent = pct + "% \u2014 " + (e.loaded / 1024 / 1024).toFixed(1) + " / " + (e.total / 1024 / 1024).toFixed(1) + " MB";
+        }
+      });
+      xhr.addEventListener("load", () => {
+        progressWrap.style.display = "none";
+        try {
+          const resp = JSON.parse(xhr.responseText);
+          if (resp.ok && resp.data) {
+            const link = HOST + "/files/" + resp.data.filename;
+            showResult('Uploaded: <a class="file-link" href="' + link + '" target="_blank">' + resp.data.filename + '</a><br>Size: ' + resp.data.sizeMB + ' MB<br>Path: ' + resp.data.path, false);
+            loadFileList();
+          } else {
+            showResult(resp.error || "Upload failed", true);
+          }
+        } catch { showResult("Upload failed: " + xhr.statusText, true); }
+      });
+      xhr.addEventListener("error", () => { progressWrap.style.display = "none"; showResult("Connection failed", true); });
+      xhr.addEventListener("abort", () => { progressWrap.style.display = "none"; showResult("Upload cancelled", true); });
+
+      const formData = new FormData();
+      formData.append("file", file);
+      xhr.send(formData);
+    }
+
+    function showResult(html, isError) {
+      resultDiv.innerHTML = html;
+      resultDiv.className = "result " + (isError ? "error" : "success");
+      resultDiv.style.display = "block";
+    }
+
+    function loadFileList() {
+      fetch(HOST + "/files", { headers: { "Authorization": "Bearer " + TOKEN } })
+        .then(r => r.json()).then(resp => {
+          if (!resp.ok || !resp.data?.length) { document.getElementById("filesList").innerHTML = ""; return; }
+          const items = resp.data.slice(0, 20).map(f =>
+            '<li><a class="file-link" href="' + HOST + '/files/' + f.name + '" target="_blank">' + f.name + '</a> (' + f.sizeMB + ' MB)</li>'
+          ).join("");
+          document.getElementById("filesList").innerHTML = "<h3>Recent Files</h3><ul>" + items + "</ul>";
+        }).catch(() => {});
+    }
+    loadFileList();
+  </script>
+</body>
+</html>`;
+}
+function handleUploadPage(req, res, _url, token) {
+  const host = `http://${req.headers.host ?? "localhost:3141"}`;
+  htmlResponse(res, getUploadHtml(token, host));
+}
+async function handleUpload(req, res) {
+  const contentType = req.headers["content-type"] ?? "";
+  const boundaryMatch = contentType.match(/boundary=(.+?)(?:;|$)/);
+  if (!boundaryMatch) {
+    return jsonResponse(res, { ok: false, error: "Missing multipart boundary" }, 400);
+  }
+  const boundary = boundaryMatch[1];
+  const contentLength = parseInt(req.headers["content-length"] ?? "0", 10);
+  if (contentLength > MAX_UPLOAD_BYTES) {
+    return jsonResponse(res, { ok: false, error: `File too large (max ${MAX_UPLOAD_BYTES / 1024 / 1024}MB)` }, 413);
+  }
+  await mkdir(INCOMING_PATH, { recursive: true });
+  try {
+    const result = await parseMultipartUpload(req, boundary);
+    if (!result) {
+      return jsonResponse(res, { ok: false, error: "No file found in upload" }, 400);
+    }
+    const ext = extname(result.originalName).toLowerCase();
+    if (BLOCKED_EXTENSIONS.has(ext)) {
+      try {
+        await unlink(result.path);
+      } catch {
+      }
+      return jsonResponse(res, { ok: false, error: `File type ${ext} is not allowed` }, 400);
+    }
+    const fileInfo = await stat(result.path);
+    const sizeMB = (fileInfo.size / 1024 / 1024).toFixed(1);
+    log(`[upload] Saved ${result.filename} (${sizeMB} MB) from ${result.originalName}`);
+    return jsonResponse(res, {
+      ok: true,
+      data: {
+        filename: result.filename,
+        originalName: result.originalName,
+        path: result.path,
+        sizeMB
+      }
+    });
+  } catch (err) {
+    warn(`[upload] Failed: ${err.message}`);
+    return jsonResponse(res, { ok: false, error: `Upload failed: ${err.message}` }, 500);
+  }
+}
+async function handleFileList(req, res) {
+  await mkdir(INCOMING_PATH, { recursive: true });
+  try {
+    const entries = await readdir(INCOMING_PATH);
+    const files = [];
+    for (const name of entries) {
+      try {
+        const s = await stat(join14(INCOMING_PATH, name));
+        if (!s.isFile()) continue;
+        files.push({
+          name,
+          sizeMB: (s.size / 1024 / 1024).toFixed(1),
+          modified: s.mtime.toISOString()
+        });
+      } catch {
+        continue;
+      }
+    }
+    files.sort((a, b) => b.modified.localeCompare(a.modified));
+    return jsonResponse(res, { ok: true, data: files });
+  } catch {
+    return jsonResponse(res, { ok: true, data: [] });
+  }
+}
+async function handleFileServe(req, res, url) {
+  const filename = decodeURIComponent(url.pathname.slice("/files/".length));
+  if (filename.includes("..") || filename.includes("/") || filename.includes("\\")) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("Invalid filename");
+    return;
+  }
+  const filePath = join14(INCOMING_PATH, filename);
+  if (!existsSync14(filePath)) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("File not found");
+    return;
+  }
+  const fileInfo = await stat(filePath);
+  const ext = extname(filename).toLowerCase();
+  const mimeTypes = {
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+    ".webm": "video/webm",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg"
+  };
+  const mime = mimeTypes[ext] ?? "application/octet-stream";
+  res.writeHead(200, {
+    "Content-Type": mime,
+    "Content-Length": fileInfo.size,
+    "Content-Disposition": `inline; filename="${filename}"`,
+    "Cache-Control": "public, max-age=3600"
+  });
+  const { createReadStream: createReadStream2 } = await import("fs");
+  const stream = createReadStream2(filePath);
+  stream.pipe(res);
+  stream.on("error", () => {
+    if (!res.headersSent) {
+      res.writeHead(500);
+    }
+    res.end();
+  });
+}
+function parseMultipartUpload(req, boundary) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let totalBytes = 0;
+    let cleanupPath = null;
+    req.on("data", (chunk) => {
+      totalBytes += chunk.length;
+      if (totalBytes > MAX_UPLOAD_BYTES) {
+        req.destroy(new Error(`Upload exceeds ${MAX_UPLOAD_BYTES / 1024 / 1024}MB limit`));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("error", async (err) => {
+      if (cleanupPath) {
+        try {
+          await unlink(cleanupPath);
+        } catch {
+        }
+      }
+      reject(err);
+    });
+    req.on("end", async () => {
+      try {
+        const body = Buffer.concat(chunks);
+        const boundaryBuf = Buffer.from(`--${boundary}`);
+        const headerEnd = body.indexOf(Buffer.from("\r\n\r\n"));
+        if (headerEnd === -1) return resolve(null);
+        const headerSection = body.subarray(0, headerEnd).toString("utf-8");
+        const nameMatch = headerSection.match(/filename="(.+?)"/);
+        if (!nameMatch) return resolve(null);
+        const originalName = nameMatch[1].replace(/[^\w.-]/g, "_");
+        const ext = extname(originalName) || ".bin";
+        const filename = `upload-${Date.now()}${ext}`;
+        const filePath = join14(INCOMING_PATH, filename);
+        cleanupPath = filePath;
+        const fileStart = headerEnd + 4;
+        const closingBoundary = Buffer.from(`\r
+--${boundary}`);
+        let fileEnd = body.indexOf(closingBoundary, fileStart);
+        if (fileEnd === -1) fileEnd = body.length;
+        const fileContent = body.subarray(fileStart, fileEnd);
+        const ws = createWriteStream(filePath);
+        await new Promise((res, rej) => {
+          ws.write(fileContent, (err) => {
+            if (err) return rej(err);
+            ws.end(res);
+          });
+        });
+        cleanupPath = null;
+        resolve({ filename, originalName, path: filePath });
+      } catch (err) {
+        if (cleanupPath) {
+          try {
+            await unlink(cleanupPath);
+          } catch {
+          }
+        }
+        reject(err);
+      }
+    });
+  });
+}
+var INCOMING_PATH, MAX_UPLOAD_BYTES, BLOCKED_EXTENSIONS;
+var init_files = __esm({
+  "src/dashboard/routes/files.ts"() {
+    "use strict";
+    init_paths();
+    init_middleware();
+    init_log();
+    INCOMING_PATH = join14(MEDIA_PATH, "incoming");
+    MAX_UPLOAD_BYTES = 200 * 1024 * 1024;
+    BLOCKED_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".exe",
+      ".bat",
+      ".cmd",
+      ".com",
+      ".scr",
+      ".pif",
+      ".msi",
+      ".sh",
+      ".bash",
+      ".csh",
+      ".ksh",
+      ".ps1",
+      ".psm1"
+    ]);
+  }
+});
+
 // src/dashboard/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -12876,6 +13229,16 @@ function startDashboard() {
     if (url.pathname === "/api/evolve/off" && req.method === "POST") return handleEvolveOff(req, res, url);
     if (url.pathname === "/api/evolve/model" && req.method === "POST") return handleEvolveModel(req, res, url);
     if (url.pathname === "/api/evolve/settings" && req.method === "POST") return handleEvolveSettings(req, res, url);
+    if (url.pathname === "/upload" && req.method === "GET") return handleUploadPage(req, res, url, getDashboardToken());
+    if (url.pathname === "/upload" && req.method === "POST") {
+      await handleUpload(req, res);
+      return;
+    }
+    if (url.pathname === "/files" && req.method === "GET") return handleFileList(req, res);
+    if (url.pathname.startsWith("/files/") && req.method === "GET") {
+      await handleFileServe(req, res, url);
+      return;
+    }
     if (url.pathname === "/" || url.pathname === "/index.html") {
       return htmlResponse(res, DASHBOARD_HTML.replace("__TOKEN__", getDashboardToken()));
     }
@@ -12891,7 +13254,8 @@ function startDashboard() {
       console.error(`[api] Server error:`, err);
     }
   });
-  server.listen(PORT, "127.0.0.1");
+  const bindHost = process.env.CC_CLAW_DASHBOARD_HOST ?? "0.0.0.0";
+  server.listen(PORT, bindHost);
   persistToken();
   return server;
 }
@@ -12908,6 +13272,7 @@ var init_server = __esm({
     init_scheduler();
     init_config();
     init_evolve();
+    init_files();
   }
 });
 
@@ -13317,9 +13682,10 @@ 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 stdinMode = adapter.id === "codex" ? "pipe" : "ignore";
     const proc = spawn6(config2.executable, finalArgs, {
       env,
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: [stdinMode, "pipe", "pipe"],
       detached: true,
       ...config2.cwd ? { cwd: config2.cwd } : {}
     });
@@ -14696,6 +15062,7 @@ var init_telegram_throttle = __esm({
             try {
               const result = await this.execWithRetry(item.label, item.fn);
               this.recordSend(item.chatId);
+              this.pauseStartedAt = 0;
               item.resolve(result);
             } catch (err) {
               if (is429(err)) {
@@ -14742,7 +15109,6 @@ var init_telegram_throttle = __esm({
         this.chatsPendingNotification.clear();
         if (!this.resumeNotifier) return;
         const pausedSec = this.pauseStartedAt > 0 ? Math.round((Date.now() - this.pauseStartedAt) / 1e3) : 0;
-        this.pauseStartedAt = 0;
         for (const chatId of chats2) {
           const queuedForChat = this.queue.filter((q) => q.chatId === chatId).length;
           if (queuedForChat === 0) continue;
@@ -14753,14 +15119,13 @@ var init_telegram_throttle = __esm({
             if (is429(err)) {
               const retrySec = err.parameters?.retry_after ?? 10;
               this.pausedUntil = Date.now() + retrySec * 1e3;
-              if (this.pauseStartedAt === 0) this.pauseStartedAt = Date.now();
-              for (const c of chats2) this.chatsPendingNotification.add(c);
-              warn(`[throttle] Resume notification hit 429, re-pausing for ${retrySec}s`);
+              warn(`[throttle] Resume notification hit 429, re-pausing for ${retrySec}s (skipping further notifications)`);
               return;
             }
             warn(`[throttle] Resume notification failed for chat ${chatId}: ${err}`);
           }
         }
+        this.pauseStartedAt = 0;
       }
       // ── Helpers ─────────────────────────────────────────────────────────
       recordSend(chatId) {
@@ -14779,10 +15144,10 @@ var init_telegram_throttle = __esm({
 });
 
 // src/health/checks.ts
-import { existsSync as existsSync14, statSync as statSync6, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync15, statSync as statSync6, readFileSync as readFileSync8 } from "fs";
 import { execFileSync, execSync as execSync3 } from "child_process";
 function getRecentErrors() {
-  if (!existsSync14(ERROR_LOG_PATH)) return null;
+  if (!existsSync15(ERROR_LOG_PATH)) return null;
   const logContent = readFileSync8(ERROR_LOG_PATH, "utf-8");
   const allLines = logContent.split("\n").filter(Boolean).slice(-500);
   const last24h = Date.now() - 864e5;
@@ -14804,7 +15169,7 @@ function getRecentErrors() {
 }
 function checkDatabase() {
   const checks = [];
-  if (existsSync14(DB_PATH)) {
+  if (existsSync15(DB_PATH)) {
     const size = statSync6(DB_PATH).size;
     checks.push({ name: "Database", status: "ok", message: `${(size / 1024).toFixed(0)}KB` });
   } else {
@@ -14836,18 +15201,18 @@ function checkErrorLog() {
     return checks;
   }
   if (errors.rate429.length > 10) {
-    checks.push({ name: "Rate limits", status: "error", message: `${errors.rate429.length} rate-limit (429) errors in last 24h` });
+    checks.push({ name: "Rate limits", status: "error", message: `${errors.rate429.length} rate-limit (429) errors in last 24h`, fix: "cc-claw doctor errors  \u2014 view details;  cc-claw doctor --fix  \u2014 clear log" });
   } else if (errors.rate429.length > 0) {
-    checks.push({ name: "Rate limits", status: "warning", message: `${errors.rate429.length} rate-limit errors in last 24h` });
+    checks.push({ name: "Rate limits", status: "warning", message: `${errors.rate429.length} rate-limit errors in last 24h`, fix: "cc-claw doctor errors  \u2014 view details;  cc-claw doctor --fix  \u2014 clear log" });
   }
   if (errors.contentSilence.length > 0) {
-    checks.push({ name: "Content silence", status: "warning", message: `${errors.contentSilence.length} silence timeout(s) in last 24h` });
+    checks.push({ name: "Content silence", status: "warning", message: `${errors.contentSilence.length} silence timeout(s) in last 24h`, fix: "cc-claw doctor errors  \u2014 view details;  cc-claw service restart  \u2014 if persistent" });
   }
   if (errors.spawnTimeout.length > 0) {
-    checks.push({ name: "Spawn timeouts", status: "warning", message: `${errors.spawnTimeout.length} backend timeout(s) in last 24h` });
+    checks.push({ name: "Spawn timeouts", status: "warning", message: `${errors.spawnTimeout.length} backend timeout(s) in last 24h`, fix: "cc-claw doctor errors  \u2014 view details;  cc-claw status  \u2014 check backends" });
   }
   if (errors.other.length > 0) {
-    checks.push({ name: "Other errors", status: "warning", message: `${errors.other.length} error(s) in last 24h` });
+    checks.push({ name: "Other errors", status: "warning", message: `${errors.other.length} error(s) in last 24h`, fix: "cc-claw doctor errors  \u2014 view details;  cc-claw doctor --fix  \u2014 clear log" });
   }
   if (checks.length === 0) {
     checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
@@ -15012,8 +15377,8 @@ __export(heartbeat_exports, {
   stopHeartbeatForChat: () => stopHeartbeatForChat,
   updateHeartbeatConfig: () => updateHeartbeatConfig
 });
-import { readFileSync as readFileSync9, existsSync as existsSync15 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync16 } from "fs";
+import { join as join15 } from "path";
 function findHeartbeatJob() {
   try {
     const { getDb: getDb2 } = (init_store5(), __toCommonJS(store_exports5));
@@ -15144,7 +15509,7 @@ ${healthText}`);
     sections.push(`[Active Watches \u2014 execute these checks using your tools]
 ${watchLines.join("\n")}`);
   }
-  if (existsSync15(HEARTBEAT_MD_PATH)) {
+  if (existsSync16(HEARTBEAT_MD_PATH)) {
     try {
       const custom = readFileSync9(HEARTBEAT_MD_PATH, "utf-8").trim();
       if (custom) {
@@ -15206,7 +15571,7 @@ var init_heartbeat2 = __esm({
     init_store5();
     init_checks();
     init_log();
-    HEARTBEAT_MD_PATH = join14(WORKSPACE_PATH, "HEARTBEAT.md");
+    HEARTBEAT_MD_PATH = join15(WORKSPACE_PATH, "HEARTBEAT.md");
     HEARTBEAT_OK = "HEARTBEAT_OK";
     HEARTBEAT_JOB_TYPE = "heartbeat";
     DEFAULT_INTERVAL_MS = 30 * 60 * 1e3;
@@ -15215,8 +15580,8 @@ var init_heartbeat2 = __esm({
 });
 
 // src/bootstrap/profile.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync16 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync17 } from "fs";
+import { join as join16 } from "path";
 function hasActiveProfile(chatId) {
   return activeProfiles.has(chatId);
 }
@@ -15345,7 +15710,7 @@ function extractUserUpdates(text) {
   return { cleanText, updates };
 }
 function appendToUserProfile(key, value) {
-  if (!existsSync16(USER_PATH2)) return;
+  if (!existsSync17(USER_PATH2)) return;
   const content = readFileSync10(USER_PATH2, "utf-8");
   const line = `- **${key}**: ${value}`;
   if (content.includes(line)) return;
@@ -15361,7 +15726,7 @@ var init_profile = __esm({
     "use strict";
     init_paths();
     init_log();
-    USER_PATH2 = join15(IDENTITY_PATH, "USER.md");
+    USER_PATH2 = join16(IDENTITY_PATH, "USER.md");
     activeProfiles = /* @__PURE__ */ new Map();
   }
 });
@@ -16658,8 +17023,8 @@ __export(session_log_exports2, {
   startSessionLogCleanupTimer: () => startSessionLogCleanupTimer,
   tailSessionLog: () => tailSessionLog
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync9, unlinkSync as unlinkSync6, statSync as statSync7, createReadStream } from "fs";
-import { join as join16, basename } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync9, unlinkSync as unlinkSync6, statSync as statSync7, createReadStream } from "fs";
+import { join as join17, basename } from "path";
 import { createInterface as createInterface6 } from "readline";
 function getRetentionDays() {
   const env = process.env.SESSION_LOG_RETENTION_DAYS;
@@ -16671,13 +17036,13 @@ function getRetentionDays() {
 }
 function cleanupSessionLogs(retentionDays) {
   const days = retentionDays ?? getRetentionDays();
-  if (!existsSync17(SESSION_LOGS_PATH)) return 0;
+  if (!existsSync18(SESSION_LOGS_PATH)) return 0;
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
   let cleaned = 0;
   try {
     for (const file of readdirSync9(SESSION_LOGS_PATH)) {
       if (!file.startsWith("session-") || !file.endsWith(".log")) continue;
-      const filePath = join16(SESSION_LOGS_PATH, file);
+      const filePath = join17(SESSION_LOGS_PATH, file);
       try {
         const { mtimeMs } = statSync7(filePath);
         if (mtimeMs < cutoff) {
@@ -16703,21 +17068,21 @@ function startSessionLogCleanupTimer() {
   return timer;
 }
 function listSessionLogs() {
-  if (!existsSync17(SESSION_LOGS_PATH)) return [];
+  if (!existsSync18(SESSION_LOGS_PATH)) return [];
   const logs = [];
   for (const file of readdirSync9(SESSION_LOGS_PATH)) {
     if (!file.startsWith("session-") || !file.endsWith(".log")) continue;
-    const filePath = join16(SESSION_LOGS_PATH, file);
+    const filePath = join17(SESSION_LOGS_PATH, file);
     try {
-      const stat3 = statSync7(filePath);
+      const stat4 = statSync7(filePath);
       const match = file.match(/^session-(.+?)-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})\.log$/);
       logs.push({
         filename: file,
         filePath,
         chatId: match?.[1] ?? "unknown",
         timestamp: match?.[2]?.replace(/-/g, (m, i) => i > 9 ? ":" : m) ?? "unknown",
-        sizeBytes: stat3.size,
-        modifiedAt: stat3.mtime
+        sizeBytes: stat4.size,
+        modifiedAt: stat4.mtime
       });
     } catch {
     }
@@ -16726,7 +17091,7 @@ function listSessionLogs() {
   return logs;
 }
 async function* tailSessionLog(filePath, lines = 50) {
-  if (!existsSync17(filePath)) {
+  if (!existsSync18(filePath)) {
     yield `File not found: ${filePath}`;
     return;
   }
@@ -16754,12 +17119,12 @@ var init_session_log2 = __esm({
       constructor(chatId, backend2, model2) {
         this.backend = backend2;
         this.model = model2;
-        if (!existsSync17(SESSION_LOGS_PATH)) {
+        if (!existsSync18(SESSION_LOGS_PATH)) {
           mkdirSync8(SESSION_LOGS_PATH, { recursive: true });
         }
         const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
         const sanitizedChatId = chatId.replace(/[^a-zA-Z0-9_-]/g, "_");
-        this.filePath = join16(SESSION_LOGS_PATH, `session-${sanitizedChatId}-${ts2}.log`);
+        this.filePath = join17(SESSION_LOGS_PATH, `session-${sanitizedChatId}-${ts2}.log`);
         const header2 = [
           "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
           `CC-Claw Agent Session \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -17162,7 +17527,7 @@ var init_gate = __esm({
 // src/voice/stt.ts
 import crypto from "crypto";
 import { execFile as execFile2, execFileSync as execFileSync2 } from "child_process";
-import { readFile as readFile2, unlink } from "fs/promises";
+import { readFile as readFile2, unlink as unlink2 } from "fs/promises";
 import { promisify as promisify2 } from "util";
 function ensureFfmpeg() {
   if (ffmpegAvailable === true) return;
@@ -17316,10 +17681,10 @@ async function mp3ToOgg(mp3Buffer) {
   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) => {
+  unlink2(tmpMp3).catch((err) => {
     error("[tts] cleanup failed:", err);
   });
-  unlink(tmpOgg).catch((err) => {
+  unlink2(tmpOgg).catch((err) => {
     error("[tts] cleanup failed:", err);
   });
   return oggBuffer;
@@ -17332,10 +17697,10 @@ async function macOsTts(text, voice2 = "Samantha") {
   await execFileAsync2("say", ["-v", voice2, "-o", tmpAiff, text]);
   await execFileAsync2("ffmpeg", ["-y", "-i", tmpAiff, "-c:a", "libopus", "-b:a", "64k", tmpOgg]);
   const oggBuffer = await readFile2(tmpOgg);
-  unlink(tmpAiff).catch((err) => {
+  unlink2(tmpAiff).catch((err) => {
     error("[tts] cleanup failed:", err);
   });
-  unlink(tmpOgg).catch((err) => {
+  unlink2(tmpOgg).catch((err) => {
     error("[tts] cleanup failed:", err);
   });
   return oggBuffer;
@@ -17367,9 +17732,9 @@ var init_stt = __esm({
 });
 
 // src/media/image-gen.ts
-import { mkdirSync as mkdirSync9, existsSync as existsSync18, unlink as unlink2, readdir, stat } from "fs";
+import { mkdirSync as mkdirSync9, existsSync as existsSync19, unlink as unlink3, readdir as readdir2, stat as stat2 } from "fs";
 import { writeFile } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 async function generateImage(prompt) {
   const apiKey = process.env.GEMINI_API_KEY;
   if (!apiKey) {
@@ -17416,12 +17781,12 @@ async function generateImage(prompt) {
   if (!imageData) {
     throw new Error(textResponse ?? "Gemini did not generate an image. The prompt may have been filtered.");
   }
-  if (!existsSync18(IMAGE_OUTPUT_DIR)) {
+  if (!existsSync19(IMAGE_OUTPUT_DIR)) {
     mkdirSync9(IMAGE_OUTPUT_DIR, { recursive: true });
   }
   const ext = mimeType.includes("jpeg") || mimeType.includes("jpg") ? "jpg" : "png";
   const filename = `img_${Date.now()}.${ext}`;
-  const filePath = join17(IMAGE_OUTPUT_DIR, filename);
+  const filePath = join18(IMAGE_OUTPUT_DIR, filename);
   const buffer = Buffer.from(imageData, "base64");
   await writeFile(filePath, buffer);
   log(`[image-gen] Saved ${buffer.length} bytes to ${filePath}`);
@@ -17431,21 +17796,21 @@ function isImageGenAvailable() {
   return !!process.env.GEMINI_API_KEY;
 }
 function cleanupGeneratedImage(filePath) {
-  unlink2(filePath, (err) => {
+  unlink3(filePath, (err) => {
     if (err) warn(`[image-gen] cleanup failed for ${filePath}: ${err.message}`);
     else log(`[image-gen] cleaned up ${filePath}`);
   });
 }
 function pruneImageCache() {
-  readdir(IMAGE_OUTPUT_DIR, (err, files) => {
+  readdir2(IMAGE_OUTPUT_DIR, (err, files) => {
     if (err || !files) return;
-    const imageFiles = files.filter((f) => /\.(png|jpg)$/.test(f)).map((f) => join17(IMAGE_OUTPUT_DIR, f));
+    const imageFiles = files.filter((f) => /\.(png|jpg)$/.test(f)).map((f) => join18(IMAGE_OUTPUT_DIR, f));
     if (imageFiles.length === 0) return;
     const now = Date.now();
     let statsPending = imageFiles.length;
     const fileStats = [];
     for (const fp of imageFiles) {
-      stat(fp, (serr, s) => {
+      stat2(fp, (serr, s) => {
         statsPending--;
         if (!serr && s) fileStats.push({ path: fp, mtime: s.mtimeMs });
         if (statsPending === 0) {
@@ -17454,7 +17819,7 @@ function pruneImageCache() {
             (f, idx) => idx >= MAX_GENERATED_IMAGES || now - f.mtime > IMAGE_MAX_AGE_MS
           );
           for (const { path } of toDelete) {
-            unlink2(path, (derr) => {
+            unlink3(path, (derr) => {
               if (!derr) log(`[image-gen] pruned old image: ${path}`);
             });
           }
@@ -17471,8 +17836,8 @@ var init_image_gen = __esm({
     MAX_GENERATED_IMAGES = 20;
     IMAGE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
     IMAGE_MODEL = "gemini-3.1-flash-image-preview";
-    IMAGE_OUTPUT_DIR = join17(
-      process.env.CC_CLAW_HOME ?? join17(process.env.HOME ?? "/tmp", ".cc-claw"),
+    IMAGE_OUTPUT_DIR = join18(
+      process.env.CC_CLAW_HOME ?? join18(process.env.HOME ?? "/tmp", ".cc-claw"),
       "data",
       "images"
     );
@@ -17929,33 +18294,33 @@ var init_video = __esm({
 });
 
 // src/router/media.ts
-import { join as join18 } from "path";
-import { mkdir, writeFile as writeFile2, readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
+import { join as join19 } from "path";
+import { mkdir as mkdir2, writeFile as writeFile2, readdir as readdir3, stat as stat3, unlink as unlink4 } from "fs/promises";
 function getMediaRetentionMs() {
   const hours = parseInt(process.env.MEDIA_RETENTION_HOURS ?? "24", 10);
   return (isNaN(hours) || hours < 1 ? 24 : hours) * 60 * 60 * 1e3;
 }
 async function saveMedia(buffer, prefix, ext) {
-  await mkdir(MEDIA_INCOMING_PATH, { recursive: true });
+  await mkdir2(MEDIA_INCOMING_PATH, { recursive: true });
   const filename = `${prefix}-${Date.now()}.${ext}`;
-  const fullPath = join18(MEDIA_INCOMING_PATH, filename);
+  const fullPath = join19(MEDIA_INCOMING_PATH, filename);
   await writeFile2(fullPath, buffer);
   return fullPath;
 }
 async function cleanupOldMedia() {
   try {
-    await mkdir(MEDIA_INCOMING_PATH, { recursive: true });
+    await mkdir2(MEDIA_INCOMING_PATH, { recursive: true });
     const retentionMs = getMediaRetentionMs();
     const retentionHours = Math.round(retentionMs / (60 * 60 * 1e3));
-    const files = await readdir2(MEDIA_INCOMING_PATH);
+    const files = await readdir3(MEDIA_INCOMING_PATH);
     const now = Date.now();
     let removed = 0;
     for (const file of files) {
       try {
-        const filePath = join18(MEDIA_INCOMING_PATH, file);
-        const s = await stat2(filePath);
+        const filePath = join19(MEDIA_INCOMING_PATH, file);
+        const s = await stat3(filePath);
         if (now - s.mtimeMs > retentionMs) {
-          await unlink3(filePath);
+          await unlink4(filePath);
           removed++;
         }
       } catch {
@@ -18170,7 +18535,21 @@ ${content}
     await sendResponse(chatId, channel, mediaResponse, msg.messageId);
   } catch (err) {
     error("[router] Media error:", err);
-    await channel.sendText(chatId, `Error processing file: ${errorMessage(err)}`, { parseMode: "plain" });
+    const errStr = errorMessage(err);
+    if (errStr.includes("file is too big") || errStr.includes("too big")) {
+      const host = process.env.CC_CLAW_API_HOST ?? "192.168.68.10";
+      const port = process.env.CC_CLAW_PORT ?? "3141";
+      await channel.sendText(
+        chatId,
+        `File too large for Telegram (max 20MB via Bot API).
+
+Upload directly instead:
+http://${host}:${port}/upload`,
+        { parseMode: "plain" }
+      );
+    } else {
+      await channel.sendText(chatId, `Error processing file: ${errStr}`, { parseMode: "plain" });
+    }
   }
 }
 var MEDIA_INCOMING_PATH;
@@ -18188,7 +18567,7 @@ var init_media = __esm({
     init_helpers();
     init_response();
     init_live_status();
-    MEDIA_INCOMING_PATH = join18(MEDIA_PATH, "incoming");
+    MEDIA_INCOMING_PATH = join19(MEDIA_PATH, "incoming");
   }
 });
 
@@ -18500,9 +18879,9 @@ var install_exports = {};
 __export(install_exports, {
   installSkillFromGitHub: () => installSkillFromGitHub
 });
-import { mkdir as mkdir2, readdir as readdir3, readFile as readFile4, cp } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import { join as join19, basename as basename2 } from "path";
+import { mkdir as mkdir3, readdir as readdir4, readFile as readFile4, cp } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import { join as join20, basename as basename2 } from "path";
 import { execSync as execSync4 } from "child_process";
 async function installSkillFromGitHub(urlOrShorthand) {
   let repoUrl;
@@ -18513,36 +18892,36 @@ async function installSkillFromGitHub(urlOrShorthand) {
   }
   repoUrl = parsed.cloneUrl;
   subPath = parsed.subPath;
-  const tmpDir = join19("/tmp", `cc-claw-skill-${Date.now()}`);
+  const tmpDir = join20("/tmp", `cc-claw-skill-${Date.now()}`);
   try {
     log(`[skill-install] Cloning ${repoUrl} to ${tmpDir}`);
     execSync4(`git clone --depth 1 ${repoUrl} ${tmpDir}`, {
       stdio: "pipe",
       timeout: 3e4
     });
-    if (!existsSync19(join19(tmpDir, ".git"))) {
+    if (!existsSync20(join20(tmpDir, ".git"))) {
       return { success: false, error: "Git clone failed: no .git directory produced" };
     }
-    const searchRoot = subPath ? join19(tmpDir, subPath) : tmpDir;
+    const searchRoot = subPath ? join20(tmpDir, subPath) : tmpDir;
     const skillDir = await findSkillDir(searchRoot);
     if (!skillDir) {
       return { success: false, error: "No SKILL.md found in the repository." };
     }
     const skillFolderName = basename2(skillDir);
-    const destDir = join19(SKILLS_PATH, skillFolderName);
-    if (existsSync19(destDir)) {
+    const destDir = join20(SKILLS_PATH, skillFolderName);
+    if (existsSync20(destDir)) {
       log(`[skill-install] Overwriting existing skill at ${destDir}`);
     }
-    await mkdir2(destDir, { recursive: true });
+    await mkdir3(destDir, { recursive: true });
     await cp(skillDir, destDir, { recursive: true });
     let skillName = skillFolderName;
     try {
-      const content = await readFile4(join19(destDir, "SKILL.md"), "utf-8");
+      const content = await readFile4(join20(destDir, "SKILL.md"), "utf-8");
       const nameMatch = content.match(/^name:\s*(.+)$/m);
       if (nameMatch) skillName = nameMatch[1].trim().replace(/^["']|["']$/g, "");
     } catch {
       try {
-        const content = await readFile4(join19(destDir, "skill.md"), "utf-8");
+        const content = await readFile4(join20(destDir, "skill.md"), "utf-8");
         const nameMatch = content.match(/^name:\s*(.+)$/m);
         if (nameMatch) skillName = nameMatch[1].trim().replace(/^["']|["']$/g, "");
       } catch {
@@ -18577,35 +18956,35 @@ function parseGitHubUrl(input) {
 async function findSkillDir(root) {
   const candidates = ["SKILL.md", "skill.md"];
   for (const c of candidates) {
-    if (existsSync19(join19(root, c))) return root;
+    if (existsSync20(join20(root, c))) return root;
   }
   try {
-    const entries = await readdir3(root, { withFileTypes: true });
+    const entries = await readdir4(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       for (const c of candidates) {
-        if (existsSync19(join19(root, entry.name, c))) {
-          return join19(root, entry.name);
+        if (existsSync20(join20(root, entry.name, c))) {
+          return join20(root, entry.name);
         }
       }
     }
   } catch {
   }
   try {
-    const entries = await readdir3(root, { withFileTypes: true });
+    const entries = await readdir4(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       let subEntries;
       try {
-        subEntries = await readdir3(join19(root, entry.name), { withFileTypes: true });
+        subEntries = await readdir4(join20(root, entry.name), { withFileTypes: true });
       } catch {
         continue;
       }
       for (const sub of subEntries) {
         if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
         for (const c of candidates) {
-          if (existsSync19(join19(root, entry.name, sub.name, c))) {
-            return join19(root, entry.name, sub.name);
+          if (existsSync20(join20(root, entry.name, sub.name, c))) {
+            return join20(root, entry.name, sub.name);
           }
         }
       }
@@ -18629,10 +19008,10 @@ __export(discover_exports, {
   invalidateSkillCache: () => invalidateSkillCache,
   stripFrontmatter: () => stripFrontmatter2
 });
-import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir5, readFile as readFile5 } from "fs/promises";
 import { createHash } from "crypto";
 import { homedir as homedir5 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function invalidateSkillCache() {
   cachedSkills = null;
   cacheTimestamp = 0;
@@ -18650,7 +19029,7 @@ async function discoverAllSkills() {
       const rawSkills = [];
       rawSkills.push(...await scanSkillDir(SKILLS_PATH, "cc-claw"));
       for (const backendId of getAllBackendIds()) {
-        const dirs = BACKEND_SKILL_DIRS[backendId] ?? [join20(homedir5(), `.${backendId}`, "skills")];
+        const dirs = BACKEND_SKILL_DIRS[backendId] ?? [join21(homedir5(), `.${backendId}`, "skills")];
         for (const dir of dirs) {
           rawSkills.push(...await scanSkillDir(dir, backendId));
         }
@@ -18669,7 +19048,7 @@ async function scanSkillDir(skillsDir, source) {
   const results = [];
   let entries;
   try {
-    entries = await readdir4(skillsDir, { withFileTypes: true });
+    entries = await readdir5(skillsDir, { withFileTypes: true });
   } catch {
     return results;
   }
@@ -18678,7 +19057,7 @@ async function scanSkillDir(skillsDir, source) {
     let content;
     let resolvedPath;
     for (const candidate of SKILL_FILE_CANDIDATES) {
-      const p = join20(skillsDir, entry.name, candidate);
+      const p = join21(skillsDir, entry.name, candidate);
       try {
         content = await readFile5(p, "utf-8");
         resolvedPath = p;
@@ -18695,9 +19074,7 @@ async function scanSkillDir(skillsDir, source) {
       description: frontmatter.description,
       filePath: resolvedPath,
       source,
-      contentHash: hash,
-      compatibleBackends: frontmatter.compatibleBackends,
-      recommendedModel: frontmatter.recommendedModel
+      contentHash: hash
     });
   }
   return results;
@@ -18726,9 +19103,7 @@ function mergeAndDeduplicate(raw) {
         filePath: primary.filePath,
         source: primary.source,
         sources: [...new Set(allSources)],
-        contentHash: primary.contentHash,
-        compatibleBackends: primary.compatibleBackends,
-        recommendedModel: primary.recommendedModel
+        contentHash: primary.contentHash
       });
     } else {
       for (const [hash, copies] of byHash) {
@@ -18740,9 +19115,7 @@ function mergeAndDeduplicate(raw) {
           filePath: primary.filePath,
           source: primary.source,
           sources: [...new Set(allSources)],
-          contentHash: hash,
-          compatibleBackends: primary.compatibleBackends,
-          recommendedModel: primary.recommendedModel
+          contentHash: hash
         });
       }
     }
@@ -18762,13 +19135,9 @@ function parseFrontmatter2(content, fallbackName) {
   const fm = fmMatch[1];
   const nameMatch = fm.match(/^name:\s*(.+)$/m);
   const descMatch = fm.match(/^description:\s*(.+)$/m);
-  const compatMatch = fm.match(/^compatible_backends:\s*(.+)$/m);
-  const modelMatch = fm.match(/^recommended_model:\s*(.+)$/m);
   return {
     name: nameMatch?.[1]?.trim().replace(/^["']|["']$/g, "") ?? fallbackName,
-    description: descMatch?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "",
-    compatibleBackends: compatMatch ? compatMatch[1].split(",").map((s) => s.trim().toLowerCase()) : void 0,
-    recommendedModel: modelMatch?.[1]?.trim() ?? void 0
+    description: descMatch?.[1]?.trim().replace(/^["']|["']$/g, "") ?? ""
   };
 }
 function stripFrontmatter2(content) {
@@ -18782,15 +19151,15 @@ var init_discover = __esm({
     init_backends();
     SKILL_FILE_CANDIDATES = ["SKILL.md", "skill.md"];
     BACKEND_SKILL_DIRS = {
-      claude: [join20(homedir5(), ".claude", "skills")],
-      gemini: [join20(homedir5(), ".gemini", "skills")],
+      claude: [join21(homedir5(), ".claude", "skills")],
+      gemini: [join21(homedir5(), ".gemini", "skills")],
       codex: [
-        join20(homedir5(), ".agents", "skills"),
-        join20(homedir5(), ".codex", "skills")
+        join21(homedir5(), ".agents", "skills"),
+        join21(homedir5(), ".codex", "skills")
       ],
       cursor: [
-        join20(homedir5(), ".cursor", "skills"),
-        join20(homedir5(), ".cursor", "skills-cursor")
+        join21(homedir5(), ".cursor", "skills"),
+        join21(homedir5(), ".cursor", "skills-cursor")
       ]
     };
     CACHE_TTL_MS2 = 3e5;
@@ -20014,13 +20383,13 @@ async function handleEvolveCallback(chatId, data, channel) {
       const { getReflectionStatus: getReflectionStatus2, setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
-        const { readFileSync: readFileSync29, existsSync: existsSync57 } = await import("fs");
-        const { join: join36 } = await import("path");
+        const { readFileSync: readFileSync29, existsSync: existsSync58 } = await import("fs");
+        const { join: join37 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const soulPath = join36(CC_CLAW_HOME3, "identity/SOUL.md");
-        const userPath = join36(CC_CLAW_HOME3, "identity/USER.md");
-        const soul = existsSync57(soulPath) ? readFileSync29(soulPath, "utf-8") : "";
-        const user = existsSync57(userPath) ? readFileSync29(userPath, "utf-8") : "";
+        const soulPath = join37(CC_CLAW_HOME3, "identity/SOUL.md");
+        const userPath = join37(CC_CLAW_HOME3, "identity/USER.md");
+        const soul = existsSync58(soulPath) ? readFileSync29(soulPath, "utf-8") : "";
+        const user = existsSync58(userPath) ? readFileSync29(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
         const { logActivity: logActivity2 } = await Promise.resolve().then(() => (init_store3(), store_exports3));
         logActivity2(getDb(), { chatId, source: "telegram", eventType: "reflection_unfrozen", summary: "Reflection enabled" });
@@ -20097,11 +20466,11 @@ var init_evolve2 = __esm({
 });
 
 // src/optimizer/identity-audit.ts
-import { readFileSync as readFileSync11, existsSync as existsSync20, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync21, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { join as join22 } from "path";
 function readIdentityFile2(filename) {
   try {
-    return readFileSync11(join21(IDENTITY_PATH, filename), "utf-8");
+    return readFileSync11(join22(IDENTITY_PATH, filename), "utf-8");
   } catch {
     return "";
   }
@@ -20116,13 +20485,13 @@ function getMtime(filepath) {
 function findBackupFiles() {
   const backups = [];
   const dirs = [IDENTITY_PATH];
-  const contextDir = join21(IDENTITY_PATH, "..", "workspace", "context");
-  if (existsSync20(contextDir)) dirs.push(contextDir);
+  const contextDir = join22(IDENTITY_PATH, "..", "workspace", "context");
+  if (existsSync21(contextDir)) dirs.push(contextDir);
   for (const dir of dirs) {
     try {
       for (const entry of readdirSync10(dir)) {
         if (entry.endsWith(".bak") || /\.bak\.\d{4}-\d{2}-\d{2}/.test(entry)) {
-          backups.push(join21(dir, entry));
+          backups.push(join22(dir, entry));
         }
       }
     } catch {
@@ -20143,9 +20512,9 @@ function computeIdentityStats(pendingProposals, driftPercent) {
     userChars,
     ccClawChars,
     boilerplateChars,
-    soulMtime: getMtime(join21(IDENTITY_PATH, "SOUL.md")),
-    userMtime: getMtime(join21(IDENTITY_PATH, "USER.md")),
-    ccClawMtime: getMtime(join21(IDENTITY_PATH, "CC-CLAW.md")),
+    soulMtime: getMtime(join22(IDENTITY_PATH, "SOUL.md")),
+    userMtime: getMtime(join22(IDENTITY_PATH, "USER.md")),
+    ccClawMtime: getMtime(join22(IDENTITY_PATH, "CC-CLAW.md")),
     backupFiles: findBackupFiles(),
     estimatedTokens: Math.ceil(ccClawChars / 4),
     pendingEvolveProposals: pendingProposals,
@@ -20254,8 +20623,8 @@ var init_identity_audit = __esm({
 });
 
 // src/optimizer/skill-audit.ts
-import { readFileSync as readFileSync12, existsSync as existsSync21 } from "fs";
-import { join as join22, basename as basename3 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync22 } from "fs";
+import { join as join23, basename as basename3 } from "path";
 function parseFrontmatter3(content) {
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) return {};
@@ -20270,10 +20639,6 @@ function parseFrontmatter3(content) {
     const singleDesc = fm.match(/^description:\s*(.+)/m);
     if (singleDesc) result.description = singleDesc[1].trim().replace(/^["']|["']$/g, "");
   }
-  const backendsMatch = fm.match(/^compatible_backends:\s*(.+)/m);
-  if (backendsMatch) result.compatibleBackends = backendsMatch[1].trim();
-  const modelMatch = fm.match(/^recommended_model:\s*(.+)/m);
-  if (modelMatch) result.recommendedModel = modelMatch[1].trim();
   return result;
 }
 function detectDependentSkills(content) {
@@ -20298,7 +20663,7 @@ function computeSkillStats(skillPath) {
   const content = readFileSync12(skillPath, "utf-8");
   const lines = content.split("\n");
   return {
-    skillName: basename3(skillPath, ".md") === "SKILL" ? basename3(join22(skillPath, "..")) : basename3(skillPath, ".md"),
+    skillName: basename3(skillPath, ".md") === "SKILL" ? basename3(join23(skillPath, "..")) : basename3(skillPath, ".md"),
     skillPath,
     lineCount: lines.length,
     charCount: content.length,
@@ -20318,11 +20683,11 @@ function loadDependentSkillContents(depNames, ccClawSkillsDir) {
   const results = [];
   for (const name of depNames) {
     const candidates = [
-      join22(ccClawSkillsDir, name, "SKILL.md"),
-      join22(ccClawSkillsDir, `${name}-skill`, "SKILL.md")
+      join23(ccClawSkillsDir, name, "SKILL.md"),
+      join23(ccClawSkillsDir, `${name}-skill`, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync21(candidate)) {
+      if (existsSync22(candidate)) {
         try {
           const content = readFileSync12(candidate, "utf-8");
           results.push({
@@ -20353,8 +20718,6 @@ Lines: ${stats.lineCount} (cap: 500 \u2014 over 500 = progressive disclosure nee
 Chars: ${stats.charCount} (~${stats.estimatedTokens} tokens)
 Frontmatter name: ${stats.frontmatter.name || "(missing)"}
 Frontmatter description: ${stats.frontmatter.description ? stats.frontmatter.description.slice(0, 200) : "(missing)"}
-Compatible backends: ${stats.frontmatter.compatibleBackends || "(not specified)"}
-Recommended model: ${stats.frontmatter.recommendedModel || "(not specified)"}
 Referenced skills: ${stats.dependentSkills.length > 0 ? stats.dependentSkills.join(", ") : "none"}`);
   sections.push(`[Rubric \u2014 Evaluate Each Area]
 
@@ -20362,7 +20725,6 @@ Referenced skills: ${stats.dependentSkills.length > 0 ? stats.dependentSkills.jo
    - Is 'name' present and descriptive?
    - Does 'description' include BOTH what the skill does AND trigger info (when to use it)?
    - A good description tells the AI exactly when to activate this skill
-   - Should 'compatible_backends' or 'recommended_model' be specified?
 
 2. BODY STRUCTURE
    - Over 500 lines? \u2192 needs progressive disclosure (essentials in body, details in references/)
@@ -20439,8 +20801,8 @@ __export(analyze_exports2, {
 });
 import { spawn as spawn7 } from "child_process";
 import { createInterface as createInterface7 } from "readline";
-import { readFileSync as readFileSync13, existsSync as existsSync22, readdirSync as readdirSync12 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync23, readdirSync as readdirSync12 } from "fs";
+import { join as join24 } from "path";
 import { homedir as homedir7 } from "os";
 function parseOptimizeOutput(raw, validAreas) {
   if (!raw || raw.includes("NO_FINDINGS")) return [];
@@ -20570,20 +20932,20 @@ function getModelDisplayInfo(chatId) {
 }
 function readIdentityFile3(filename) {
   try {
-    return readFileSync13(join23(IDENTITY_PATH, filename), "utf-8");
+    return readFileSync13(join24(IDENTITY_PATH, filename), "utf-8");
   } catch {
     return "";
   }
 }
 function loadContextFiles2() {
-  const contextDir = join23(homedir7(), ".cc-claw", "workspace", "context");
+  const contextDir = join24(homedir7(), ".cc-claw", "workspace", "context");
   const results = [];
-  if (!existsSync22(contextDir)) return results;
+  if (!existsSync23(contextDir)) return results;
   try {
     for (const entry of readdirSync12(contextDir)) {
       if (!entry.endsWith(".md")) continue;
       try {
-        const content = readFileSync13(join23(contextDir, entry), "utf-8");
+        const content = readFileSync13(join24(contextDir, entry), "utf-8");
         results.push({ name: entry, content });
       } catch {
       }
@@ -20634,7 +20996,7 @@ async function runSkillAudit(chatId, skillPath) {
   const stats = computeSkillStats(skillPath);
   log(`[optimizer] Running skill audit on ${stats.skillName} with ${adapter.id}:${model2}`);
   const soulMd = readIdentityFile3("SOUL.md");
-  const ccClawSkillsDir = join23(homedir7(), ".cc-claw", "workspace", "skills");
+  const ccClawSkillsDir = join24(homedir7(), ".cc-claw", "workspace", "skills");
   const skillContent = readFileSync13(skillPath, "utf-8");
   const prompt = buildSkillAuditPrompt(skillContent, stats, soulMd, ccClawSkillsDir);
   const raw = await spawnAnalysis2(adapter, model2, prompt);
@@ -20649,13 +21011,13 @@ async function runSkillAudit(chatId, skillPath) {
   };
 }
 function listCcClawSkills() {
-  const skillsDir = join23(homedir7(), ".cc-claw", "workspace", "skills");
+  const skillsDir = join24(homedir7(), ".cc-claw", "workspace", "skills");
   const entries = [];
-  if (!existsSync22(skillsDir)) return entries;
+  if (!existsSync23(skillsDir)) return entries;
   try {
     for (const dir of readdirSync12(skillsDir)) {
-      const skillFile = join23(skillsDir, dir, "SKILL.md");
-      if (!existsSync22(skillFile)) continue;
+      const skillFile = join24(skillsDir, dir, "SKILL.md");
+      if (!existsSync23(skillFile)) continue;
       let description = "skill";
       try {
         const content = readFileSync13(skillFile, "utf-8");
@@ -20978,8 +21340,8 @@ var init_ui2 = __esm({
 });
 
 // src/router/optimize.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync7, existsSync as existsSync23, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
-import { join as join24, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync7, existsSync as existsSync24, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
+import { join as join25, 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));
@@ -21160,7 +21522,7 @@ async function runSkillAuditFlow(chatId, channel, skillName) {
   } = await Promise.resolve().then(() => (init_ui2(), ui_exports));
   const modelInfo = getModelDisplayInfo2(chatId);
   if (!modelInfo) return;
-  const skillPath = join24(homedir8(), ".cc-claw", "workspace", "skills", skillName, "SKILL.md");
+  const skillPath = join25(homedir8(), ".cc-claw", "workspace", "skills", skillName, "SKILL.md");
   const progressMsgId = typeof channel.sendTextReturningId === "function" ? await channel.sendTextReturningId(
     chatId,
     buildProgressMessage2(`skill: ${skillName}`, modelInfo.backend, modelInfo.model, modelInfo.thinkingLevel),
@@ -21249,7 +21611,7 @@ async function applyFinding(chatId, channel, index) {
       await showFinding(chatId, channel, index + 1);
       return;
     }
-    if (!existsSync23(targetPath)) {
+    if (!existsSync24(targetPath)) {
       await channel.sendText(chatId, `Target file not found: ${targetPath}`, { parseMode: "plain" });
       session2.skipped.push(index);
       await showFinding(chatId, channel, index + 1);
@@ -21331,14 +21693,14 @@ async function finishReview(chatId, channel) {
   activeSessions.delete(chatId);
 }
 function resolveTargetFile(location, auditTarget) {
-  const ccClawHome = join24(homedir8(), ".cc-claw");
+  const ccClawHome = join25(homedir8(), ".cc-claw");
   const filePart = location.split(":")[0]?.trim();
   if (!filePart) return null;
-  if (filePart === "SOUL.md") return join24(ccClawHome, "identity", "SOUL.md");
-  if (filePart === "USER.md") return join24(ccClawHome, "identity", "USER.md");
-  if (filePart === "CC-CLAW.md") return join24(ccClawHome, "identity", "CC-CLAW.md");
+  if (filePart === "SOUL.md") return join25(ccClawHome, "identity", "SOUL.md");
+  if (filePart === "USER.md") return join25(ccClawHome, "identity", "USER.md");
+  if (filePart === "CC-CLAW.md") return join25(ccClawHome, "identity", "CC-CLAW.md");
   if (filePart === "SKILL.md" && auditTarget !== "identity") {
-    return join24(ccClawHome, "workspace", "skills", auditTarget, "SKILL.md");
+    return join25(ccClawHome, "workspace", "skills", auditTarget, "SKILL.md");
   }
   return null;
 }
@@ -21346,7 +21708,7 @@ function pruneBackups2(absolutePath) {
   const dir = dirname4(absolutePath);
   const baseName = absolutePath.split("/").pop() ?? "";
   try {
-    const backups = readdirSync13(dir).filter((f) => f.startsWith(baseName + ".bak.")).sort().map((f) => join24(dir, f));
+    const backups = readdirSync13(dir).filter((f) => f.startsWith(baseName + ".bak.")).sort().map((f) => join25(dir, f));
     while (backups.length > 3) {
       const oldest = backups.shift();
       try {
@@ -21368,6 +21730,193 @@ var init_optimize = __esm({
   }
 });
 
+// src/skills/auto-create.ts
+var auto_create_exports = {};
+__export(auto_create_exports, {
+  buildSessionExtractionPrompt: () => buildSessionExtractionPrompt,
+  buildSkillExtractionPrompt: () => buildSkillExtractionPrompt,
+  clearPendingDraft: () => clearPendingDraft,
+  getPendingDraft: () => getPendingDraft,
+  isSkillWorthy: () => isSkillWorthy,
+  parseExtractedSkill: () => parseExtractedSkill,
+  saveSkill: () => saveSkill,
+  storePendingDraft: () => storePendingDraft
+});
+import { join as join26 } from "path";
+import { writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+function isSkillWorthy(signals) {
+  const { toolUseCount, tokenOutput, elapsedMs, userMessage } = signals;
+  if (toolUseCount < 12) return false;
+  if (elapsedMs < 3e5) return false;
+  if (tokenOutput < 3e3) return false;
+  const words = userMessage.split(/\s+/).length;
+  if (words < 5) return false;
+  const skillPatterns = /\b(use|using|run|with|the)\s+(the\s+)?[\w-]+\s+skill\b/i;
+  if (skillPatterns.test(userMessage)) {
+    log(`[auto-skill] Skipping \u2014 message references an existing skill`);
+    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 buildSessionExtractionPrompt(sessionMessages) {
+  const transcript = [];
+  let totalChars = 0;
+  const CAP = 12e3;
+  for (const msg of sessionMessages) {
+    const prefix = msg.role === "user" ? "USER" : "ASSISTANT";
+    const text = msg.text.length > 2e3 ? msg.text.slice(0, 2e3) + " [...]" : msg.text;
+    if (totalChars + text.length > CAP) {
+      transcript.push(`[...earlier messages truncated...]`);
+      break;
+    }
+    transcript.push(`[${prefix}]: ${text}`);
+    totalChars += text.length;
+  }
+  return [
+    "You are a skill extraction assistant. Review the following session transcript 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.",
+    "Analyze the ENTIRE session to understand:",
+    "- What the user was trying to accomplish",
+    "- What tools and approaches the AI used",
+    "- Any feedback the user gave (corrections, preferences, refinements)",
+    "- The overall workflow pattern",
+    "",
+    "Focus on the PROCESS and APPROACH, not the specific details of this session.",
+    "Incorporate user feedback as best practices or decision points in the skill.",
+    "",
+    "## Session Transcript",
+    "",
+    ...transcript,
+    "",
+    "## 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]",
+    "[Incorporate any user preferences or corrections from the session]",
+    "[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)",
+    "- If the user corrected the AI during the session, bake those corrections into the skill as best practices",
+    "- 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();
+  let fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    const greedyFence = llmResponse.match(/```(?:markdown|md)?\s*\n([\s\S]*)```/);
+    if (greedyFence) {
+      content = greedyFence[1].trim();
+      fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    }
+  }
+  if (!fmMatch) {
+    fmMatch = llmResponse.match(/---\s*\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      const fmStart = llmResponse.indexOf(fmMatch[0]);
+      content = llmResponse.slice(fmStart).replace(/```\s*$/, "").trim();
+    }
+  }
+  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 = join26(SKILLS_PATH, name);
+  await mkdir4(dir, { recursive: true });
+  const filePath = join26(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/council/types.ts
 var COUNCIL_MIN_PARTICIPANTS, COUNCIL_MAX_ROUNDS, COUNCIL_WIZARD_TIMEOUT_MS;
 var init_types4 = __esm({
@@ -21720,6 +22269,49 @@ Use /skills to see it.`, { parseMode: "plain" });
     await channel.sendText(chatId, `Installation failed: ${result.error}`, { parseMode: "plain" });
   }
 }
+async function handleExtractSkillCommand(chatId, commandArgs, msg, channel) {
+  const { getLog: getLog2 } = await Promise.resolve().then(() => (init_session_log(), session_log_exports));
+  const sessionMessages = getLog2(chatId);
+  if (sessionMessages.length < 2) {
+    await channel.sendText(chatId, "No session history to extract from. Have a conversation first, then run /extract_skill.", { parseMode: "plain" });
+    return;
+  }
+  await channel.sendText(chatId, `Reviewing session (${Math.floor(sessionMessages.length / 2)} exchanges)...`, { parseMode: "plain" });
+  const { buildSessionExtractionPrompt: buildSessionExtractionPrompt2, parseExtractedSkill: parseExtractedSkill2, storePendingDraft: storePendingDraft2 } = await Promise.resolve().then(() => (init_auto_create(), auto_create_exports));
+  const { askAgent: askAgent3 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
+  const { getMode: getMode3 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const prompt = buildSessionExtractionPrompt2(sessionMessages);
+  const response = await askAgent3(chatId, prompt, { permMode: getMode3(chatId) });
+  const extracted = parseExtractedSkill2(response.text);
+  if (!extracted) {
+    await channel.sendText(chatId, "Could not extract a skill from this session. The session may be too short or unfocused.", { parseMode: "plain" });
+    return;
+  }
+  storePendingDraft2(chatId, {
+    name: extracted.name,
+    content: extracted.content,
+    userMessage: sessionMessages.filter((m) => m.role === "user").map((m) => m.text).join("\n"),
+    assistantResponse: sessionMessages.filter((m) => m.role === "assistant").map((m) => m.text).join("\n")
+  });
+  const preview = extracted.content.length > 3500 ? extracted.content.slice(0, 3500) + "\n\n[...truncated...]" : extracted.content;
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendText(chatId, `Extracted skill: "${extracted.name}"
+
+${preview}`, { parseMode: "plain" });
+    await channel.sendKeyboard(
+      chatId,
+      `Save this skill?`,
+      [[
+        { label: "\u2705 Save Skill", data: "skill:confirm-save", style: "success" },
+        { label: "\u2715 Discard", data: "skill:discard" }
+      ]]
+    );
+  } else {
+    const { saveSkill: saveSkill2 } = await Promise.resolve().then(() => (init_auto_create(), auto_create_exports));
+    const result = await saveSkill2(extracted.name, extracted.content);
+    await channel.sendText(chatId, `Skill "${extracted.name}" saved to ${result.path}`, { parseMode: "plain" });
+  }
+}
 async function handleSetupProfileCommand(chatId, commandArgs, msg, channel) {
   await startProfileWizard(chatId, channel);
 }
@@ -23364,6 +23956,10 @@ async function handleCommand(msg, channel) {
     case "skill-install":
       await handleSkillInstallCommand(chatId, commandArgs, msg, channel);
       break;
+    case "extract_skill":
+    case "extractskill":
+      await handleExtractSkillCommand(chatId, commandArgs, msg, channel);
+      break;
     case "setup-profile":
       await handleSetupProfileCommand(chatId, commandArgs, msg, channel);
       break;
@@ -23450,134 +24046,6 @@ 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();
-  let fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
-  if (!fmMatch) {
-    const greedyFence = llmResponse.match(/```(?:markdown|md)?\s*\n([\s\S]*)```/);
-    if (greedyFence) {
-      content = greedyFence[1].trim();
-      fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    }
-  }
-  if (!fmMatch) {
-    fmMatch = llmResponse.match(/---\s*\n([\s\S]*?)\n---/);
-    if (fmMatch) {
-      const fmStart = llmResponse.indexOf(fmMatch[0]);
-      content = llmResponse.slice(fmStart).replace(/```\s*$/, "").trim();
-    }
-  }
-  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) {
@@ -23980,7 +24448,107 @@ This cannot be undone.`,
       }
     } else if (rest.startsWith("edit:")) {
       const id = parseInt(rest.slice(5), 10);
+      const editJob = getJobById(id);
+      if (!editJob) {
+        await channel.sendText(chatId, `Job #${id} not found.`, { parseMode: "plain" });
+        return;
+      }
+      if (typeof channel.sendKeyboard === "function") {
+        const backendLabel = editJob.backend ? `${editJob.backend}/${editJob.model ?? "default"}` : "chat default";
+        await channel.sendKeyboard(
+          chatId,
+          `Edit Job #${id}
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+What do you want to change?`,
+          [
+            [
+              { label: "\u{1F4C5} Schedule", data: `job:editwiz:${id}` },
+              { label: "\u{1F527} Backend/Model", data: `job:editbackend:${id}` }
+            ],
+            [
+              { label: "\u23F1 Timeout", data: `job:edittimeout:${id}` },
+              { label: "\u{1F4DD} Full Edit", data: `job:editwiz:${id}` }
+            ],
+            [{ label: "\u2190 Back to Job", data: `job:view:${id}` }]
+          ]
+        );
+      } else {
+        await startEditWizard(chatId, id, channel);
+      }
+    } else if (rest.startsWith("editwiz:")) {
+      const id = parseInt(rest.slice(8), 10);
       await startEditWizard(chatId, id, channel);
+    } else if (rest.startsWith("editbackend:")) {
+      const id = parseInt(rest.slice(12), 10);
+      const { getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapters2 = getAllAdapters5().filter((a) => a.id !== "ollama");
+      const buttons = adapters2.map((a) => ({
+        label: a.displayName,
+        data: `job:setbackend:${id}:${a.id}`
+      }));
+      const rows = [];
+      for (let i = 0; i < buttons.length; i += 2) {
+        rows.push(buttons.slice(i, i + 2));
+      }
+      rows.push([{ label: "\u2190 Back", data: `job:edit:${id}` }]);
+      if (typeof channel.sendKeyboard === "function") {
+        await channel.sendKeyboard(chatId, `Pick a backend for Job #${id}:`, rows);
+      }
+    } else if (rest.startsWith("setbackend:")) {
+      const parts = rest.slice(11).split(":");
+      const id = parseInt(parts[0], 10);
+      const backend2 = parts[1];
+      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter4(backend2);
+      const models = Object.entries(adapter.availableModels);
+      const buttons = models.map(([modelId, info]) => ({
+        label: info.label?.split("\u2014")[0]?.trim() ?? modelId,
+        data: `job:setmodel:${id}:${backend2}:${modelId}`
+      }));
+      const rows = [];
+      for (let i = 0; i < buttons.length; i += 2) {
+        rows.push(buttons.slice(i, i + 2));
+      }
+      rows.push([{ label: "\u2190 Back", data: `job:editbackend:${id}` }]);
+      if (typeof channel.sendKeyboard === "function") {
+        await channel.sendKeyboard(chatId, `Pick a model for ${adapter.displayName}:`, rows);
+      }
+    } else if (rest.startsWith("setmodel:")) {
+      const parts = rest.slice(9).split(":");
+      const id = parseInt(parts[0], 10);
+      const backend2 = parts[1];
+      const model2 = parts.slice(2).join(":");
+      const { updateJob: updateJobFields } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+      updateJobFields(id, { backend: backend2, model: model2 });
+      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter4(backend2);
+      await channel.sendText(chatId, `Job #${id} updated: ${adapter.displayName} / ${model2}`, { parseMode: "plain" });
+      await sendJobDetail(chatId, id, channel);
+    } else if (rest.startsWith("edittimeout:")) {
+      const id = parseInt(rest.slice(12), 10);
+      if (typeof channel.sendKeyboard === "function") {
+        await channel.sendKeyboard(chatId, `Set timeout for Job #${id}:`, [
+          [
+            { label: "2 min", data: `job:settimeout:${id}:120` },
+            { label: "5 min", data: `job:settimeout:${id}:300` },
+            { label: "10 min", data: `job:settimeout:${id}:600` }
+          ],
+          [
+            { label: "15 min", data: `job:settimeout:${id}:900` },
+            { label: "30 min", data: `job:settimeout:${id}:1800` },
+            { label: "60 min", data: `job:settimeout:${id}:3600` }
+          ],
+          [{ label: "\u2190 Back", data: `job:edit:${id}` }]
+        ]);
+      }
+    } else if (rest.startsWith("settimeout:")) {
+      const parts = rest.slice(11).split(":");
+      const id = parseInt(parts[0], 10);
+      const timeout = parseInt(parts[1], 10);
+      const { updateJob: updateJobFields } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+      updateJobFields(id, { timeout });
+      await channel.sendText(chatId, `Job #${id} timeout updated: ${timeout}s (${Math.round(timeout / 60)} min)`, { parseMode: "plain" });
+      await sendJobDetail(chatId, id, channel);
     } else if (rest === "back") {
       await sendJobsBoard(chatId, channel, 1, messageId);
     } else {
@@ -24786,14 +25354,6 @@ Use /skills to see all available skills.`, { parseMode: "plain" });
       await channel.sendText(chatId, `Skill "${skillName}" not found.`, { parseMode: "plain" });
       return;
     }
-    const activeBackend = getBackend(chatId) ?? "claude";
-    if (skill.compatibleBackends && !skill.compatibleBackends.includes(activeBackend)) {
-      await channel.sendText(
-        chatId,
-        `Note: "${skillName}" lists compatible backends as [${skill.compatibleBackends.join(", ")}], but active backend is ${activeBackend}. Proceeding anyway.`,
-        { parseMode: "plain" }
-      );
-    }
     const raw = await readFile7(skill.filePath, "utf-8");
     const skillContent = stripFrontmatter2(raw);
     const tags = skill.sources.join(", ");
@@ -26322,7 +26882,7 @@ var init_cron = __esm({
 });
 
 // src/agents/runners/wrap-backend.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function buildMcpCommands(backendId) {
   const exe = backendId === BACKEND.CURSOR ? "agent" : backendId;
   return {
@@ -26416,7 +26976,7 @@ function wrapBackendAdapter(adapter) {
       const configPath = writeMcpConfigFile(server);
       return ["--mcp-config", configPath];
     },
-    getSkillPath: () => join26(SKILLS_PATH, `agent-${adapter.id}.md`)
+    getSkillPath: () => join27(SKILLS_PATH, `agent-${adapter.id}.md`)
   };
 }
 var BACKEND_CAPABILITIES;
@@ -26478,18 +27038,18 @@ var init_wrap_backend = __esm({
 });
 
 // src/agents/runners/config-loader.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync14, existsSync as existsSync24, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
-import { join as join27 } from "path";
+import { readFileSync as readFileSync15, readdirSync as readdirSync14, existsSync as existsSync25, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
+import { join as join28 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 function resolveExecutable2(config2) {
-  if (existsSync24(config2.executable)) return config2.executable;
+  if (existsSync25(config2.executable)) return config2.executable;
   try {
     return execFileSync3("which", [config2.executable], { encoding: "utf-8" }).trim();
   } catch {
   }
   for (const fallback of config2.executableFallbacks ?? []) {
     const resolved = fallback.replace(/^~/, process.env.HOME ?? "");
-    if (existsSync24(resolved)) return resolved;
+    if (existsSync25(resolved)) return resolved;
   }
   return config2.executable;
 }
@@ -26615,7 +27175,7 @@ function configToRunner(config2) {
     prepareMcpInjection() {
       return [];
     },
-    getSkillPath: () => join27(SKILLS_PATH, `agent-${config2.id}.md`)
+    getSkillPath: () => join28(SKILLS_PATH, `agent-${config2.id}.md`)
   };
 }
 function loadRunnerConfig(filePath) {
@@ -26628,14 +27188,14 @@ function loadRunnerConfig(filePath) {
   }
 }
 function loadAllRunnerConfigs() {
-  if (!existsSync24(RUNNERS_PATH)) {
+  if (!existsSync25(RUNNERS_PATH)) {
     mkdirSync10(RUNNERS_PATH, { recursive: true });
     return [];
   }
   const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   const configs = [];
   for (const file of files) {
-    const config2 = loadRunnerConfig(join27(RUNNERS_PATH, file));
+    const config2 = loadRunnerConfig(join28(RUNNERS_PATH, file));
     if (config2) configs.push(config2);
   }
   return configs;
@@ -26656,16 +27216,16 @@ function registerConfigRunners() {
   return count;
 }
 function watchRunnerConfigs(onChange) {
-  if (!existsSync24(RUNNERS_PATH)) return;
+  if (!existsSync25(RUNNERS_PATH)) return;
   for (const prev of watchedFiles) {
-    if (!existsSync24(prev)) {
+    if (!existsSync25(prev)) {
       unwatchFile(prev);
       watchedFiles.delete(prev);
     }
   }
   const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   for (const file of files) {
-    const fullPath = join27(RUNNERS_PATH, file);
+    const fullPath = join28(RUNNERS_PATH, file);
     if (watchedFiles.has(fullPath)) continue;
     watchedFiles.add(fullPath);
     watchFile(fullPath, { interval: 5e3 }, () => {
@@ -27731,19 +28291,19 @@ var init_telegram2 = __esm({
 });
 
 // src/skills/bootstrap.ts
-import { existsSync as existsSync25 } from "fs";
-import { readdir as readdir5, readFile as readFile8, writeFile as writeFile5, copyFile } from "fs/promises";
-import { join as join28, dirname as dirname5 } from "path";
+import { existsSync as existsSync26 } from "fs";
+import { readdir as readdir6, readFile as readFile8, writeFile as writeFile5, copyFile } from "fs/promises";
+import { join as join29, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function copyAgentManifestSkills() {
-  if (!existsSync25(PKG_SKILLS)) return;
+  if (!existsSync26(PKG_SKILLS)) return;
   try {
-    const entries = await readdir5(PKG_SKILLS, { withFileTypes: true });
+    const entries = await readdir6(PKG_SKILLS, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.startsWith("agent-") || !entry.name.endsWith(".md")) continue;
-      const src = join28(PKG_SKILLS, entry.name);
-      const dest = join28(SKILLS_PATH, entry.name);
-      if (existsSync25(dest)) continue;
+      const src = join29(PKG_SKILLS, entry.name);
+      const dest = join29(SKILLS_PATH, entry.name);
+      if (existsSync26(dest)) continue;
       await copyFile(src, dest);
       log(`[skills] Bootstrapped ${entry.name} to ${SKILLS_PATH}`);
     }
@@ -27753,10 +28313,10 @@ async function copyAgentManifestSkills() {
 }
 async function bootstrapSkills() {
   await copyAgentManifestSkills();
-  const usmDir = join28(SKILLS_PATH, USM_DIR_NAME);
-  if (existsSync25(usmDir)) return;
+  const usmDir = join29(SKILLS_PATH, USM_DIR_NAME);
+  if (existsSync26(usmDir)) return;
   try {
-    const entries = await readdir5(SKILLS_PATH);
+    const entries = await readdir6(SKILLS_PATH);
     const dirs = entries.filter((e) => !e.startsWith("."));
     if (dirs.length > 0) return;
   } catch (err) {
@@ -27777,8 +28337,8 @@ async function bootstrapSkills() {
   }
 }
 async function patchUsmForCcClaw(usmDir) {
-  const skillPath = join28(usmDir, "SKILL.md");
-  if (!existsSync25(skillPath)) return;
+  const skillPath = join29(usmDir, "SKILL.md");
+  if (!existsSync26(skillPath)) return;
   try {
     let content = await readFile8(skillPath, "utf-8");
     let patched = false;
@@ -27823,8 +28383,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 = join28(dirname5(fileURLToPath2(import.meta.url)), "..", "..");
-    PKG_SKILLS = join28(PKG_ROOT, "skills");
+    PKG_ROOT = join29(dirname5(fileURLToPath2(import.meta.url)), "..", "..");
+    PKG_SKILLS = join29(PKG_ROOT, "skills");
   }
 });
 
@@ -28046,13 +28606,13 @@ __export(ai_skill_exports, {
   generateAiSkill: () => generateAiSkill,
   installAiSkill: () => installAiSkill
 });
-import { existsSync as existsSync26, writeFileSync as writeFileSync8, mkdirSync as mkdirSync11 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync27, writeFileSync as writeFileSync8, mkdirSync as mkdirSync11 } from "fs";
+import { join as join30 } from "path";
 import { homedir as homedir9 } from "os";
 function generateAiSkill() {
   const version = VERSION;
   let systemState = "";
-  if (existsSync26(DB_PATH)) {
+  if (existsSync27(DB_PATH)) {
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = (init_store5(), __toCommonJS(store_exports5));
       const readDb = openDatabaseReadOnly2();
@@ -28492,8 +29052,8 @@ function installAiSkill() {
   const failed = [];
   for (const [backend2, dirs] of Object.entries(BACKEND_SKILL_DIRS2)) {
     for (const dir of dirs) {
-      const skillDir = join29(dir, "cc-claw-cli");
-      const skillPath = join29(skillDir, "SKILL.md");
+      const skillDir = join30(dir, "cc-claw-cli");
+      const skillPath = join30(skillDir, "SKILL.md");
       try {
         mkdirSync11(skillDir, { recursive: true });
         writeFileSync8(skillPath, skill, "utf-8");
@@ -28512,11 +29072,11 @@ var init_ai_skill = __esm({
     init_paths();
     init_version();
     BACKEND_SKILL_DIRS2 = {
-      "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")]
+      "cc-claw": [join30(homedir9(), ".cc-claw", "workspace", "skills")],
+      claude: [join30(homedir9(), ".claude", "skills")],
+      gemini: [join30(homedir9(), ".gemini", "skills")],
+      codex: [join30(homedir9(), ".agents", "skills")],
+      cursor: [join30(homedir9(), ".cursor", "skills"), join30(homedir9(), ".cursor", "skills-cursor")]
     };
   }
 });
@@ -28526,21 +29086,21 @@ var index_exports = {};
 __export(index_exports, {
   main: () => main
 });
-import { mkdirSync as mkdirSync12, existsSync as existsSync27, renameSync as renameSync2, statSync as statSync9, readFileSync as readFileSync17 } from "fs";
-import { join as join30 } from "path";
+import { mkdirSync as mkdirSync12, existsSync as existsSync28, renameSync as renameSync2, statSync as statSync9, readFileSync as readFileSync17 } from "fs";
+import { join as join31 } from "path";
 import dotenv from "dotenv";
 function migrateLayout() {
   const moves = [
-    [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")]
+    [join31(CC_CLAW_HOME, "cc-claw.db"), join31(DATA_PATH, "cc-claw.db")],
+    [join31(CC_CLAW_HOME, "cc-claw.db-shm"), join31(DATA_PATH, "cc-claw.db-shm")],
+    [join31(CC_CLAW_HOME, "cc-claw.db-wal"), join31(DATA_PATH, "cc-claw.db-wal")],
+    [join31(CC_CLAW_HOME, "cc-claw.log"), join31(LOGS_PATH, "cc-claw.log")],
+    [join31(CC_CLAW_HOME, "cc-claw.log.1"), join31(LOGS_PATH, "cc-claw.log.1")],
+    [join31(CC_CLAW_HOME, "cc-claw.error.log"), join31(LOGS_PATH, "cc-claw.error.log")],
+    [join31(CC_CLAW_HOME, "cc-claw.error.log.1"), join31(LOGS_PATH, "cc-claw.error.log.1")]
   ];
   for (const [from, to] of moves) {
-    if (existsSync27(from) && !existsSync27(to)) {
+    if (existsSync28(from) && !existsSync28(to)) {
       try {
         renameSync2(from, to);
       } catch {
@@ -28717,10 +29277,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: join36 } = await import("path");
-    const skillDir = join36(SKILLS_PATH, "cc-claw-cli");
+    const { join: join37 } = await import("path");
+    const skillDir = join37(SKILLS_PATH, "cc-claw-cli");
     mkdirSync19(skillDir, { recursive: true });
-    writeFileSync13(join36(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
+    writeFileSync13(join37(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
     log("[cc-claw] AI skill updated");
   } catch {
   }
@@ -28820,10 +29380,10 @@ var init_index = __esm({
     init_health3();
     init_image_gen();
     for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SESSION_LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-      if (!existsSync27(dir)) mkdirSync12(dir, { recursive: true });
+      if (!existsSync28(dir)) mkdirSync12(dir, { recursive: true });
     }
     migrateLayout();
-    if (existsSync27(ENV_PATH)) {
+    if (existsSync28(ENV_PATH)) {
       dotenv.config({ path: ENV_PATH });
     } else {
       console.error(`[cc-claw] Config not found at ${ENV_PATH} \u2014 run 'cc-claw setup' first`);
@@ -28844,12 +29404,12 @@ __export(api_client_exports, {
   apiPost: () => apiPost,
   isDaemonRunning: () => isDaemonRunning
 });
-import { readFileSync as readFileSync18, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync29 } from "fs";
 import { request as httpRequest, Agent } from "http";
 function getToken() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync28(TOKEN_PATH)) return readFileSync18(TOKEN_PATH, "utf-8").trim();
+    if (existsSync29(TOKEN_PATH)) return readFileSync18(TOKEN_PATH, "utf-8").trim();
   } catch {
   }
   return null;
@@ -28948,10 +29508,10 @@ __export(service_exports2, {
   serviceStatus: () => serviceStatus,
   uninstallService: () => uninstallService
 });
-import { existsSync as existsSync29, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8 } from "fs";
 import { execFileSync as execFileSync4, execSync as execSync5 } from "child_process";
 import { homedir as homedir10, platform } from "os";
-import { join as join31, dirname as dirname6 } from "path";
+import { join as join32, 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;");
 }
@@ -28960,7 +29520,7 @@ function resolveExecutable3(name) {
     return execFileSync4("which", [name], { encoding: "utf-8" }).trim();
   } catch {
     const fallback = process.argv[1];
-    if (fallback && existsSync29(fallback)) return fallback;
+    if (fallback && existsSync30(fallback)) return fallback;
     throw new Error(`Cannot find '${name}' executable. Install globally: npm install -g cc-claw`);
   }
 }
@@ -28969,14 +29529,14 @@ function getPathDirs() {
   const home = homedir10();
   const dirs = /* @__PURE__ */ new Set([
     nodeBin,
-    join31(home, ".local", "bin"),
+    join32(home, ".local", "bin"),
     "/usr/local/bin",
     "/usr/bin",
     "/bin"
   ]);
   try {
     const prefix = execSync5("npm config get prefix", { encoding: "utf-8" }).trim();
-    if (prefix) dirs.add(join31(prefix, "bin"));
+    if (prefix) dirs.add(join32(prefix, "bin"));
   } catch {
   }
   return [...dirs].join(":");
@@ -29035,9 +29595,9 @@ function generatePlist() {
 }
 function installMacOS() {
   const agentsDir = dirname6(PLIST_PATH);
-  if (!existsSync29(agentsDir)) mkdirSync13(agentsDir, { recursive: true });
-  if (!existsSync29(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
-  if (existsSync29(PLIST_PATH)) {
+  if (!existsSync30(agentsDir)) mkdirSync13(agentsDir, { recursive: true });
+  if (!existsSync30(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
+  if (existsSync30(PLIST_PATH)) {
     try {
       execFileSync4("launchctl", ["unload", PLIST_PATH]);
     } catch {
@@ -29049,7 +29609,7 @@ function installMacOS() {
   console.log("  Service loaded and starting.");
 }
 function uninstallMacOS() {
-  if (!existsSync29(PLIST_PATH)) {
+  if (!existsSync30(PLIST_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
@@ -29124,8 +29684,8 @@ WantedBy=default.target
 `;
 }
 function installLinux() {
-  if (!existsSync29(SYSTEMD_DIR)) mkdirSync13(SYSTEMD_DIR, { recursive: true });
-  if (!existsSync29(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
+  if (!existsSync30(SYSTEMD_DIR)) mkdirSync13(SYSTEMD_DIR, { recursive: true });
+  if (!existsSync30(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
   writeFileSync9(UNIT_PATH, generateUnit());
   console.log(`  Installed: ${UNIT_PATH}`);
   execFileSync4("systemctl", ["--user", "daemon-reload"]);
@@ -29134,7 +29694,7 @@ function installLinux() {
   console.log("  Service enabled and started.");
 }
 function uninstallLinux() {
-  if (!existsSync29(UNIT_PATH)) {
+  if (!existsSync30(UNIT_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
@@ -29159,7 +29719,7 @@ function statusLinux() {
   }
 }
 function installService() {
-  if (!existsSync29(join31(CC_CLAW_HOME, ".env"))) {
+  if (!existsSync30(join32(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;
@@ -29188,9 +29748,9 @@ var init_service2 = __esm({
     "use strict";
     init_paths();
     PLIST_LABEL = "com.cc-claw";
-    PLIST_PATH = join31(homedir10(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-    SYSTEMD_DIR = join31(homedir10(), ".config", "systemd", "user");
-    UNIT_PATH = join31(SYSTEMD_DIR, "cc-claw.service");
+    PLIST_PATH = join32(homedir10(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+    SYSTEMD_DIR = join32(homedir10(), ".config", "systemd", "user");
+    UNIT_PATH = join32(SYSTEMD_DIR, "cc-claw.service");
   }
 });
 
@@ -29387,7 +29947,7 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import { existsSync as existsSync30, statSync as statSync10 } from "fs";
+import { existsSync as existsSync31, statSync as statSync10 } from "fs";
 async function statusCommand(globalOpts, localOpts) {
   try {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
@@ -29427,7 +29987,7 @@ async function statusCommand(globalOpts, localOpts) {
     const cwdRow = readDb.prepare("SELECT cwd FROM chat_cwd WHERE chat_id = ?").get(chatId);
     const voiceRow = readDb.prepare("SELECT enabled FROM chat_voice WHERE chat_id = ?").get(chatId);
     const usageRow = readDb.prepare("SELECT * FROM chat_usage WHERE chat_id = ?").get(chatId);
-    const dbStat = existsSync30(DB_PATH) ? statSync10(DB_PATH) : null;
+    const dbStat = existsSync31(DB_PATH) ? statSync10(DB_PATH) : null;
     let daemonRunning = false;
     let daemonInfo = {};
     try {
@@ -29539,13 +30099,13 @@ __export(doctor_exports, {
   doctorCommand: () => doctorCommand,
   doctorErrors: () => doctorErrors
 });
-import { existsSync as existsSync31, accessSync, constants } from "fs";
+import { existsSync as existsSync32, accessSync, constants } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
 async function doctorCommand(globalOpts, localOpts) {
   const checks = [];
   const dbChecks = checkDatabase();
   checks.push(...dbChecks);
-  if (existsSync31(DB_PATH)) {
+  if (existsSync32(DB_PATH)) {
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
       const readDb = openDatabaseReadOnly2();
@@ -29571,7 +30131,7 @@ async function doctorCommand(globalOpts, localOpts) {
       checks.push({ name: "Database health", status: "error", message: err.message });
     }
   }
-  if (existsSync31(ENV_PATH)) {
+  if (existsSync32(ENV_PATH)) {
     checks.push({ name: "Environment", status: "ok", message: `.env loaded` });
   } else {
     checks.push({ name: "Environment", status: "error", message: "No .env found", fix: "cc-claw setup" });
@@ -29614,7 +30174,7 @@ async function doctorCommand(globalOpts, localOpts) {
   } catch {
   }
   const tokenPath = `${DATA_PATH}/api-token`;
-  if (existsSync31(tokenPath)) {
+  if (existsSync32(tokenPath)) {
     try {
       accessSync(tokenPath, constants.R_OK);
       checks.push({ name: "API token", status: "ok", message: "token file readable" });
@@ -29680,7 +30240,7 @@ async function doctorCommand(globalOpts, localOpts) {
     const errorChecks = checks.filter(
       (c) => ["Rate limits", "Content silence", "Spawn timeouts", "Other errors"].includes(c.name) && c.status !== "ok"
     );
-    if (errorChecks.length > 0 && existsSync31(ERROR_LOG_PATH)) {
+    if (errorChecks.length > 0 && existsSync32(ERROR_LOG_PATH)) {
       try {
         const { writeFileSync: writeFileSync13 } = await import("fs");
         writeFileSync13(ERROR_LOG_PATH, "");
@@ -29809,10 +30369,10 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import { existsSync as existsSync32, readFileSync as readFileSync22, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync22, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
 async function logsCommand(opts) {
   const logFile = opts.error ? ERROR_LOG_PATH : LOG_PATH;
-  if (!existsSync32(logFile)) {
+  if (!existsSync33(logFile)) {
     outputError("LOG_NOT_FOUND", `Log file not found: ${logFile}`);
     process.exit(1);
   }
@@ -29965,11 +30525,11 @@ __export(gemini_exports, {
   geminiReorder: () => geminiReorder,
   geminiRotation: () => geminiRotation
 });
-import { existsSync as existsSync34, mkdirSync as mkdirSync14, writeFileSync as writeFileSync10, readFileSync as readFileSync24, chmodSync } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync14, writeFileSync as writeFileSync10, readFileSync as readFileSync24, chmodSync } from "fs";
+import { join as join33 } from "path";
 import { createInterface as createInterface8 } from "readline";
 function requireDb() {
-  if (!existsSync34(DB_PATH)) {
+  if (!existsSync35(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -29994,8 +30554,8 @@ async function resolveSlotId(idOrLabel) {
 function resolveOAuthEmail(configHome) {
   if (!configHome) return null;
   try {
-    const accountsPath = join32(configHome, ".gemini", "google_accounts.json");
-    if (!existsSync34(accountsPath)) return null;
+    const accountsPath = join33(configHome, ".gemini", "google_accounts.json");
+    if (!existsSync35(accountsPath)) return null;
     const accounts = JSON.parse(readFileSync24(accountsPath, "utf-8"));
     return accounts.active || null;
   } catch {
@@ -30078,14 +30638,14 @@ async function geminiAddKey(globalOpts, opts) {
 }
 async function geminiAddAccount(globalOpts, opts) {
   await requireWriteDb();
-  const slotsDir = join32(CC_CLAW_HOME, "gemini-slots");
-  if (!existsSync34(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
+  const slotsDir = join33(CC_CLAW_HOME, "gemini-slots");
+  if (!existsSync35(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
   const { addGeminiSlot: addGeminiSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const tempId = Date.now();
-  const slotDir = join32(slotsDir, `slot-${tempId}`);
+  const slotDir = join33(slotsDir, `slot-${tempId}`);
   mkdirSync14(slotDir, { recursive: true, mode: 448 });
-  mkdirSync14(join32(slotDir, ".gemini"), { recursive: true });
-  writeFileSync10(join32(slotDir, ".gemini", "settings.json"), JSON.stringify({
+  mkdirSync14(join33(slotDir, ".gemini"), { recursive: true });
+  writeFileSync10(join33(slotDir, ".gemini", "settings.json"), JSON.stringify({
     security: { auth: { selectedType: "oauth-personal" } }
   }, null, 2));
   console.log("");
@@ -30102,8 +30662,8 @@ async function geminiAddAccount(globalOpts, opts) {
     });
   } catch {
   }
-  const oauthPath = join32(slotDir, ".gemini", "oauth_creds.json");
-  if (!existsSync34(oauthPath)) {
+  const oauthPath = join33(slotDir, ".gemini", "oauth_creds.json");
+  if (!existsSync35(oauthPath)) {
     console.log(error2("\n  No OAuth credentials found. Sign-in may have failed."));
     console.log("  The slot directory is preserved at: " + slotDir);
     console.log("  Re-run: cc-claw gemini add-account\n");
@@ -30111,7 +30671,7 @@ async function geminiAddAccount(globalOpts, opts) {
   }
   let accountEmail = "unknown";
   try {
-    const accounts = JSON.parse(__require("fs").readFileSync(join32(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(__require("fs").readFileSync(join33(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
     accountEmail = accounts.active || accountEmail;
   } catch {
   }
@@ -30222,9 +30782,9 @@ async function geminiRelogin(globalOpts, idOrLabel) {
     outputError("NO_CONFIG", `Slot "${idOrLabel}" has no config directory \u2014 cannot re-login.`);
     return;
   }
-  const settingsPath = join32(slot.configHome, ".gemini", "settings.json");
-  if (!existsSync34(settingsPath)) {
-    mkdirSync14(join32(slot.configHome, ".gemini"), { recursive: true });
+  const settingsPath = join33(slot.configHome, ".gemini", "settings.json");
+  if (!existsSync35(settingsPath)) {
+    mkdirSync14(join33(slot.configHome, ".gemini"), { recursive: true });
     writeFileSync10(settingsPath, JSON.stringify({
       security: { auth: { selectedType: "oauth-personal" } }
     }, null, 2));
@@ -30248,8 +30808,8 @@ async function geminiRelogin(globalOpts, idOrLabel) {
     });
   } catch {
   }
-  const oauthPath = join32(slot.configHome, ".gemini", "oauth_creds.json");
-  if (!existsSync34(oauthPath)) {
+  const oauthPath = join33(slot.configHome, ".gemini", "oauth_creds.json");
+  if (!existsSync35(oauthPath)) {
     console.log(error2("\n  Re-login failed \u2014 no OAuth credentials found."));
     console.log(`  Try again: cc-claw gemini re-login ${idOrLabel}
 `);
@@ -30259,7 +30819,7 @@ async function geminiRelogin(globalOpts, idOrLabel) {
   setGeminiSlotEnabled2(slotId, true);
   let accountEmail = slot.label;
   try {
-    const accounts = JSON.parse(readFileSync24(join32(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(readFileSync24(join33(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
     if (accounts.active) accountEmail = accounts.active;
   } catch {
   }
@@ -30318,11 +30878,11 @@ __export(backend_cmd_factory_exports, {
   makeReorder: () => makeReorder,
   registerBackendSlotCommands: () => registerBackendSlotCommands
 });
-import { existsSync as existsSync35, mkdirSync as mkdirSync15, readFileSync as readFileSync25 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync15, readFileSync as readFileSync25 } from "fs";
+import { join as join34 } from "path";
 import { createInterface as createInterface9 } from "readline";
 function requireDb2() {
-  if (!existsSync35(DB_PATH)) {
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -30411,10 +30971,10 @@ function makeAddAccount(backend2, displayName) {
       process.exit(1);
     }
     await requireWriteDb2();
-    const slotsDir = join33(CC_CLAW_HOME, config2.slotsSubdir);
-    if (!existsSync35(slotsDir)) mkdirSync15(slotsDir, { recursive: true });
+    const slotsDir = join34(CC_CLAW_HOME, config2.slotsSubdir);
+    if (!existsSync36(slotsDir)) mkdirSync15(slotsDir, { recursive: true });
     const tempId = Date.now();
-    const slotDir = join33(slotsDir, `slot-${tempId}`);
+    const slotDir = join34(slotsDir, `slot-${tempId}`);
     mkdirSync15(slotDir, { recursive: true, mode: 448 });
     if (config2.preSetup) config2.preSetup(slotDir);
     console.log("");
@@ -30665,12 +31225,12 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { ANTHROPIC_API_KEY: void 0 },
         preSetup: (slotDir) => {
-          mkdirSync15(join33(slotDir, ".claude"), { recursive: true });
+          mkdirSync15(join34(slotDir, ".claude"), { recursive: true });
         },
         verifyCredentials: (slotDir) => {
-          const claudeJson = join33(slotDir, ".claude.json");
-          const claudeJsonNested = join33(slotDir, ".claude", ".claude.json");
-          if (existsSync35(claudeJson)) {
+          const claudeJson = join34(slotDir, ".claude.json");
+          const claudeJsonNested = join34(slotDir, ".claude", ".claude.json");
+          if (existsSync36(claudeJson)) {
             try {
               const data = JSON.parse(readFileSync25(claudeJson, "utf-8"));
               return Boolean(data.oauthAccount);
@@ -30678,7 +31238,7 @@ var init_backend_cmd_factory = __esm({
               return false;
             }
           }
-          if (existsSync35(claudeJsonNested)) {
+          if (existsSync36(claudeJsonNested)) {
             try {
               const data = JSON.parse(readFileSync25(claudeJsonNested, "utf-8"));
               return Boolean(data.oauthAccount);
@@ -30701,8 +31261,8 @@ var init_backend_cmd_factory = __esm({
           } catch {
           }
           try {
-            const claudeJson = join33(slotDir, ".claude.json");
-            if (existsSync35(claudeJson)) {
+            const claudeJson = join34(slotDir, ".claude.json");
+            if (existsSync36(claudeJson)) {
               const data = JSON.parse(readFileSync25(claudeJson, "utf-8"));
               if (data.oauthAccount?.emailAddress) return data.oauthAccount.emailAddress;
             }
@@ -30718,11 +31278,11 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { OPENAI_API_KEY: void 0 },
         verifyCredentials: (slotDir) => {
-          return existsSync35(join33(slotDir, "auth.json"));
+          return existsSync36(join34(slotDir, "auth.json"));
         },
         extractLabel: (slotDir) => {
           try {
-            const authData = JSON.parse(readFileSync25(join33(slotDir, "auth.json"), "utf-8"));
+            const authData = JSON.parse(readFileSync25(join34(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;
@@ -30746,9 +31306,9 @@ __export(ollama_exports3, {
   ollamaRemove: () => ollamaRemove,
   ollamaTest: () => ollamaTest
 });
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 function requireDb3() {
-  if (!existsSync36(DB_PATH)) {
+  if (!existsSync37(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -31007,12 +31567,12 @@ __export(backend_exports, {
   backendList: () => backendList,
   backendSet: () => backendSet
 });
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 async function backendList(globalOpts) {
   const { getAvailableAdapters: getAvailableAdapters3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   const chatId = resolveChatId2(globalOpts);
   let activeBackend = null;
-  if (existsSync37(DB_PATH)) {
+  if (existsSync38(DB_PATH)) {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     try {
@@ -31043,7 +31603,7 @@ async function backendList(globalOpts) {
 }
 async function backendGet(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -31087,13 +31647,13 @@ __export(model_exports, {
   modelList: () => modelList,
   modelSet: () => modelSet
 });
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 async function modelList(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const { getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   let backendId = "claude";
-  if (existsSync38(DB_PATH)) {
+  if (existsSync39(DB_PATH)) {
     const readDb = openDatabaseReadOnly2();
     try {
       const row = readDb.prepare("SELECT backend FROM chat_backend WHERE chat_id = ?").get(chatId);
@@ -31126,7 +31686,7 @@ async function modelList(globalOpts) {
 }
 async function modelGet(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31170,9 +31730,9 @@ __export(memory_exports2, {
   memoryList: () => memoryList,
   memorySearch: () => memorySearch
 });
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 async function memoryList(globalOpts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -31196,7 +31756,7 @@ async function memoryList(globalOpts) {
   });
 }
 async function memorySearch(globalOpts, query) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31218,7 +31778,7 @@ async function memorySearch(globalOpts, query) {
   });
 }
 async function memoryHistory(globalOpts, opts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31266,7 +31826,7 @@ __export(cron_exports2, {
   cronList: () => cronList,
   cronRuns: () => cronRuns
 });
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 function parseFallbacks(raw) {
   return raw.slice(0, 3).map((f) => {
     const [backend2, ...rest] = f.split(":");
@@ -31287,7 +31847,7 @@ function parseAndValidateTimeout(raw) {
   return val;
 }
 async function cronList(globalOpts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31325,7 +31885,7 @@ async function cronList(globalOpts) {
   });
 }
 async function cronHealth(globalOpts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31486,7 +32046,7 @@ async function cronEdit(globalOpts, id, opts) {
   }
 }
 async function cronRuns(globalOpts, jobId, opts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31533,9 +32093,9 @@ __export(agents_exports, {
   runnersList: () => runnersList,
   tasksList: () => tasksList
 });
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 async function agentsList(globalOpts) {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31566,7 +32126,7 @@ async function agentsList(globalOpts) {
   });
 }
 async function tasksList(globalOpts) {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31694,10 +32254,10 @@ __export(db_exports, {
   dbPath: () => dbPath,
   dbStats: () => dbStats
 });
-import { existsSync as existsSync42, statSync as statSync11, copyFileSync as copyFileSync3, mkdirSync as mkdirSync16 } from "fs";
+import { existsSync as existsSync43, statSync as statSync11, copyFileSync as copyFileSync3, mkdirSync as mkdirSync16 } from "fs";
 import { dirname as dirname7 } from "path";
 async function dbStats(globalOpts) {
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -31705,7 +32265,7 @@ async function dbStats(globalOpts) {
   const readDb = openDatabaseReadOnly2();
   const mainSize = statSync11(DB_PATH).size;
   const walPath = DB_PATH + "-wal";
-  const walSize = existsSync42(walPath) ? statSync11(walPath).size : 0;
+  const walSize = existsSync43(walPath) ? statSync11(walPath).size : 0;
   const tableNames = readDb.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts%' ORDER BY name"
   ).all();
@@ -31739,7 +32299,7 @@ async function dbPath(globalOpts) {
   output({ path: DB_PATH }, (d) => d.path);
 }
 async function dbBackup(globalOpts, destPath) {
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -31748,7 +32308,7 @@ async function dbBackup(globalOpts, destPath) {
     mkdirSync16(dirname7(dest), { recursive: true });
     copyFileSync3(DB_PATH, dest);
     const walPath = DB_PATH + "-wal";
-    if (existsSync42(walPath)) copyFileSync3(walPath, dest + "-wal");
+    if (existsSync43(walPath)) copyFileSync3(walPath, dest + "-wal");
     output({ path: dest, sizeBytes: statSync11(dest).size }, (d) => {
       const b = d;
       return `
@@ -31777,9 +32337,9 @@ __export(usage_exports, {
   usageCost: () => usageCost,
   usageTokens: () => usageTokens
 });
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 function ensureDb() {
-  if (!existsSync43(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -31969,9 +32529,9 @@ __export(config_exports2, {
   configList: () => configList,
   configSet: () => configSet
 });
-import { existsSync as existsSync44, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync26 } from "fs";
 async function configList(globalOpts) {
-  if (!existsSync44(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32005,7 +32565,7 @@ async function configGet(globalOpts, key) {
     outputError("INVALID_KEY", `Unknown config key "${key}". Valid keys: ${RUNTIME_KEYS.join(", ")}`);
     process.exit(1);
   }
-  if (!existsSync44(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32051,7 +32611,7 @@ async function configSet(globalOpts, key, value) {
   }
 }
 async function configEnv(_globalOpts) {
-  if (!existsSync44(ENV_PATH)) {
+  if (!existsSync45(ENV_PATH)) {
     outputError("ENV_NOT_FOUND", `No .env file at ${ENV_PATH}. Run cc-claw setup.`);
     process.exit(1);
   }
@@ -32105,9 +32665,9 @@ __export(session_exports, {
   sessionGet: () => sessionGet,
   sessionNew: () => sessionNew
 });
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 async function sessionGet(globalOpts) {
-  if (!existsSync45(DB_PATH)) {
+  if (!existsSync46(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32168,9 +32728,9 @@ __export(permissions_exports, {
   verboseGet: () => verboseGet,
   verboseSet: () => verboseSet
 });
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 function ensureDb2() {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync47(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32317,9 +32877,9 @@ __export(cwd_exports, {
   cwdGet: () => cwdGet,
   cwdSet: () => cwdSet
 });
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 async function cwdGet(globalOpts) {
-  if (!existsSync47(DB_PATH)) {
+  if (!existsSync48(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32381,9 +32941,9 @@ __export(voice_exports, {
   voiceGet: () => voiceGet,
   voiceSet: () => voiceSet
 });
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 async function voiceGet(globalOpts) {
-  if (!existsSync48(DB_PATH)) {
+  if (!existsSync49(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32432,9 +32992,9 @@ __export(heartbeat_exports2, {
   heartbeatGet: () => heartbeatGet,
   heartbeatSet: () => heartbeatSet
 });
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 async function heartbeatGet(globalOpts) {
-  if (!existsSync49(DB_PATH)) {
+  if (!existsSync50(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32645,9 +33205,9 @@ __export(summarizer_exports, {
   summarizerGet: () => summarizerGet,
   summarizerSet: () => summarizerSet
 });
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 async function summarizerGet(globalOpts) {
-  if (!existsSync50(DB_PATH)) {
+  if (!existsSync51(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32691,9 +33251,9 @@ __export(thinking_exports, {
   thinkingGet: () => thinkingGet,
   thinkingSet: () => thinkingSet
 });
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync52 } from "fs";
 async function thinkingGet(globalOpts) {
-  if (!existsSync51(DB_PATH)) {
+  if (!existsSync52(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32737,9 +33297,9 @@ __export(chats_exports, {
   chatsList: () => chatsList,
   chatsRemoveAlias: () => chatsRemoveAlias
 });
-import { existsSync as existsSync52 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 async function chatsList(_globalOpts) {
-  if (!existsSync52(DB_PATH)) {
+  if (!existsSync53(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32867,9 +33427,9 @@ var mcps_exports2 = {};
 __export(mcps_exports2, {
   mcpsList: () => mcpsList
 });
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 async function mcpsList(_globalOpts) {
-  if (!existsSync53(DB_PATH)) {
+  if (!existsSync54(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32906,11 +33466,11 @@ __export(chat_exports2, {
   chatSend: () => chatSend
 });
 import { request as httpRequest2 } from "http";
-import { readFileSync as readFileSync27, existsSync as existsSync54 } from "fs";
+import { readFileSync as readFileSync27, existsSync as existsSync55 } from "fs";
 function getToken2() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync54(TOKEN_PATH2)) return readFileSync27(TOKEN_PATH2, "utf-8").trim();
+    if (existsSync55(TOKEN_PATH2)) return readFileSync27(TOKEN_PATH2, "utf-8").trim();
   } catch {
   }
   return null;
@@ -33398,7 +33958,7 @@ __export(completion_exports, {
   completionCommand: () => completionCommand
 });
 import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync17 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 import { homedir as homedir11 } from "os";
 async function completionCommand(opts) {
   const shell = opts.shell ?? detectShell();
@@ -33414,10 +33974,10 @@ async function completionCommand(opts) {
     process.exit(1);
   }
   if (opts.install) {
-    const dir = join34(homedir11(), ".config", "cc-claw", "completions");
+    const dir = join35(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 = join34(dir, filename);
+    const filepath = join35(dir, filename);
     writeFileSync11(filepath, script, "utf-8");
     console.log(`\u2713 Completion script written to ${filepath}
 `);
@@ -33590,9 +34150,9 @@ __export(evolve_exports2, {
   evolveStatus: () => evolveStatus,
   evolveUndo: () => evolveUndo
 });
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 function ensureDb3() {
-  if (!existsSync55(DB_PATH)) {
+  if (!existsSync56(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -34066,10 +34626,10 @@ var init_optimize2 = __esm({
 
 // src/setup.ts
 var setup_exports = {};
-import { existsSync as existsSync56, writeFileSync as writeFileSync12, readFileSync as readFileSync28, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
+import { existsSync as existsSync57, writeFileSync as writeFileSync12, readFileSync as readFileSync28, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
 import { execFileSync as execFileSync6 } from "child_process";
 import { createInterface as createInterface11 } from "readline";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 function divider2() {
   console.log(dim("\u2500".repeat(55)));
 }
@@ -34144,10 +34704,10 @@ async function setup() {
   }
   console.log("");
   for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-    if (!existsSync56(dir)) mkdirSync18(dir, { recursive: true });
+    if (!existsSync57(dir)) mkdirSync18(dir, { recursive: true });
   }
   const env = {};
-  const envSource = existsSync56(ENV_PATH) ? ENV_PATH : existsSync56(".env") ? ".env" : null;
+  const envSource = existsSync57(ENV_PATH) ? ENV_PATH : existsSync57(".env") ? ".env" : null;
   if (envSource) {
     console.log(yellow(`  Found existing config at ${envSource} \u2014 your values will be preserved`));
     console.log(yellow("  unless you enter new ones. Just press Enter to keep existing values.\n"));
@@ -34157,8 +34717,8 @@ async function setup() {
       if (match) env[match[1].trim()] = match[2].trim();
     }
   }
-  const cwdDb = join35(process.cwd(), "cc-claw.db");
-  if (existsSync56(cwdDb) && !existsSync56(DB_PATH)) {
+  const cwdDb = join36(process.cwd(), "cc-claw.db");
+  if (existsSync57(cwdDb) && !existsSync57(DB_PATH)) {
     const { size } = statSync12(cwdDb);
     console.log(yellow(`  Found existing database at ${cwdDb} (${(size / 1024).toFixed(0)}KB)`));
     const migrate = await confirm("Copy database to ~/.cc-claw/? (preserves memories & history)", true);