cc-claw 0.2.8 → 0.3.1

package/dist/cli.js

@@ -48,7 +48,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.2.8" : (() => {
+    VERSION = true ? "0.3.1" : (() => {
       try {
         return JSON.parse(readFileSync(join2(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -864,10 +864,13 @@ __export(store_exports2, {
   clearThinkingLevel: () => clearThinkingLevel,
   clearUsage: () => clearUsage,
   completeJobRun: () => completeJobRun,
+  deleteBookmark: () => deleteBookmark,
+  findBookmarksByPrefix: () => findBookmarksByPrefix,
   forgetMemory: () => forgetMemory,
   getActiveJobs: () => getActiveJobs,
   getActiveWatches: () => getActiveWatches,
   getAllBackendLimits: () => getAllBackendLimits,
+  getAllBookmarks: () => getAllBookmarks,
   getAllChatAliases: () => getAllChatAliases,
   getAllJobs: () => getAllJobs,
   getAllMemoriesWithEmbeddings: () => getAllMemoriesWithEmbeddings,
@@ -876,6 +879,7 @@ __export(store_exports2, {
   getBackend: () => getBackend,
   getBackendLimit: () => getBackendLimit,
   getBackendUsageInWindow: () => getBackendUsageInWindow,
+  getBookmark: () => getBookmark,
   getChatIdByAlias: () => getChatIdByAlias,
   getChatUsageByModel: () => getChatUsageByModel,
   getCwd: () => getCwd,
@@ -887,6 +891,7 @@ __export(store_exports2, {
   getMemoriesWithoutEmbeddings: () => getMemoriesWithoutEmbeddings,
   getMode: () => getMode,
   getModel: () => getModel,
+  getRecentBookmarks: () => getRecentBookmarks,
   getRecentMemories: () => getRecentMemories,
   getSessionId: () => getSessionId,
   getSessionStartedAt: () => getSessionStartedAt,
@@ -929,13 +934,15 @@ __export(store_exports2, {
   setThinkingLevel: () => setThinkingLevel,
   setVerboseLevel: () => setVerboseLevel,
   toggleTool: () => toggleTool,
+  touchBookmark: () => touchBookmark,
   updateHeartbeatTimestamps: () => updateHeartbeatTimestamps,
   updateJob: () => updateJob,
   updateJobEnabled: () => updateJobEnabled,
   updateJobLastRun: () => updateJobLastRun,
   updateJobNextRun: () => updateJobNextRun,
   updateMemoryEmbedding: () => updateMemoryEmbedding,
-  updateSessionSummaryEmbedding: () => updateSessionSummaryEmbedding
+  updateSessionSummaryEmbedding: () => updateSessionSummaryEmbedding,
+  upsertBookmark: () => upsertBookmark
 });
 import Database from "better-sqlite3";
 function openDatabaseReadOnly() {
@@ -1297,6 +1304,16 @@ function initDatabase() {
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
   `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS cwd_bookmarks (
+      chatId TEXT NOT NULL,
+      alias TEXT NOT NULL,
+      path TEXT NOT NULL,
+      manual INTEGER NOT NULL DEFAULT 0,
+      lastUsed INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (chatId, alias)
+    )
+  `);
   try {
     db.exec("ALTER TABLE memories ADD COLUMN embedding TEXT");
   } catch {
@@ -1491,6 +1508,58 @@ function setCwd(chatId, cwd) {
 function clearCwd(chatId) {
   db.prepare("DELETE FROM chat_cwd WHERE chat_id = ?").run(chatId);
 }
+function upsertBookmark(chatId, alias, path, manual) {
+  const now = Date.now();
+  const existing = db.prepare(
+    "SELECT manual FROM cwd_bookmarks WHERE chatId = ? AND alias = ?"
+  ).get(chatId, alias);
+  if (existing) {
+    if (existing.manual === 1 && !manual) {
+      return;
+    }
+    db.prepare(
+      "UPDATE cwd_bookmarks SET path = ?, manual = ?, lastUsed = ? WHERE chatId = ? AND alias = ?"
+    ).run(path, manual ? 1 : 0, now, chatId, alias);
+  } else {
+    db.prepare(
+      "INSERT INTO cwd_bookmarks (chatId, alias, path, manual, lastUsed) VALUES (?, ?, ?, ?, ?)"
+    ).run(chatId, alias, path, manual ? 1 : 0, now);
+  }
+}
+function touchBookmark(chatId, alias) {
+  db.prepare(
+    "UPDATE cwd_bookmarks SET lastUsed = ? WHERE chatId = ? AND alias = ?"
+  ).run(Date.now(), chatId, alias);
+}
+function getBookmark(chatId, alias) {
+  const row = db.prepare(
+    "SELECT alias, path, manual FROM cwd_bookmarks WHERE chatId = ? AND alias = ?"
+  ).get(chatId, alias);
+  return row ? { alias: row.alias, path: row.path, manual: row.manual === 1 } : void 0;
+}
+function getRecentBookmarks(chatId, limit = 10) {
+  return db.prepare(
+    "SELECT alias, path FROM cwd_bookmarks WHERE chatId = ? ORDER BY lastUsed DESC LIMIT ?"
+  ).all(chatId, limit);
+}
+function findBookmarksByPrefix(chatId, prefix) {
+  return db.prepare(
+    "SELECT alias, path FROM cwd_bookmarks WHERE chatId = ? AND alias LIKE ? || '%'"
+  ).all(chatId, prefix);
+}
+function deleteBookmark(chatId, alias) {
+  const result = db.prepare(
+    "DELETE FROM cwd_bookmarks WHERE chatId = ? AND alias = ?"
+  ).run(chatId, alias);
+  return result.changes > 0;
+}
+function getAllBookmarks(chatId) {
+  return db.prepare(
+    "SELECT alias, path, manual FROM cwd_bookmarks WHERE chatId = ? ORDER BY alias"
+  ).all(chatId).map(
+    (r) => ({ alias: r.alias, path: r.path, manual: r.manual === 1 })
+  );
+}
 function getModel(chatId) {
   const row = db.prepare(
     "SELECT model FROM chat_model WHERE chat_id = ?"
@@ -2199,13 +2268,13 @@ var init_claude = __esm({
       displayName = "Claude";
       availableModels = {
         "claude-opus-4-6": {
-          label: "Opus 4.6 \u2014 most capable",
+          label: "Opus 4.6 \u2014 most capable, 1M context",
           thinking: "adjustable",
           thinkingLevels: ["auto", "off", "low", "medium", "high"],
           defaultThinkingLevel: "medium"
         },
         "claude-sonnet-4-6": {
-          label: "Sonnet 4.6 \u2014 balanced (default)",
+          label: "Sonnet 4.6 \u2014 balanced (default), 1M context",
           thinking: "adjustable",
           thinkingLevels: ["auto", "off", "low", "medium", "high"],
           defaultThinkingLevel: "medium"
@@ -2225,8 +2294,8 @@ var init_claude = __esm({
         "claude-haiku-4-5": { in: 0.8, out: 4, cache: 0.08 }
       };
       contextWindow = {
-        "claude-opus-4-6": 2e5,
-        "claude-sonnet-4-6": 2e5,
+        "claude-opus-4-6": 1e6,
+        "claude-sonnet-4-6": 1e6,
         "claude-haiku-4-5": 2e5
       };
       _resolvedPath = "";
@@ -4035,6 +4104,9 @@ async function startAgent(agentId, chatId, opts) {
   }
   let mcpExtraArgs = [];
   let orchestratorMcpName = "";
+  if (process.env.DASHBOARD_ENABLED !== "1") {
+    warn(`[orchestrator] DASHBOARD_ENABLED is not set \u2014 agent ${agentId.slice(0, 8)} will NOT have orchestrator MCP tools (set_state, send_message, etc.)`);
+  }
   if (process.env.DASHBOARD_ENABLED === "1") {
     try {
       const { createSubAgentToken: createSubAgentToken2 } = await Promise.resolve().then(() => (init_server(), server_exports));
@@ -4054,6 +4126,9 @@ async function startAgent(agentId, chatId, opts) {
         });
         mcpsAdded = [...mcpsAdded, orchestratorMcpName];
         updateAgentMcpsAdded(db3, agentId, mcpsAdded);
+        if (runner.id === "gemini") {
+          mcpExtraArgs = [`--allowed-mcp-server-names=${orchestratorMcpName}`];
+        }
         log(`[orchestrator] Injected cc-claw MCP via add-remove for agent ${agentId.slice(0, 8)}`);
       }
     } catch (err) {
@@ -8278,6 +8353,180 @@ var init_video = __esm({
   }
 });
 
+// src/shell/guard.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function isDestructive(command) {
+  return DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(command));
+}
+function storePendingCommand(command, chatId, raw) {
+  const id = randomUUID2().slice(0, 8);
+  pendingCommands.set(id, { command, chatId, raw, createdAt: Date.now() });
+  setTimeout(() => pendingCommands.delete(id), PENDING_TTL_MS);
+  return id;
+}
+function getPendingCommand(id) {
+  return pendingCommands.get(id);
+}
+function removePendingCommand(id) {
+  return pendingCommands.delete(id);
+}
+var DESTRUCTIVE_PATTERNS, pendingCommands, PENDING_TTL_MS;
+var init_guard = __esm({
+  "src/shell/guard.ts"() {
+    "use strict";
+    DESTRUCTIVE_PATTERNS = [
+      /\brm\s+(-[a-zA-Z]*[fr][a-zA-Z]*|-[a-zA-Z]*[rf][a-zA-Z]*|--force|--recursive)\b/,
+      /\brm\s+-[a-zA-Z]*\s+\/\s*$/,
+      /\bmkfs\b/,
+      /\bdd\b.*\bof=/,
+      /\b(shutdown|reboot|halt|poweroff)\b/,
+      />\s*\/dev\/sd/,
+      /\bchmod\s+-R\s+777\b/,
+      /\bchown\s+-R\b/,
+      /\bkillall\b/,
+      /\blaunchctl\s+(unload|remove)\b/,
+      /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;?\s*:/
+    ];
+    pendingCommands = /* @__PURE__ */ new Map();
+    PENDING_TTL_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/shell/exec.ts
+import { execFile as execFile3 } from "child_process";
+function executeShell(command, cwd, timeoutMs = SHELL_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    execFile3(
+      "/bin/zsh",
+      ["-c", command],
+      { cwd, timeout: timeoutMs, maxBuffer: 5 * 1024 * 1024 },
+      (error3, stdout, stderr) => {
+        const output2 = (stdout || "") + (stderr || "");
+        if (error3 && "killed" in error3 && error3.killed) {
+          resolve({
+            output: `Command timed out after ${Math.round(timeoutMs / 1e3)} seconds`,
+            exitCode: 124,
+            timedOut: true
+          });
+          return;
+        }
+        const exitCode = error3 ? typeof error3.code === "number" ? error3.code : 1 : 0;
+        resolve({
+          output: output2,
+          exitCode,
+          timedOut: false
+        });
+      }
+    );
+  });
+}
+function formatCodeBlock(command, output2, exitCode) {
+  return `<pre>$ ${command}
+${output2}
+[exit ${exitCode}]</pre>`;
+}
+function formatRaw(output2) {
+  return output2.trim();
+}
+function shouldSendAsFile(output2) {
+  return output2.length > OUTPUT_MAX_LENGTH;
+}
+var SHELL_TIMEOUT_MS, OUTPUT_MAX_LENGTH;
+var init_exec = __esm({
+  "src/shell/exec.ts"() {
+    "use strict";
+    SHELL_TIMEOUT_MS = 6e4;
+    OUTPUT_MAX_LENGTH = 4e3;
+  }
+});
+
+// src/shell/backend-cmd.ts
+import { execFile as execFile4 } from "child_process";
+function buildNativeResponse(backendId, command, output2) {
+  const body = output2 || "(no output)";
+  return `<pre>[${backendId}] ${command}
+${body}</pre>`;
+}
+function extractTextFromNdjson(raw) {
+  const texts = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === "result" && obj.result) {
+        texts.push(typeof obj.result === "string" ? obj.result : JSON.stringify(obj.result));
+      }
+      if (obj.type === "assistant" && obj.message?.content) {
+        for (const block of obj.message.content) {
+          if (block.type === "text" && block.text) texts.push(block.text);
+        }
+      }
+      if (obj.type === "text" && obj.text) {
+        texts.push(obj.text);
+      }
+    } catch {
+    }
+  }
+  return texts.join("\n").trim();
+}
+async function handleBackendCommand(command, chatId, channel) {
+  let adapter;
+  try {
+    adapter = getAdapterForChat(chatId);
+  } catch {
+    await channel.sendText(chatId, "No backend set. Use /backend first.", "plain");
+    return;
+  }
+  const sessionId = getSessionId(chatId);
+  if (!sessionId) {
+    await channel.sendText(chatId, "No active session. Start a conversation first.", "plain");
+    return;
+  }
+  const cwd = getCwd(chatId) ?? `${process.env.HOME ?? "/tmp"}/.cc-claw/workspace`;
+  try {
+    const output2 = await spawnBackendCommand(adapter, command, sessionId, cwd);
+    const formatted = buildNativeResponse(adapter.id, command, output2);
+    await channel.sendText(chatId, formatted, "html");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    await channel.sendText(chatId, `Backend command failed: ${msg}`, "plain");
+  }
+}
+function spawnBackendCommand(adapter, command, sessionId, cwd) {
+  return new Promise((resolve, reject) => {
+    const config2 = adapter.buildSpawnConfig({
+      prompt: command,
+      sessionId,
+      cwd,
+      permMode: "plan",
+      allowedTools: []
+    });
+    const env = { ...process.env, ...adapter.getEnv() };
+    execFile4(config2.executable, config2.args, {
+      cwd,
+      timeout: BACKEND_CMD_TIMEOUT_MS,
+      env,
+      maxBuffer: 5 * 1024 * 1024
+    }, (error3, stdout, stderr) => {
+      if (error3 && "killed" in error3 && error3.killed) {
+        reject(new Error(`Backend command timed out after ${BACKEND_CMD_TIMEOUT_MS / 1e3} seconds.`));
+        return;
+      }
+      const output2 = extractTextFromNdjson(stdout) || stdout || stderr || "";
+      resolve(output2.trim());
+    });
+  });
+}
+var BACKEND_CMD_TIMEOUT_MS;
+var init_backend_cmd = __esm({
+  "src/shell/backend-cmd.ts"() {
+    "use strict";
+    init_backends();
+    init_store4();
+    BACKEND_CMD_TIMEOUT_MS = 15e3;
+  }
+});
+
 // src/router.ts
 import { readFile as readFile5, writeFile as writeFile2, unlink as unlink2 } from "fs/promises";
 import { resolve as resolvePath } from "path";
@@ -8367,6 +8616,17 @@ async function handleMessage(msg, channel) {
       }
     }
   }
+  if (msg.type === "text" && msg.text) {
+    const text = msg.text.trim();
+    if (text.startsWith("!!")) {
+      const cmd = text.slice(2).trim();
+      if (cmd) return handleRawShell(cmd, chatId, channel);
+    }
+    if (text.startsWith("!") && text.length > 1) {
+      const cmd = text.slice(1).trim();
+      if (cmd) return handleShell(cmd, chatId, channel);
+    }
+  }
   switch (msg.type) {
     case "command":
       await handleCommand(msg, channel);
@@ -8386,6 +8646,9 @@ async function handleMessage(msg, channel) {
 }
 async function handleCommand(msg, channel) {
   const { chatId, command, commandArgs } = msg;
+  if (command?.startsWith("/")) {
+    return handleBackendCommand(command, chatId, channel);
+  }
   switch (command) {
     case "start":
     case "help":
@@ -8520,15 +8783,7 @@ Tap to toggle:`,
     case "backend": {
       const requestedBackend = (commandArgs ?? "").trim().toLowerCase();
       if (requestedBackend && getAllBackendIds().includes(requestedBackend)) {
-        summarizeSession(chatId).catch(() => {
-        });
-        clearSession(chatId);
-        clearModel(chatId);
-        clearThinkingLevel(chatId);
-        setBackend(chatId, requestedBackend);
-        const adapter = getAdapter(requestedBackend);
-        logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Backend switched to ${adapter.displayName}`, detail: { field: "backend", value: requestedBackend } });
-        await channel.sendText(chatId, `Switched to <b>${adapter.displayName}</b>.`, "html");
+        await sendBackendSwitchConfirmation(chatId, requestedBackend, channel);
         break;
       }
       const currentBackend = getBackend(chatId);
@@ -8552,15 +8807,7 @@ Tap to toggle:`,
     case "codex": {
       const backendId = command;
       if (getAllBackendIds().includes(backendId)) {
-        summarizeSession(chatId).catch(() => {
-        });
-        clearSession(chatId);
-        clearModel(chatId);
-        clearThinkingLevel(chatId);
-        setBackend(chatId, backendId);
-        const adapter = getAdapter(backendId);
-        logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Backend switched to ${adapter.displayName}`, detail: { field: "backend", value: backendId } });
-        await channel.sendText(chatId, `Switched to <b>${adapter.displayName}</b>.`, "html");
+        await sendBackendSwitchConfirmation(chatId, backendId, channel);
       } else {
         await channel.sendText(chatId, `Backend "${command}" is not available.`, "plain");
       }
@@ -8733,11 +8980,28 @@ Use /summarizer auto, /summarizer off, or /summarizer <backend>:<model>`, "plain
     case "cwd": {
       if (!commandArgs) {
         const current = getCwd(chatId);
-        await channel.sendText(
-          chatId,
-          current ? `Working directory: ${current}` : "No working directory set. Usage: /cwd ~/projects/my-app",
-          "plain"
-        );
+        const recents = getRecentBookmarks(chatId, 10);
+        if (recents.length === 0) {
+          await channel.sendText(
+            chatId,
+            current ? `Working directory: ${current}
+
+No saved bookmarks yet. Set a directory with /cwd <path> to auto-save.` : "No working directory set. Usage: /cwd ~/projects/my-app",
+            "plain"
+          );
+          return;
+        }
+        const text = current ? `Current: ${current}
+
+Recent directories:` : "Recent directories:";
+        if (typeof channel.sendKeyboard === "function") {
+          const buttons = recents.map((r) => [{ label: r.alias, data: `cwdpick:${r.alias}` }]);
+          await channel.sendKeyboard(chatId, text, buttons);
+        } else {
+          const list = recents.map((r) => `  ${r.alias} \u2192 ${r.path}`).join("\n");
+          await channel.sendText(chatId, `${text}
+${list}`, "plain");
+        }
         return;
       }
       if (commandArgs === "reset" || commandArgs === "clear") {
@@ -8745,12 +9009,71 @@ Use /summarizer auto, /summarizer off, or /summarizer <backend>:<model>`, "plain
         await channel.sendText(chatId, "Working directory cleared. Using default.", "plain");
         return;
       }
-      const resolvedPath = commandArgs.startsWith("~") ? commandArgs.replace("~", process.env.HOME ?? "") : commandArgs;
-      setCwd(chatId, resolvedPath);
-      clearSession(chatId);
-      logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Working directory set to ${resolvedPath}`, detail: { field: "cwd", value: resolvedPath } });
-      await channel.sendText(chatId, `Working directory set to: ${resolvedPath}
-Session reset for new context.`, "plain");
+      if (commandArgs === "aliases") {
+        const all = getAllBookmarks(chatId);
+        if (all.length === 0) {
+          await channel.sendText(chatId, "No bookmarks saved yet.", "plain");
+          return;
+        }
+        const lines = all.map((b) => `  ${b.manual ? "[manual]" : "[auto]"} ${b.alias} \u2192 ${b.path}`);
+        await channel.sendText(chatId, `Directory bookmarks:
+${lines.join("\n")}`, "plain");
+        return;
+      }
+      if (commandArgs.startsWith("unalias ")) {
+        const aliasName = commandArgs.slice(8).trim();
+        if (!aliasName) {
+          await channel.sendText(chatId, "Usage: /cwd unalias <name>", "plain");
+          return;
+        }
+        const deleted = deleteBookmark(chatId, aliasName);
+        await channel.sendText(chatId, deleted ? `Bookmark '${aliasName}' removed.` : `Bookmark '${aliasName}' not found.`, "plain");
+        return;
+      }
+      if (commandArgs.startsWith("alias ")) {
+        const parts = commandArgs.slice(6).trim().split(/\s+/);
+        if (parts.length < 2) {
+          await channel.sendText(chatId, "Usage: /cwd alias <name> <path>", "plain");
+          return;
+        }
+        const [aliasName, ...pathParts] = parts;
+        const aliasPath = pathParts.join(" ").replace(/^~/, process.env.HOME ?? "");
+        upsertBookmark(chatId, aliasName, aliasPath, true);
+        await channel.sendText(chatId, `Bookmark saved: ${aliasName} \u2192 ${aliasPath}`, "plain");
+        return;
+      }
+      const arg = commandArgs;
+      if (arg.startsWith("/") || arg.startsWith("~")) {
+        const resolvedPath = arg.startsWith("~") ? arg.replace("~", process.env.HOME ?? "") : arg;
+        setCwd(chatId, resolvedPath);
+        const basename2 = resolvedPath.split("/").filter(Boolean).pop();
+        if (basename2) upsertBookmark(chatId, basename2, resolvedPath, false);
+        logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Working directory set to ${resolvedPath}`, detail: { field: "cwd", value: resolvedPath } });
+        await sendCwdSessionChoice(chatId, resolvedPath, channel);
+        return;
+      }
+      const exact = getBookmark(chatId, arg);
+      if (exact) {
+        setCwd(chatId, exact.path);
+        touchBookmark(chatId, arg);
+        logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Working directory set to ${exact.path}`, detail: { field: "cwd", value: exact.path } });
+        await sendCwdSessionChoice(chatId, exact.path, channel);
+        return;
+      }
+      const matches = findBookmarksByPrefix(chatId, arg);
+      if (matches.length === 1) {
+        setCwd(chatId, matches[0].path);
+        touchBookmark(chatId, matches[0].alias);
+        logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Working directory set to ${matches[0].path}`, detail: { field: "cwd", value: matches[0].path } });
+        await sendCwdSessionChoice(chatId, matches[0].path, channel);
+        return;
+      }
+      if (matches.length > 1 && typeof channel.sendKeyboard === "function") {
+        const buttons = matches.map((m) => [{ label: `${m.alias} \u2192 ${m.path}`, data: `cwdpick:${m.alias}` }]);
+        await channel.sendKeyboard(chatId, `Multiple matches for "${arg}":`, buttons);
+        return;
+      }
+      await channel.sendText(chatId, `Directory alias '${arg}' not found. Use /cwd aliases to see saved bookmarks.`, "plain");
       break;
     }
     case "memory": {
@@ -9255,7 +9578,7 @@ Use /skills to see it.`, "plain");
         lines.push("", "\u2501\u2501 <b>Built-in</b> \u2501\u2501");
         lines.push(`  \u2705 <b>cc-claw</b>  <i>Agent orchestrator (spawn, tasks, inbox)</i>`);
       }
-      const { execFile: execFile3 } = await import("child_process");
+      const { execFile: execFile5 } = await import("child_process");
       const { homedir: homedir5 } = await import("os");
       const discoveryCwd = homedir5();
       const runnerResults = await Promise.allSettled(
@@ -9264,7 +9587,7 @@ Use /skills to see it.`, "plain");
           if (!listCmd.length) return Promise.resolve({ runner, output: "" });
           const exe = runner.getExecutablePath();
           return new Promise((resolve) => {
-            execFile3(exe, listCmd.slice(1), {
+            execFile5(exe, listCmd.slice(1), {
               encoding: "utf-8",
               timeout: 3e4,
               cwd: discoveryCwd,
@@ -9711,31 +10034,65 @@ async function sendResponse(chatId, channel, text) {
 function isImageExt(ext) {
   return ["jpg", "jpeg", "png", "gif", "webp", "bmp", "svg"].includes(ext);
 }
+async function sendBackendSwitchConfirmation(chatId, target, channel) {
+  const current = getBackend(chatId);
+  const targetAdapter = getAdapter(target);
+  if (current === target) {
+    await channel.sendText(chatId, `Already using ${targetAdapter.displayName}.`, "plain");
+    return;
+  }
+  const currentLabel = current ? getAdapter(current).displayName : "current backend";
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendKeyboard(
+      chatId,
+      `\u26A0\uFE0F Switching to ${targetAdapter.displayName} will summarize and reset your current session.
+
+What would you like to do?`,
+      [
+        [{ label: `Stay on ${currentLabel}`, data: "backend_cancel" }],
+        [{ label: `Switch to ${targetAdapter.displayName} + summarize`, data: `backend_confirm:${target}` }]
+      ]
+    );
+  } else {
+    await doBackendSwitch(chatId, target, channel);
+  }
+}
+async function doBackendSwitch(chatId, backendId, channel) {
+  summarizeSession(chatId).catch(() => {
+  });
+  clearSession(chatId);
+  clearModel(chatId);
+  clearThinkingLevel(chatId);
+  setBackend(chatId, backendId);
+  const adapter = getAdapter(backendId);
+  logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Backend switched to ${adapter.displayName}`, detail: { field: "backend", value: backendId } });
+  await channel.sendText(
+    chatId,
+    `Backend switched to ${adapter.displayName}.
+Default model: ${adapter.defaultModel}
+Session reset. Ready!`,
+    "plain"
+  );
+}
 async function handleCallback(chatId, data, channel) {
   if (data.startsWith("backend:")) {
     const chosen = data.slice(8);
     if (!getAllBackendIds().includes(chosen)) return;
     const previous = getBackend(chatId);
     if (chosen === previous) {
-      const adapter2 = getAdapter(chosen);
-      await channel.sendText(chatId, `Already using ${adapter2.displayName}.`, "plain");
+      const adapter = getAdapter(chosen);
+      await channel.sendText(chatId, `Already using ${adapter.displayName}.`, "plain");
       return;
     }
-    summarizeSession(chatId).catch(() => {
-    });
-    clearSession(chatId);
-    clearModel(chatId);
-    clearThinkingLevel(chatId);
-    setBackend(chatId, chosen);
-    const adapter = getAdapter(chosen);
-    logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Backend switched to ${adapter.displayName}`, detail: { field: "backend", value: chosen } });
-    await channel.sendText(
-      chatId,
-      `Backend switched to ${adapter.displayName}.
-Default model: ${adapter.defaultModel}
-Session reset. Ready!`,
-      "plain"
-    );
+    await sendBackendSwitchConfirmation(chatId, chosen, channel);
+  } else if (data.startsWith("backend_confirm:")) {
+    const chosen = data.slice(16);
+    if (!getAllBackendIds().includes(chosen)) return;
+    await doBackendSwitch(chatId, chosen, channel);
+  } else if (data === "backend_cancel") {
+    const current = getBackend(chatId);
+    const label2 = current ? getAdapter(current).displayName : "current backend";
+    await channel.sendText(chatId, `No change. Staying on ${label2}.`, "plain");
   } else if (data.startsWith("model:")) {
     const chosen = data.slice(6);
     let adapter;
@@ -9834,6 +10191,51 @@ ${PERM_MODES[chosen]}`,
     } else {
       await channel.sendText(chatId, "Preference not saved.", "plain");
     }
+  } else if (data.startsWith("shell:")) {
+    const parts = data.split(":");
+    const action = parts[1];
+    const id = parts[2];
+    if (action === "confirm") {
+      const pending = getPendingCommand(id);
+      if (!pending) {
+        await channel.sendText(chatId, "Confirmation expired. Please re-send the command.", "plain");
+        return;
+      }
+      removePendingCommand(id);
+      if (pending.raw) {
+        await handleRawShell(pending.command, pending.chatId, channel, true);
+      } else {
+        await handleShell(pending.command, pending.chatId, channel, true);
+      }
+    } else if (action === "cancel") {
+      removePendingCommand(id);
+      await channel.sendText(chatId, "Command cancelled.", "plain");
+    }
+  } else if (data.startsWith("cwd:")) {
+    const parts = data.split(":");
+    const action = parts[1];
+    const targetChatId = parts.slice(2).join(":");
+    if (action === "keep") {
+      await channel.sendText(chatId, "Session kept. The agent will continue with existing context.", "plain");
+    } else if (action === "summarize") {
+      await summarizeSession(targetChatId);
+      clearSession(targetChatId);
+      await channel.sendText(chatId, "Session summarized and reset. Context preserved in memory.", "plain");
+    } else if (action === "reset") {
+      clearSession(targetChatId);
+      await channel.sendText(chatId, "Session reset. Clean slate.", "plain");
+    }
+  } else if (data.startsWith("cwdpick:")) {
+    const alias = data.slice(8);
+    const bookmark = getBookmark(chatId, alias);
+    if (!bookmark) {
+      await channel.sendText(chatId, `Bookmark '${alias}' no longer exists.`, "plain");
+      return;
+    }
+    setCwd(chatId, bookmark.path);
+    touchBookmark(chatId, alias);
+    logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: `Working directory set to ${bookmark.path}`, detail: { field: "cwd", value: bookmark.path } });
+    await sendCwdSessionChoice(chatId, bookmark.path, channel);
   } else if (data.startsWith("skill:")) {
     const parts = data.slice(6).split(":");
     let skillName;
@@ -9871,6 +10273,101 @@ ${PERM_MODES[chosen]}`,
     await sendResponse(chatId, channel, response.text);
   }
 }
+async function handleShell(command, chatId, channel, skipGuard = false) {
+  if (!skipGuard && isDestructive(command)) {
+    const id = storePendingCommand(command, chatId, false);
+    if (typeof channel.sendKeyboard === "function") {
+      await channel.sendKeyboard(
+        chatId,
+        `\u26A0\uFE0F This command looks potentially destructive.
+
+Command: ${command}`,
+        [[
+          { label: "Run anyway", data: `shell:confirm:${id}` },
+          { label: "Cancel", data: `shell:cancel:${id}` }
+        ]]
+      );
+    } else {
+      await channel.sendText(chatId, `\u26A0\uFE0F Destructive command blocked: ${command}
+No keyboard available to confirm.`, "plain");
+    }
+    return;
+  }
+  const cwd = getCwd(chatId) ?? `${process.env.HOME ?? "/tmp"}/.cc-claw/workspace`;
+  const result = await executeShell(command, cwd);
+  logActivity(getDb(), {
+    chatId,
+    source: "telegram",
+    eventType: "shell_command",
+    summary: `Shell: ${command.slice(0, 100)}`,
+    detail: { command, exitCode: result.exitCode, outputLength: result.output.length, timedOut: result.timedOut }
+  });
+  const formatted = formatCodeBlock(command, result.output, result.exitCode);
+  if (shouldSendAsFile(formatted)) {
+    const buffer = Buffer.from(result.output, "utf-8");
+    await channel.sendFile(chatId, buffer, "output.txt", "text/plain");
+    await channel.sendText(chatId, `Output too long (${result.output.length} chars), sent as file.`, "plain");
+  } else {
+    await channel.sendText(chatId, formatted, "html");
+  }
+}
+async function handleRawShell(command, chatId, channel, skipGuard = false) {
+  if (!skipGuard && isDestructive(command)) {
+    const id = storePendingCommand(command, chatId, true);
+    if (typeof channel.sendKeyboard === "function") {
+      await channel.sendKeyboard(
+        chatId,
+        `\u26A0\uFE0F This command looks potentially destructive.
+
+Command: ${command}`,
+        [[
+          { label: "Run anyway", data: `shell:confirm:${id}` },
+          { label: "Cancel", data: `shell:cancel:${id}` }
+        ]]
+      );
+    } else {
+      await channel.sendText(chatId, `\u26A0\uFE0F Destructive command blocked: ${command}
+No keyboard available to confirm.`, "plain");
+    }
+    return;
+  }
+  const cwd = getCwd(chatId) ?? `${process.env.HOME ?? "/tmp"}/.cc-claw/workspace`;
+  const result = await executeShell(command, cwd);
+  logActivity(getDb(), {
+    chatId,
+    source: "telegram",
+    eventType: "shell_command",
+    summary: `Shell: ${command.slice(0, 100)}`,
+    detail: { command, exitCode: result.exitCode, outputLength: result.output.length, timedOut: result.timedOut }
+  });
+  const formatted = formatRaw(result.output);
+  if (shouldSendAsFile(formatted)) {
+    const buffer = Buffer.from(result.output, "utf-8");
+    await channel.sendFile(chatId, buffer, "output.txt", "text/plain");
+    await channel.sendText(chatId, `Output too long (${result.output.length} chars), sent as file.`, "plain");
+  } else {
+    await channel.sendText(chatId, formatted, "plain");
+  }
+}
+async function sendCwdSessionChoice(chatId, path, channel) {
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendKeyboard(
+      chatId,
+      `Working directory set to: ${path}
+
+Changing directories mid-session may confuse the agent.
+What would you like to do?`,
+      [[
+        { label: "Keep session", data: `cwd:keep:${chatId}` },
+        { label: "Summarize & reset", data: `cwd:summarize:${chatId}` },
+        { label: "Reset session", data: `cwd:reset:${chatId}` }
+      ]]
+    );
+  } else {
+    await channel.sendText(chatId, `Working directory set to: ${path}
+Session kept.`, "plain");
+  }
+}
 function parseIntervalToMs(input) {
   const match = input.trim().match(/^(\d+)\s*(m|min|h|hr|hour|s|sec)$/i);
   if (!match) return null;
@@ -9938,6 +10435,9 @@ var init_router = __esm({
     init_registry();
     init_registry2();
     init_store3();
+    init_guard();
+    init_exec();
+    init_backend_cmd();
     PERM_MODES = {
       yolo: "YOLO \u2014 all tools, full autopilot",
       safe: "Safe \u2014 only my allowed tools",
@@ -11520,7 +12020,7 @@ async function doctorCommand(globalOpts, localOpts) {
     const r = d;
     const lines = [
       "",
-      box("CC-Claw Doctor"),
+      box(`CC-Claw Doctor v${VERSION}`),
       ""
     ];
     for (const c of r.checks) {
@@ -11550,6 +12050,7 @@ var init_doctor = __esm({
     "use strict";
     init_format();
     init_paths();
+    init_version();
   }
 });
 

package/package.json

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