seclaw 0.1.9 → 0.1.11

package/dist/cli.js

@@ -331,9 +331,9 @@ function openUrl(url) {
   });
 }
 function discoverInstalledTemplates(targetDir) {
-  const templates = [];
+  const templates2 = [];
   const templatesDir = join(targetDir, "templates");
-  if (!existsSync2(templatesDir)) return templates;
+  if (!existsSync2(templatesDir)) return templates2;
   try {
     const entries = readdirSync(templatesDir);
     for (const entry of entries) {
@@ -342,7 +342,7 @@ function discoverInstalledTemplates(targetDir) {
       if (!existsSync2(manifestPath)) continue;
       try {
         const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-        templates.push({
+        templates2.push({
           id: manifest.id || entry,
           name: manifest.name || entry,
           description: manifest.description || "",
@@ -353,7 +353,7 @@ function discoverInstalledTemplates(targetDir) {
     }
   } catch {
   }
-  return templates;
+  return templates2;
 }
 function readComposioLocalKey() {
   try {
@@ -2561,6 +2561,75 @@ async function upgrade() {
   p9.outro("Upgrade complete!");
 }
 
+// src/commands/templates.ts
+import { resolve as resolve12 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import * as p10 from "@clack/prompts";
+import pc10 from "picocolors";
+async function templates() {
+  const { configDir, installed } = await loadInstalled();
+  if (!installed || installed.capabilities.length === 0) {
+    p10.intro(`${pc10.bgCyan(pc10.black(" seclaw "))} Templates`);
+    p10.log.warning("No templates installed.");
+    p10.log.info(`Add one: ${pc10.cyan("npx seclaw add <template>")}`);
+    p10.log.info(`Browse:  ${pc10.cyan("https://seclawai.com/templates")}`);
+    p10.outro("");
+    return;
+  }
+  const capabilities = installed.capabilities;
+  const activeMode = installed.active || "auto";
+  p10.intro(`${pc10.bgCyan(pc10.black(" seclaw "))} Installed Templates (${capabilities.length})`);
+  for (const capId of capabilities) {
+    const displayName = capId.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    const promptPath = resolve12(configDir, "capabilities", capId, "system-prompt.md");
+    const hasPrompt = existsSync9(promptPath);
+    const schedPath = resolve12(configDir, "capabilities", capId, "schedules.json");
+    let schedCount = 0;
+    if (existsSync9(schedPath)) {
+      try {
+        const schedData = JSON.parse(await readFile9(schedPath, "utf-8"));
+        schedCount = schedData.schedules.filter((s) => s.enabled !== false).length;
+      } catch {
+      }
+    }
+    const icon = hasPrompt ? pc10.green("\u2713") : pc10.yellow("\u26A0");
+    const schedLabel = schedCount > 0 ? pc10.dim(` \u2014 ${schedCount} schedule${schedCount > 1 ? "s" : ""}`) : "";
+    p10.log.info(`${icon} ${pc10.bold(displayName)}${schedLabel}`);
+  }
+  let modeLabel;
+  if (activeMode === "auto") {
+    modeLabel = `Auto \u2014 all ${capabilities.length} capabilities active`;
+  } else {
+    const activeName = activeMode.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    modeLabel = `${activeName} (focus mode)`;
+  }
+  p10.log.info("");
+  p10.log.info(`Mode: ${pc10.cyan(modeLabel)}`);
+  if (capabilities.length >= 2) {
+    p10.log.info(`Switch: ${pc10.dim("npx seclaw switch")}`);
+  }
+  p10.outro("");
+}
+async function loadInstalled() {
+  let wsHostPath = "shared";
+  try {
+    const envContent = await readFile9(resolve12(process.cwd(), ".env"), "utf-8");
+    const wsMatch = envContent.match(/WORKSPACE_HOST_PATH=(.+)/);
+    if (wsMatch?.[1]?.trim()) wsHostPath = wsMatch[1].trim();
+  } catch {
+  }
+  const configDir = resolve12(process.cwd(), wsHostPath, "config");
+  const installedPath = resolve12(configDir, "installed.json");
+  if (!existsSync9(installedPath)) return { configDir, installed: null };
+  try {
+    const installed = JSON.parse(await readFile9(installedPath, "utf-8"));
+    return { configDir, installed };
+  } catch {
+    return { configDir, installed: null };
+  }
+}
+
 // src/cli.ts
 program.name("seclaw").description("Secure autonomous AI agents in 60 seconds").version("0.1.0");
 program.command("create", { isDefault: true }).alias("init").description("Set up a new seclaw project").argument("[directory]", "Project directory", ".").action(create);
@@ -2571,4 +2640,5 @@ program.command("stop").description("Stop all services").action(stop);
 program.command("reconnect").description("Reconnect tunnel + Telegram webhook").action(reconnect);
 program.command("doctor").description("Diagnose and fix common issues").action(doctor);
 program.command("upgrade").description("Pull latest images and restart").action(upgrade);
+program.command("templates").description("List installed templates and capabilities").action(templates);
 program.parse();

package/dist/runtime/agent.js

@@ -251,7 +251,7 @@ function truncateToolResult(text) {
 }
 
 // telegram.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
 import { resolve as resolve4, dirname } from "path";
 
 // tools.ts
@@ -342,7 +342,8 @@ async function initTools(config2) {
   };
   const advancedTools = [
     createTriggerScheduleTool(config2, ctx),
-    createScheduleActionTool(config2)
+    createScheduleActionTool(config2),
+    createConnectIntegrationTool(config2, ctx)
   ];
   for (const t of advancedTools) {
     allTools.push(t.definition);
@@ -548,6 +549,7 @@ function createBuiltinTools(config2) {
         const delay = Math.min(Math.max(args.delay_seconds || 0, 0), 3600);
         if (!chatId) return "Error: no chat_id provided.";
         const confirmId = `confirm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        console.log(`[confirm] Created: ${confirmId} | action: ${onApprove.substring(0, 60)}`);
         pendingConfirmations.set(confirmId, {
           chatId,
           onApprove,
@@ -1018,6 +1020,85 @@ function createScheduleActionTool(config2) {
     }
   };
 }
+function createConnectIntegrationTool(config2, ctx) {
+  return {
+    definition: {
+      name: "connect_integration",
+      description: "Connect a new integration (Twitter, Reddit, YouTube, Tavily, Gmail, etc.) via OAuth. Returns an authorization URL that the user must open to grant access. Call this when you need an integration that isn't connected yet. After the user completes authorization, their tools become available automatically.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          integration_key: {
+            type: "string",
+            description: "Integration to connect. Available: " + Object.entries(INTEGRATIONS).map(([k, v]) => `${k} (${v.hint})`).join(", ")
+          }
+        },
+        required: ["integration_key"]
+      }
+    },
+    execute: async (_name, args) => {
+      const key = args.integration_key;
+      const apiKey = config2.composioApiKey;
+      if (!apiKey) {
+        return "Error: Composio API key is not configured. Set COMPOSIO_API_KEY in .env";
+      }
+      const integration = INTEGRATIONS[key];
+      if (!integration) {
+        const available = Object.keys(INTEGRATIONS).join(", ");
+        return `Unknown integration "${key}". Available: ${available}`;
+      }
+      try {
+        const activeConnections = await getActiveConnections(apiKey);
+        if (activeConnections.has(integration.app)) {
+          await ctx.reloadComposio();
+          return `${integration.name} is already connected. Tools have been reloaded.`;
+        }
+        const configRes = await composioFetch(apiKey, `/auth_configs?appName=${integration.app}`);
+        const matchingConfig = (configRes.items || []).find(
+          (c) => c.toolkit?.slug === integration.app
+        );
+        let authConfigId;
+        if (matchingConfig) {
+          authConfigId = matchingConfig.id;
+        } else {
+          const created = await composioFetch(apiKey, "/auth_configs", {
+            method: "POST",
+            body: JSON.stringify({ toolkit: { slug: integration.app } })
+          });
+          authConfigId = created.auth_config?.id ?? created.id;
+        }
+        const entityId = config2.composioUserId || "default";
+        const connection = await composioFetch(apiKey, "/connected_accounts", {
+          method: "POST",
+          body: JSON.stringify({
+            auth_config: { id: authConfigId },
+            connection: { entity_id: entityId }
+          })
+        });
+        const redirectUrl = connection.redirect_url || connection.redirect_uri;
+        if (redirectUrl) {
+          console.log(`[connect_integration] ${integration.name} OAuth URL generated`);
+          return `Authorization link for ${integration.name}:
+${redirectUrl}
+
+The user needs to open this link, sign in, and grant access. After completing authorization, send any message and the new tools will be loaded automatically.`;
+        }
+        return `Could not generate authorization URL for ${integration.name}. The Composio API did not return a redirect URL.`;
+      } catch (err) {
+        const msg = err.message;
+        console.error(`[connect_integration] Error: ${msg}`);
+        if (msg.includes("DefaultAuthConfigNotFound") || msg.includes("auth config not found")) {
+          return `${integration.name} does not support one-click OAuth authorization. It requires an API key to be configured manually. The user should add their ${integration.name} API key in the .env file and restart the agent. Do NOT attempt to use execute_command or any workaround.`;
+        }
+        if (msg.includes("NoAuthApp") || msg.includes("does not require authentication")) {
+          await ctx.reloadComposio();
+          return `${integration.name} does not require authentication \u2014 its tools should be available directly. Tools have been reloaded. Try using the ${integration.name} tools now. If no tools are available for ${integration.name}, tell the user this integration is not yet configured in Composio. Do NOT use execute_command or curl as a workaround.`;
+        }
+        return `Failed to connect ${integration.name}: ${msg}. Do NOT fall back to execute_command.`;
+      }
+    }
+  };
+}
 
 // scheduler.ts
 import { Inngest } from "inngest";
@@ -1026,10 +1107,10 @@ import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // config.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 var WORKSPACE = process.env.WORKSPACE_PATH || "/workspace";
-var BASE_PROMPT = `You are a personal AI assistant running on seclaw. You have multiple capabilities installed \u2014 use the right one based on the user's request.
+var AUTO_BASE_PROMPT = `You are a personal AI assistant running on seclaw. You have multiple capabilities installed \u2014 use the right one based on the user's request.
 
 ## Communication
 - Detect the user's language and respond in the same language
@@ -1040,6 +1121,21 @@ var BASE_PROMPT = `You are a personal AI assistant running on seclaw. You have m
 At the end of every response, write on a new line:
 --- CapabilityName
 Where CapabilityName is the capability you primarily used (e.g. "Inbox Management", "Research & Intelligence"). If no specific capability applies, write: --- General`;
+function focusBasePrompt(capId) {
+  const displayName = capId.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  return `You are a specialized AI agent running on seclaw, focused exclusively on: ${displayName}.
+
+IMPORTANT: You are in FOCUS MODE. Only use the capability described below. Do NOT answer questions outside your specialization \u2014 politely redirect the user to switch to the right agent via /templates.
+
+## Communication
+- Detect the user's language and respond in the same language
+- Keep Telegram messages concise \u2014 use bullet points and short paragraphs
+- Be proactive when you have relevant context to share
+
+## Response Format
+At the end of every response, write on a new line:
+--- ${displayName}`;
+}
 function loadConfig() {
   return {
     // LLM
@@ -1062,19 +1158,26 @@ function loadConfig() {
   };
 }
 function loadSystemPrompt() {
-  const installedPath = resolve2(WORKSPACE, "config", "installed.json");
+  return reloadSystemPrompt(WORKSPACE);
+}
+function reloadSystemPrompt(workspace) {
+  const installedPath = resolve2(workspace, "config", "installed.json");
   if (existsSync3(installedPath)) {
     try {
       const installed = JSON.parse(readFileSync3(installedPath, "utf-8"));
       if (installed.capabilities && installed.capabilities.length > 0) {
-        return composeCapabilityPrompt(installed.capabilities);
+        const active = installed.active || "auto";
+        if (active === "auto") {
+          return composeCapabilityPrompt(installed.capabilities, "auto");
+        }
+        return composeCapabilityPrompt([active], active);
       }
     } catch (err) {
       console.error(`[config] Failed to parse installed.json: ${err.message}`);
     }
   }
   const paths = [
-    resolve2(WORKSPACE, "config", "system-prompt.md"),
+    resolve2(workspace, "config", "system-prompt.md"),
     "/templates/system-prompt.md"
   ];
   for (const p of paths) {
@@ -1086,7 +1189,29 @@ function loadSystemPrompt() {
 Always be concise in Telegram messages. Use bullet points.
 Detect the user's language and respond in the same language.`;
 }
-function composeCapabilityPrompt(capabilities) {
+function getActiveMode(workspace) {
+  const installedPath = resolve2(workspace, "config", "installed.json");
+  if (!existsSync3(installedPath)) return "auto";
+  try {
+    const installed = JSON.parse(readFileSync3(installedPath, "utf-8"));
+    return installed.active || "auto";
+  } catch {
+    return "auto";
+  }
+}
+function setActiveMode(workspace, active) {
+  const installedPath = resolve2(workspace, "config", "installed.json");
+  if (!existsSync3(installedPath)) return;
+  try {
+    const installed = JSON.parse(readFileSync3(installedPath, "utf-8"));
+    installed.active = active;
+    writeFileSync2(installedPath, JSON.stringify(installed, null, 2) + "\n");
+    console.log(`[config] Active mode set to: ${active}`);
+  } catch (err) {
+    console.error(`[config] Failed to update installed.json: ${err.message}`);
+  }
+}
+function composeCapabilityPrompt(capabilities, mode) {
   const sections = [];
   for (const id of capabilities) {
     const promptPath = resolve2(WORKSPACE, "config", "capabilities", id, "system-prompt.md");
@@ -1098,21 +1223,47 @@ function composeCapabilityPrompt(capabilities) {
       console.warn(`[config] Capability prompt not found: ${promptPath}`);
     }
   }
+  const base = mode === "auto" ? AUTO_BASE_PROMPT : focusBasePrompt(mode);
   if (sections.length === 0) {
     console.warn("[config] No capability prompts loaded, using base prompt only");
-    return BASE_PROMPT;
+    return base;
   }
-  return BASE_PROMPT + "\n\n" + sections.join("\n\n");
+  return base + "\n\n" + sections.join("\n\n");
 }
 function loadInstalledCapabilities(workspace) {
   const installedPath = resolve2(workspace, "config", "installed.json");
-  if (!existsSync3(installedPath)) return [];
-  try {
-    const installed = JSON.parse(readFileSync3(installedPath, "utf-8"));
-    return installed.capabilities || [];
-  } catch {
-    return [];
+  const capsDir = resolve2(workspace, "config", "capabilities");
+  let installed = { capabilities: [] };
+  if (existsSync3(installedPath)) {
+    try {
+      installed = JSON.parse(readFileSync3(installedPath, "utf-8"));
+      if (!installed.capabilities) installed.capabilities = [];
+    } catch {
+    }
   }
+  if (existsSync3(capsDir)) {
+    let dirty = false;
+    try {
+      const dirs = readdirSync2(capsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      for (const dir of dirs) {
+        const promptPath = resolve2(capsDir, dir, "system-prompt.md");
+        if (existsSync3(promptPath) && !installed.capabilities.includes(dir)) {
+          installed.capabilities.push(dir);
+          dirty = true;
+          console.log(`[config] Auto-discovered capability: ${dir}`);
+        }
+      }
+    } catch {
+    }
+    if (dirty) {
+      try {
+        writeFileSync2(installedPath, JSON.stringify(installed, null, 2) + "\n");
+        console.log(`[config] Updated installed.json: ${installed.capabilities.length} capabilities`);
+      } catch {
+      }
+    }
+  }
+  return installed.capabilities;
 }
 
 // scheduler.ts
@@ -1290,6 +1441,10 @@ async function handleWebhook(req, res, config2, toolCtx2, inngestClient) {
       const confirmId = data.replace(/^confirm_(yes|no):/, "");
       const msgId = callback.message?.message_id;
       await handleConfirmation(chatId2, msgId, confirmId, isApprove, config2, toolCtx2);
+    } else if (data.startsWith("cap_switch:")) {
+      const capId = data.replace("cap_switch:", "");
+      const msgId = callback.message?.message_id;
+      await handleSwitchCallback(chatId2, msgId, capId, config2);
     }
     return;
   }
@@ -1311,8 +1466,8 @@ async function handleWebhook(req, res, config2, toolCtx2, inngestClient) {
     await handleSchedules(chatId, config2);
     return;
   }
-  if (userText.startsWith("/capabilities")) {
-    await handleCapabilities(chatId, config2);
+  if (userText.startsWith("/templates")) {
+    await handleTemplates(chatId, config2);
     return;
   }
   try {
@@ -1348,7 +1503,7 @@ async function sendMessage(token, chatId, text) {
   const chunks = splitMessage(text, 4e3);
   for (const chunk of chunks) {
     try {
-      await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      const res = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
@@ -1357,6 +1512,15 @@ async function sendMessage(token, chatId, text) {
           parse_mode: "Markdown"
         })
       });
+      const data = await res.json();
+      if (!data.ok) {
+        console.log(`[telegram] Markdown failed: ${data.description} \u2014 retrying plain`);
+        await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ chat_id: chatId, text: chunk })
+        });
+      }
     } catch {
       try {
         await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
@@ -1401,12 +1565,17 @@ function loadHistory(chatId, workspace) {
 function saveHistory(chatId, workspace, messages) {
   const p = historyPath(chatId, workspace);
   mkdirSync2(dirname(p), { recursive: true });
-  writeFileSync2(p, JSON.stringify(messages.slice(-MAX_HISTORY), null, 2));
+  writeFileSync3(p, JSON.stringify(messages.slice(-MAX_HISTORY), null, 2));
 }
 var INTEGRATIONS = {
   gmail: { name: "Gmail", app: "gmail", hint: "email" },
   drive: { name: "Google Drive", app: "googledrive", hint: "files" },
   calendar: { name: "Google Calendar", app: "googlecalendar", hint: "events" },
+  twitter: { name: "X (Twitter)", app: "twitter", hint: "tweets, leads, monitoring" },
+  reddit: { name: "Reddit", app: "reddit", hint: "subreddits, posts" },
+  youtube: { name: "YouTube", app: "youtube", hint: "channels, videos" },
+  tavily: { name: "Tavily", app: "tavily", hint: "web search" },
+  hackernews: { name: "Hacker News", app: "hackernews", hint: "tech news, stories" },
   notion: { name: "Notion", app: "notion", hint: "notes, databases" },
   github: { name: "GitHub", app: "github", hint: "repos, issues" },
   slack: { name: "Slack", app: "slack", hint: "messaging" },
@@ -1758,7 +1927,7 @@ async function handleScheduleToggle(chatId, msgId, scheduleId, config2) {
     return;
   }
   entry.enabled = entry.enabled === false ? true : false;
-  writeFileSync2(loc.filePath, JSON.stringify(data, null, 2) + "\n");
+  writeFileSync3(loc.filePath, JSON.stringify(data, null, 2) + "\n");
   const state = entry.enabled ? "enabled" : "disabled";
   const icon = entry.enabled ? "\u2705" : "\u23F8\uFE0F";
   if (msgId) await removeButtons(config2.telegramToken, chatId, msgId, `${icon} ${scheduleId} \u2014 ${state}`);
@@ -1836,7 +2005,7 @@ async function handleScheduleDeleteExecute(chatId, msgId, scheduleId, config2) {
   }
   const removed = data.schedules.splice(idx, 1)[0];
   delete data.actions[removed.action];
-  writeFileSync2(loc.filePath, JSON.stringify(data, null, 2) + "\n");
+  writeFileSync3(loc.filePath, JSON.stringify(data, null, 2) + "\n");
   if (msgId) await removeButtons(config2.telegramToken, chatId, msgId, `Deleted: ${scheduleId}`);
   console.log(`[schedules] ${scheduleId} deleted`);
 }
@@ -1855,16 +2024,17 @@ async function editMessageWithButtons(token, chatId, messageId, text, keyboard)
   } catch {
   }
 }
-async function handleCapabilities(chatId, config2) {
+async function handleTemplates(chatId, config2) {
   const capabilities = loadInstalledCapabilities(config2.workspace);
   if (capabilities.length === 0) {
     await sendMessage(
       config2.telegramToken,
       chatId,
-      "No capabilities installed. Using default single-prompt mode."
+      "No templates installed. Using default single-prompt mode.\n\nAdd templates: `npx seclaw add <template>`\nBrowse: seclawai.com/templates"
     );
     return;
   }
+  const activeMode = getActiveMode(config2.workspace);
   const scheduleConfig = loadScheduleConfig(config2.workspace);
   const scheduleCountByCapability = {};
   if (scheduleConfig) {
@@ -1885,13 +2055,53 @@ async function handleCapabilities(chatId, config2) {
     const statusIcon = hasPrompt ? "\u2705" : "\u26A0\uFE0F";
     return `${statusIcon} *${displayName}*${schedLabel}`;
   });
-  await sendMessage(
-    config2.telegramToken,
-    chatId,
-    `*Installed Capabilities*
+  let modeLabel;
+  if (activeMode === "auto") {
+    modeLabel = `Auto \u2014 all ${capabilities.length} templates active`;
+  } else {
+    const activeName = activeMode.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    modeLabel = `${activeName} (focus mode)`;
+  }
+  const text = `*Installed Templates (${capabilities.length})*
 
-${lines.join("\n")}`
-  );
+${lines.join("\n")}
+
+Mode: *${modeLabel}*`;
+  if (capabilities.length >= 2) {
+    const keyboard = [];
+    const autoLabel = activeMode === "auto" ? "\u2705 Auto (All Templates)" : "\u{1F504} Auto (All Templates)";
+    keyboard.push([{ text: autoLabel, callback_data: "cap_switch:auto" }]);
+    const capButtons = [];
+    for (const capId of capabilities) {
+      const displayName = capId.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      const icon = activeMode === capId ? "\u2705" : "\u25CB";
+      capButtons.push({ text: `${icon} ${displayName}`, callback_data: `cap_switch:${capId}` });
+    }
+    for (let i = 0; i < capButtons.length; i += 2) {
+      keyboard.push(capButtons.slice(i, i + 2));
+    }
+    await sendMessageWithButtons(config2.telegramToken, chatId, text, keyboard);
+  } else {
+    await sendMessage(
+      config2.telegramToken,
+      chatId,
+      text + "\n\nAdd more templates to switch modes:\n`npx seclaw add <template> --key YOUR_KEY`"
+    );
+  }
+}
+async function handleSwitchCallback(chatId, msgId, capId, config2) {
+  const capabilities = loadInstalledCapabilities(config2.workspace);
+  if (capId !== "auto" && !capabilities.includes(capId)) {
+    await sendMessage(config2.telegramToken, chatId, `Capability "${capId}" is not installed.`);
+    return;
+  }
+  setActiveMode(config2.workspace, capId);
+  config2.systemPrompt = reloadSystemPrompt(config2.workspace);
+  if (msgId) {
+    const label = capId === "auto" ? `\u2705 Switched to *Auto* \u2014 all capabilities active` : `\u2705 Switched to *${capId.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")}*`;
+    await removeButtons(config2.telegramToken, chatId, msgId, label);
+  }
+  console.log(`[switch] Mode changed to: ${capId}`);
 }
 async function sendMessageWithButtons(token, chatId, text, keyboard) {
   if (!token || !chatId) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seclaw",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Secure autonomous AI agents in 60 seconds",
   "type": "module",
   "bin": {