@agentforge-ai/cli 0.5.4 → 0.6.0

package/dist/index.js

@@ -35,7 +35,7 @@ async function createProject(projectName, options) {
   ];
   let templateDir = "";
   for (const dir of searchDirs) {
-    if (await fs.pathExists(path.join(dir, "package.json"))) {
+    if (await fs.pathExists(dir)) {
       templateDir = dir;
       break;
     }
@@ -126,6 +126,10 @@ Next steps:
   # Or chat with your agent from the CLI
   agentforge chat
 
+  # Install skills to extend agent capabilities
+  agentforge skills list --registry
+  agentforge skills install web-search
+
   # Check system status
   agentforge status
 
@@ -157,10 +161,26 @@ async function runProject(options) {
 \u{1F680} Starting AgentForge development server...
 `);
   console.log(`  Convex dev server starting on port ${options.port}...`);
+  if (options.sandbox === "docker") {
+    console.log(`  \u{1F433} Docker sandbox enabled \u2014 agent tools will execute in isolated containers`);
+    console.log(`     Image: ${process.env["DOCKER_IMAGE"] ?? "node:22-slim (default)"}`);
+    console.log(`     Host:  ${process.env["DOCKER_HOST"] ?? "/var/run/docker.sock (default)"}`);
+  } else if (options.sandbox === "e2b") {
+    console.log(`  \u2601\uFE0F  E2B sandbox enabled \u2014 agent tools will execute in cloud sandboxes`);
+  } else if (options.sandbox === "none") {
+    console.log(`  \u26A0\uFE0F  No sandbox \u2014 agent tools will execute directly on the host (unsafe)`);
+  } else {
+    console.log(`  \u{1F4E6} Local sandbox enabled (default)`);
+  }
+  const sandboxEnv = {
+    ...process.env,
+    AGENTFORGE_SANDBOX_PROVIDER: options.sandbox
+  };
   const convexProcess = spawn("npx", ["convex", "dev"], {
     cwd: projectDir,
     stdio: "inherit",
-    shell: true
+    shell: true,
+    env: sandboxEnv
   });
   convexProcess.on("error", (err) => {
     console.error(`Failed to start Convex dev server: ${err.message}`);
@@ -296,8 +316,8 @@ var CloudClient = class {
    */
   getUrl(endpoint) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const path10 = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
-    return `${base}${path10}`;
+    const path12 = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    return `${base}${path12}`;
   }
   /**
    * Get request headers with authentication
@@ -338,7 +358,7 @@ var CloudClient = class {
     const isJson = contentType?.includes("application/json");
     if (!response.ok) {
       const errorBody = isJson ? await response.json() : null;
-      const message = errorBody?.message || errorBody?.error || `HTTP ${response.status}: ${response.statusText}`;
+      const message = errorBody?.message || `HTTP ${response.status}: ${response.statusText}`;
       throw new CloudClientError(
         message,
         errorBody?.code || `HTTP_${response.status}`,
@@ -857,6 +877,9 @@ function success(msg) {
 function error(msg) {
   console.error(`${colors.red}\u2716${colors.reset} ${msg}`);
 }
+function warn(msg) {
+  console.log(`${colors.yellow}\u26A0${colors.reset} ${msg}`);
+}
 function info(msg) {
   console.log(`${colors.blue}\u2139${colors.reset} ${msg}`);
 }
@@ -901,6 +924,10 @@ function details(data) {
 function formatDate(ts) {
   return new Date(ts).toLocaleString();
 }
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+}
 
 // src/commands/agents.ts
 import readline from "readline";
@@ -957,8 +984,7 @@ function registerAgentsCommand(program2) {
         name,
         instructions,
         model,
-        provider,
-        isActive: true
+        provider
       }),
       "Failed to create agent"
     );
@@ -967,7 +993,7 @@ function registerAgentsCommand(program2) {
   agents.command("inspect").argument("<id>", "Agent ID").description("Show detailed agent information").action(async (id) => {
     const client = await createClient();
     const agent = await safeCall(
-      () => client.query("agents:getByAgentId", { id }),
+      () => client.query("agents:get", { id }),
       "Failed to fetch agent"
     );
     if (!agent) {
@@ -995,7 +1021,7 @@ function registerAgentsCommand(program2) {
   agents.command("edit").argument("<id>", "Agent ID").option("--name <name>", "New name").option("--model <model>", "New model").option("--instructions <text>", "New instructions").description("Edit an agent").action(async (id, opts) => {
     const client = await createClient();
     const agent = await safeCall(
-      () => client.query("agents:getByAgentId", { id }),
+      () => client.query("agents:get", { id }),
       "Failed to fetch agent"
     );
     if (!agent) {
@@ -1026,7 +1052,7 @@ function registerAgentsCommand(program2) {
       return;
     }
     await safeCall(
-      () => client.mutation("agents:update", { _id: agent._id, ...updates }),
+      () => client.mutation("agents:update", { id, ...updates }),
       "Failed to update agent"
     );
     success(`Agent "${id}" updated.`);
@@ -1041,7 +1067,7 @@ function registerAgentsCommand(program2) {
     }
     const client = await createClient();
     const agent = await safeCall(
-      () => client.query("agents:getByAgentId", { id }),
+      () => client.query("agents:get", { id }),
       "Failed to fetch agent"
     );
     if (!agent) {
@@ -1049,29 +1075,29 @@ function registerAgentsCommand(program2) {
       process.exit(1);
     }
     await safeCall(
-      () => client.mutation("agents:remove", { _id: agent._id }),
+      () => client.mutation("agents:remove", { id }),
       "Failed to delete agent"
     );
     success(`Agent "${id}" deleted.`);
   });
   agents.command("enable").argument("<id>", "Agent ID").description("Enable an agent").action(async (id) => {
     const client = await createClient();
-    const agent = await safeCall(() => client.query("agents:getByAgentId", { id }), "Failed to fetch agent");
+    const agent = await safeCall(() => client.query("agents:get", { id }), "Failed to fetch agent");
     if (!agent) {
       error(`Agent "${id}" not found.`);
       process.exit(1);
     }
-    await safeCall(() => client.mutation("agents:update", { _id: agent._id, isActive: true }), "Failed");
+    await safeCall(() => client.mutation("agents:update", { id, isActive: true }), "Failed");
     success(`Agent "${id}" enabled.`);
   });
   agents.command("disable").argument("<id>", "Agent ID").description("Disable an agent").action(async (id) => {
     const client = await createClient();
-    const agent = await safeCall(() => client.query("agents:getByAgentId", { id }), "Failed to fetch agent");
+    const agent = await safeCall(() => client.query("agents:get", { id }), "Failed to fetch agent");
     if (!agent) {
       error(`Agent "${id}" not found.`);
       process.exit(1);
     }
-    await safeCall(() => client.mutation("agents:update", { _id: agent._id, isActive: false }), "Failed");
+    await safeCall(() => client.mutation("agents:update", { id, isActive: false }), "Failed");
     success(`Agent "${id}" disabled.`);
   });
 }
@@ -1100,7 +1126,7 @@ function registerChatCommand(program2) {
       const idx = parseInt(choice) - 1;
       agentId = idx >= 0 && idx < agents.length ? agents[idx].id : choice;
     }
-    const agent = await safeCall(() => client.query("agents:getByAgentId", { id: agentId }), "Failed to fetch agent");
+    const agent = await safeCall(() => client.query("agents:get", { id: agentId }), "Failed to fetch agent");
     if (!agent) {
       error(`Agent "${agentId}" not found.`);
       process.exit(1);
@@ -1111,7 +1137,7 @@ function registerChatCommand(program2) {
     dim(`  Type "exit" or "quit" to end. "/new" for new thread. "/history" for messages.`);
     console.log();
     let threadId = await safeCall(
-      () => client.mutation("threads:create", { agentId: a.id, status: "active" }),
+      () => client.mutation("threads:create", { agentId: a.id }),
       "Failed to create thread"
     );
     const history = [];
@@ -1128,7 +1154,7 @@ function registerChatCommand(program2) {
         process.exit(0);
       }
       if (input === "/new") {
-        threadId = await safeCall(() => client.mutation("threads:create", { agentId: a.id, status: "active" }), "Failed");
+        threadId = await safeCall(() => client.mutation("threads:create", { agentId: a.id }), "Failed");
         history.length = 0;
         info("New thread started.");
         rl.prompt();
@@ -1145,14 +1171,14 @@ function registerChatCommand(program2) {
         return;
       }
       history.push({ role: "user", content: input });
-      await safeCall(() => client.mutation("messages:send", { threadId, role: "user", content: input }), "Failed to send");
+      await safeCall(() => client.mutation("messages:add", { threadId, role: "user", content: input }), "Failed to send");
       process.stdout.write(`${colors.cyan}${a.name}${colors.reset} > `);
       try {
         const response = await safeCall(
-          () => client.action("mastraIntegration:generateResponse", { agentId: a.id, threadId, message: input }),
+          () => client.action("mastraIntegration:executeAgent", { agentId: a.id, prompt: input, threadId }),
           "Failed to get response"
         );
-        const text = response?.text || response?.content || String(response);
+        const text = response?.response || response?.text || response?.content || String(response);
         console.log(text);
         history.push({ role: "assistant", content: text });
       } catch {
@@ -1188,7 +1214,7 @@ function registerSessionsCommand(program2) {
     const filtered = opts.status ? items.filter((s) => s.status === opts.status) : items;
     table(filtered.map((s) => ({
       ID: s._id?.slice(-8) || "N/A",
-      Name: s.name || "Unnamed",
+      Session: s.sessionId,
       Agent: s.agentId,
       Status: s.status,
       Started: formatDate(s.startedAt),
@@ -1197,18 +1223,18 @@ function registerSessionsCommand(program2) {
   });
   sessions.command("inspect").argument("<id>", "Session ID").description("Show session details").action(async (id) => {
     const client = await createClient();
-    const session = await safeCall(() => client.query("sessions:getById", { id }), "Failed to fetch session");
+    const session = await safeCall(() => client.query("sessions:get", { sessionId: id }), "Failed to fetch session");
     if (!session) {
       error(`Session "${id}" not found.`);
       process.exit(1);
     }
     const s = session;
-    header(`Session: ${s.name || "Unnamed"}`);
-    details({ ID: s._id, Name: s.name, Agent: s.agentId, Status: s.status, Started: formatDate(s.startedAt), "Last Activity": formatDate(s.lastActivityAt) });
+    header(`Session: ${s.sessionId}`);
+    details({ ID: s._id, "Session ID": s.sessionId, Agent: s.agentId, Status: s.status, Started: formatDate(s.startedAt), "Last Activity": formatDate(s.lastActivityAt) });
   });
   sessions.command("end").argument("<id>", "Session ID").description("End an active session").action(async (id) => {
     const client = await createClient();
-    await safeCall(() => client.mutation("sessions:update", { _id: id, status: "ended" }), "Failed to end session");
+    await safeCall(() => client.mutation("sessions:updateStatus", { sessionId: id, status: "completed" }), "Failed to end session");
     success(`Session "${id}" ended.`);
   });
 }
@@ -1232,13 +1258,13 @@ function registerThreadsCommand(program2) {
       ID: t._id?.slice(-8) || "N/A",
       Name: t.name || "Unnamed",
       Agent: t.agentId,
-      Status: t.status,
+      Messages: t.metadata?.messageCount || "-",
       Created: formatDate(t.createdAt)
     })));
   });
   threads.command("inspect").argument("<id>", "Thread ID").description("Show thread messages").action(async (id) => {
     const client = await createClient();
-    const messages = await safeCall(() => client.query("messages:listByThread", { threadId: id }), "Failed to fetch messages");
+    const messages = await safeCall(() => client.query("messages:list", { threadId: id }), "Failed to fetch messages");
     header(`Thread: ${id}`);
     const items = messages || [];
     if (items.length === 0) {
@@ -1253,7 +1279,7 @@ function registerThreadsCommand(program2) {
   });
   threads.command("delete").argument("<id>", "Thread ID").description("Delete a thread and its messages").action(async (id) => {
     const client = await createClient();
-    await safeCall(() => client.mutation("threads:remove", { _id: id }), "Failed to delete thread");
+    await safeCall(() => client.mutation("threads:remove", { id }), "Failed to delete thread");
     success(`Thread "${id}" deleted.`);
   });
 }
@@ -1262,6 +1288,68 @@ function registerThreadsCommand(program2) {
 import fs6 from "fs-extra";
 import path6 from "path";
 import readline3 from "readline";
+import { execSync as execSync3 } from "child_process";
+var SKILLS_DIR_NAME = "skills";
+var SKILLS_LOCK_FILE = "skills.lock.json";
+var WORKSPACE_DIR_NAME = "workspace";
+var BUILTIN_REGISTRY = [
+  {
+    name: "web-search",
+    description: "Search the web for information using DuckDuckGo. Provides structured search results with titles, URLs, and snippets.",
+    version: "1.0.0",
+    tags: ["web", "search", "research"],
+    author: "AgentForge",
+    source: "builtin"
+  },
+  {
+    name: "file-manager",
+    description: "Advanced file management operations including batch rename, find-and-replace across files, directory comparison, and file organization.",
+    version: "1.0.0",
+    tags: ["files", "utility", "management"],
+    author: "AgentForge",
+    source: "builtin"
+  },
+  {
+    name: "code-review",
+    description: "Systematic code review following best practices. Checks for bugs, security vulnerabilities, style issues, and suggests improvements.",
+    version: "1.0.0",
+    tags: ["development", "review", "quality"],
+    author: "AgentForge",
+    source: "builtin"
+  },
+  {
+    name: "data-analyst",
+    description: "Analyze CSV, JSON, and tabular data. Generate summaries, statistics, and insights from structured datasets.",
+    version: "1.0.0",
+    tags: ["data", "analysis", "csv", "json"],
+    author: "AgentForge",
+    source: "builtin"
+  },
+  {
+    name: "api-tester",
+    description: "Test REST APIs with structured request/response validation. Supports GET, POST, PUT, DELETE with headers and body.",
+    version: "1.0.0",
+    tags: ["api", "testing", "http", "rest"],
+    author: "AgentForge",
+    source: "builtin"
+  },
+  {
+    name: "git-workflow",
+    description: "Git workflow automation including conventional commits, branch management, PR descriptions, and changelog generation.",
+    version: "1.0.0",
+    tags: ["git", "workflow", "development"],
+    author: "AgentForge",
+    source: "builtin"
+  },
+  {
+    name: "browser-automation",
+    description: "Browser automation using Playwright. Navigate web pages, click elements, type text, extract content, take screenshots, and run JavaScript. Supports Docker sandbox mode for secure execution.",
+    version: "1.0.0",
+    tags: ["web", "browser", "automation", "scraping"],
+    author: "AgentForge",
+    source: "builtin"
+  }
+];
 function prompt2(q) {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((r) => rl.question(q, (a) => {
@@ -1269,247 +1357,1490 @@ function prompt2(q) {
     r(a.trim());
   }));
 }
-function registerSkillsCommand(program2) {
-  const skills = program2.command("skills").description("Manage agent skills");
-  skills.command("list").option("--installed", "Show only installed skills").option("--json", "Output as JSON").description("List all skills").action(async (opts) => {
-    const client = await createClient();
-    const result = await safeCall(() => client.query("skills:list", {}), "Failed to list skills");
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
+function resolveSkillsDir() {
+  const cwd = process.cwd();
+  const workspaceSkillsDir = path6.join(cwd, WORKSPACE_DIR_NAME, SKILLS_DIR_NAME);
+  if (fs6.existsSync(path6.join(cwd, WORKSPACE_DIR_NAME))) {
+    return workspaceSkillsDir;
+  }
+  return path6.join(cwd, SKILLS_DIR_NAME);
+}
+function readSkillsLock(skillsDir) {
+  const lockPath = path6.join(path6.dirname(skillsDir), SKILLS_LOCK_FILE);
+  if (fs6.existsSync(lockPath)) {
+    try {
+      return JSON.parse(fs6.readFileSync(lockPath, "utf-8"));
+    } catch {
     }
-    header("Skills");
-    const localSkills = [];
-    const skillsDir = path6.join(process.cwd(), "skills");
-    if (fs6.existsSync(skillsDir)) {
-      const dirs = fs6.readdirSync(skillsDir).filter((d) => fs6.statSync(path6.join(skillsDir, d)).isDirectory());
-      localSkills.push(...dirs);
+  }
+  return { version: 1, skills: {} };
+}
+function writeSkillsLock(skillsDir, lock) {
+  const lockPath = path6.join(path6.dirname(skillsDir), SKILLS_LOCK_FILE);
+  fs6.writeFileSync(lockPath, JSON.stringify(lock, null, 2) + "\n");
+}
+function parseSkillMd(content) {
+  try {
+    const matter = __require("gray-matter");
+    const parsed = matter(content);
+    return {
+      data: parsed.data,
+      content: parsed.content
+    };
+  } catch {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!fmMatch) {
+      return { data: { name: "", description: "", version: "1.0.0" }, content };
     }
-    const items = result || [];
-    if (items.length === 0 && localSkills.length === 0) {
-      info("No skills found. Install one with: agentforge skills install <name>");
-      info("Or create one with: agentforge skills create");
-      return;
+    const frontmatter = fmMatch[1];
+    const body = fmMatch[2];
+    const data = {};
+    for (const line of frontmatter.split("\n")) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        const value = match[2].trim();
+        data[match[1]] = value;
+      }
     }
-    if (localSkills.length > 0) {
-      dim("  Local Skills:");
-      localSkills.forEach((s) => {
-        const configPath = path6.join(skillsDir, s, "config.json");
-        let desc = "";
-        if (fs6.existsSync(configPath)) {
-          try {
-            desc = JSON.parse(fs6.readFileSync(configPath, "utf-8")).description || "";
-          } catch {
+    return {
+      data,
+      content: body
+    };
+  }
+}
+function readSkillMetadata(skillDir) {
+  const skillMdPath = path6.join(skillDir, "SKILL.md");
+  if (!fs6.existsSync(skillMdPath)) return null;
+  const content = fs6.readFileSync(skillMdPath, "utf-8");
+  const { data } = parseSkillMd(content);
+  return {
+    name: data.name || path6.basename(skillDir),
+    description: data.description || "",
+    version: data.version || "1.0.0",
+    tags: data.tags || [],
+    author: data.author || "Unknown"
+  };
+}
+function findInRegistry(name) {
+  return BUILTIN_REGISTRY.find((s) => s.name === name);
+}
+function generateBuiltinSkill(name) {
+  const generators = {
+    "web-search": generateWebSearchSkill,
+    "file-manager": generateFileManagerSkill,
+    "code-review": generateCodeReviewSkill,
+    "data-analyst": generateDataAnalystSkill,
+    "api-tester": generateApiTesterSkill,
+    "git-workflow": generateGitWorkflowSkill,
+    "browser-automation": generateBrowserAutomationSkill
+  };
+  const generator = generators[name];
+  return generator ? generator() : null;
+}
+function generateWebSearchSkill() {
+  const files = /* @__PURE__ */ new Map();
+  files.set("SKILL.md", `---
+name: web-search
+description: Search the web for information using DuckDuckGo and return structured results
+version: 1.0.0
+tags:
+  - web
+  - search
+  - research
+---
+
+# Web Search
+
+You are a web research assistant. When the user asks you to search for information:
+
+1. Use the workspace sandbox to execute the search script at \`scripts/search.ts\`
+2. Parse the results and present them in a clear, organized format
+3. Include source URLs for all information
+4. Summarize key findings at the top
+
+## How to Search
+
+Run the search script with the user's query:
+
+\`\`\`bash
+npx tsx scripts/search.ts "user query here"
+\`\`\`
+
+The script returns JSON with structured results including title, URL, and snippet.
+
+## Result Format
+
+Present results as:
+- **Title** \u2014 Brief description ([Source](url))
+- Group related results together
+- Highlight the most relevant findings first
+
+## Guidelines
+
+- Always cite sources with URLs
+- If results are insufficient, suggest refined queries
+- Cross-reference multiple results for accuracy
+- Note when information may be outdated
+`);
+  files.set("scripts/search.ts", `#!/usr/bin/env npx tsx
+/**
+ * Web Search Script \u2014 Uses DuckDuckGo Instant Answer API
+ *
+ * Usage: npx tsx scripts/search.ts "your query"
+ */
+
+const query = process.argv[2];
+if (!query) {
+  console.error('Usage: npx tsx scripts/search.ts "query"');
+  process.exit(1);
+}
+
+interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+async function search(q: string): Promise<SearchResult[]> {
+  const url = \`https://api.duckduckgo.com/?q=\${encodeURIComponent(q)}&format=json&no_redirect=1&no_html=1\`;
+  const res = await fetch(url);
+  const data = await res.json();
+
+  const results: SearchResult[] = [];
+
+  // Abstract (main answer)
+  if (data.Abstract) {
+    results.push({
+      title: data.Heading || q,
+      url: data.AbstractURL || '',
+      snippet: data.Abstract,
+    });
+  }
+
+  // Related topics
+  if (data.RelatedTopics) {
+    for (const topic of data.RelatedTopics) {
+      if (topic.Text && topic.FirstURL) {
+        results.push({
+          title: topic.Text.split(' - ')[0] || topic.Text.slice(0, 80),
+          url: topic.FirstURL,
+          snippet: topic.Text,
+        });
+      }
+      // Subtopics
+      if (topic.Topics) {
+        for (const sub of topic.Topics) {
+          if (sub.Text && sub.FirstURL) {
+            results.push({
+              title: sub.Text.split(' - ')[0] || sub.Text.slice(0, 80),
+              url: sub.FirstURL,
+              snippet: sub.Text,
+            });
           }
         }
-        console.log(`  ${colors.cyan}\u25CF${colors.reset} ${s} ${colors.dim}${desc}${colors.reset}`);
-      });
-      console.log();
-    }
-    if (items.length > 0) {
-      const filtered = opts.installed ? items.filter((s) => s.isInstalled) : items;
-      table(filtered.map((s) => ({
-        Name: s.name,
-        Category: s.category,
-        Version: s.version,
-        Installed: s.isInstalled ? "\u2714" : "\u2716",
-        Agent: s.agentId || "all"
-      })));
+      }
     }
+  }
+
+  return results.slice(0, 10);
+}
+
+search(query)
+  .then((results) => console.log(JSON.stringify({ query, results, count: results.length }, null, 2)))
+  .catch((err) => {
+    console.error(JSON.stringify({ error: err.message }));
+    process.exit(1);
   });
-  skills.command("create").description("Create a new skill (interactive)").option("--name <name>", "Skill name").option("--description <desc>", "Skill description").option("--category <cat>", "Category (utility, web, file, data, integration, ai, custom)").action(async (opts) => {
-    const name = opts.name || await prompt2("Skill name (kebab-case): ");
-    const description = opts.description || await prompt2("Description: ");
-    const category = opts.category || await prompt2("Category (utility/web/file/data/integration/ai/custom): ") || "custom";
-    if (!name) {
-      error("Skill name is required.");
-      process.exit(1);
-    }
-    const skillDir = path6.join(process.cwd(), "skills", name);
-    if (fs6.existsSync(skillDir)) {
-      error(`Skill "${name}" already exists at ${skillDir}`);
-      process.exit(1);
-    }
-    fs6.mkdirSync(skillDir, { recursive: true });
-    fs6.writeFileSync(path6.join(skillDir, "config.json"), JSON.stringify({
-      name,
-      version: "1.0.0",
-      description,
-      category,
-      author: "User",
-      tools: [name],
-      dependencies: [],
-      agentInstructions: `You have access to the ${name} skill. ${description}`
-    }, null, 2));
-    fs6.writeFileSync(path6.join(skillDir, "index.ts"), `import { z } from 'zod';
+`);
+  files.set("references/search-tips.md", `# Search Tips
+
+## Effective Queries
+- Use specific keywords rather than full sentences
+- Include domain-specific terms for technical searches
+- Use quotes for exact phrase matching (in the query string)
+- Add "site:example.com" to limit to specific domains
+
+## Result Evaluation
+- Check the date of sources when available
+- Cross-reference claims across multiple results
+- Prefer authoritative sources (.edu, .gov, established publications)
+- Note when results are from forums vs. official documentation
+`);
+  return files;
+}
+function generateFileManagerSkill() {
+  const files = /* @__PURE__ */ new Map();
+  files.set("SKILL.md", `---
+name: file-manager
+description: Advanced file management operations including batch rename, find-and-replace, and directory organization
+version: 1.0.0
+tags:
+  - files
+  - utility
+  - management
+---
+
+# File Manager
+
+You are a file management assistant. Help users organize, search, and manipulate files in the workspace.
+
+## Capabilities
+
+1. **List & Search** \u2014 Find files by name, extension, or content
+2. **Batch Rename** \u2014 Rename multiple files using patterns
+3. **Find & Replace** \u2014 Search and replace text across files
+4. **Organize** \u2014 Sort files into directories by type, date, or custom rules
+5. **Compare** \u2014 Show differences between files or directories
+
+## How to Use
+
+Use the workspace filesystem tools to perform operations:
+
+- \`mastra_workspace_list_files\` \u2014 List directory contents as a tree
+- \`mastra_workspace_read_file\` \u2014 Read file contents
+- \`mastra_workspace_write_file\` \u2014 Create or overwrite files
+- \`mastra_workspace_edit_file\` \u2014 Find and replace in files
+- \`mastra_workspace_delete\` \u2014 Remove files or directories
+- \`mastra_workspace_file_stat\` \u2014 Get file metadata (size, dates)
+- \`mastra_workspace_mkdir\` \u2014 Create directories
 
+For complex operations, use \`mastra_workspace_execute_command\` with the scripts in this skill.
+
+## Scripts
+
+- \`scripts/batch-rename.ts\` \u2014 Batch rename files with pattern support
+- \`scripts/find-replace.ts\` \u2014 Find and replace across multiple files
+- \`scripts/organize.ts\` \u2014 Organize files by extension into directories
+
+## Guidelines
+
+- Always confirm destructive operations (delete, overwrite) with the user
+- Show a preview of changes before executing batch operations
+- Create backups when performing bulk modifications
+- Report the number of files affected after each operation
+`);
+  files.set("scripts/batch-rename.ts", `#!/usr/bin/env npx tsx
 /**
- * ${name} \u2014 AgentForge Skill
- * ${description}
+ * Batch Rename Script
+ *
+ * Usage: npx tsx scripts/batch-rename.ts <directory> <find-pattern> <replace-pattern>
+ * Example: npx tsx scripts/batch-rename.ts ./docs "report-" "2026-report-"
  */
-export const tools = [
-  {
-    name: '${name}',
-    description: '${description}',
-    inputSchema: z.object({
-      input: z.string().describe('Input for ${name}'),
-    }),
-    outputSchema: z.object({
-      result: z.string(),
-      success: z.boolean(),
-    }),
-    handler: async (params: { input: string }) => {
-      // TODO: Implement your skill logic here
-      return { result: \`Processed: \${params.input}\`, success: true };
-    },
-  },
-];
 
-export default { tools };
-`);
-    fs6.writeFileSync(path6.join(skillDir, "SKILL.md"), `# ${name}
+import { readdirSync, renameSync } from 'fs';
+import { join, basename } from 'path';
 
-${description}
+const [dir, findPattern, replacePattern] = process.argv.slice(2);
+if (!dir || !findPattern || !replacePattern) {
+  console.error('Usage: npx tsx scripts/batch-rename.ts <dir> <find> <replace>');
+  process.exit(1);
+}
+
+const files = readdirSync(dir);
+const renames: Array<{ from: string; to: string }> = [];
 
-## Usage
+for (const file of files) {
+  if (file.includes(findPattern)) {
+    const newName = file.replace(findPattern, replacePattern);
+    renames.push({ from: file, to: newName });
+  }
+}
 
-Ask your agent: "Use the ${name} tool to [your request]"
+if (renames.length === 0) {
+  console.log(JSON.stringify({ message: 'No files matched the pattern', count: 0 }));
+  process.exit(0);
+}
 
-## Configuration
+for (const { from, to } of renames) {
+  renameSync(join(dir, from), join(dir, to));
+}
 
-Edit \`skills/${name}/config.json\` to customize.
+console.log(JSON.stringify({ renames, count: renames.length }));
 `);
-    success(`Skill "${name}" created at skills/${name}/`);
-    info("Files created: index.ts, config.json, SKILL.md");
-    info(`Edit skills/${name}/index.ts to implement your tool logic.`);
-  });
-  skills.command("install").argument("<name>", "Skill name to install").description("Install a skill").action(async (name) => {
-    const client = await createClient();
-    await safeCall(
-      () => client.mutation("skills:create", {
-        name,
-        category: "custom",
-        version: "1.0.0",
-        isInstalled: true
-      }),
-      "Failed to install skill"
-    );
-    success(`Skill "${name}" installed.`);
-  });
-  skills.command("remove").argument("<name>", "Skill name to remove").description("Remove a skill").action(async (name) => {
-    const skillDir = path6.join(process.cwd(), "skills", name);
-    if (fs6.existsSync(skillDir)) {
-      const confirm = await prompt2(`Remove skill "${name}" and delete files? (y/N): `);
-      if (confirm.toLowerCase() === "y") {
-        fs6.removeSync(skillDir);
-        success(`Skill "${name}" removed from disk.`);
-      }
-    }
-    const client = await createClient();
-    try {
-      const skills2 = await client.query("skills:list", {});
-      const skill = skills2.find((s) => s.name === name);
-      if (skill) {
-        await client.mutation("skills:remove", { _id: skill._id });
-        success(`Skill "${name}" removed from database.`);
+  files.set("scripts/find-replace.ts", `#!/usr/bin/env npx tsx
+/**
+ * Find and Replace Script
+ *
+ * Usage: npx tsx scripts/find-replace.ts <directory> <find-text> <replace-text> [--ext .ts,.js]
+ */
+
+import { readdirSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { join, extname } from 'path';
+
+const args = process.argv.slice(2);
+const dir = args[0];
+const findText = args[1];
+const replaceText = args[2];
+const extFilter = args.includes('--ext') ? args[args.indexOf('--ext') + 1]?.split(',') : null;
+
+if (!dir || !findText || replaceText === undefined) {
+  console.error('Usage: npx tsx scripts/find-replace.ts <dir> <find> <replace> [--ext .ts,.js]');
+  process.exit(1);
+}
+
+interface Change { file: string; count: number; }
+const changes: Change[] = [];
+
+function processDir(dirPath: string) {
+  for (const entry of readdirSync(dirPath)) {
+    const fullPath = join(dirPath, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
+      processDir(fullPath);
+    } else if (stat.isFile()) {
+      if (extFilter && !extFilter.includes(extname(entry))) continue;
+      const content = readFileSync(fullPath, 'utf-8');
+      const count = (content.match(new RegExp(findText.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&'), 'g')) || []).length;
+      if (count > 0) {
+        const newContent = content.replaceAll(findText, replaceText);
+        writeFileSync(fullPath, newContent);
+        changes.push({ file: fullPath, count });
       }
-    } catch {
-    }
-  });
-  skills.command("search").argument("<query>", "Search query").description("Search available skills").action(async (query) => {
-    header("Skill Search Results");
-    const examples = [
-      { name: "web-search", desc: "Search the web for information", cat: "web" },
-      { name: "calculator", desc: "Evaluate mathematical expressions", cat: "utility" },
-      { name: "file-reader", desc: "Read file contents", cat: "file" },
-      { name: "http-request", desc: "Make HTTP requests", cat: "web" },
-      { name: "json-transformer", desc: "Transform JSON data", cat: "data" },
-      { name: "text-summarizer", desc: "Summarize text into key points", cat: "ai" },
-      { name: "csv-parser", desc: "Parse CSV into structured JSON", cat: "data" }
-    ];
-    const q = query.toLowerCase();
-    const matches = examples.filter((e) => e.name.includes(q) || e.desc.toLowerCase().includes(q) || e.cat.includes(q));
-    if (matches.length === 0) {
-      info(`No skills matching "${query}". Try: agentforge skills create`);
-      return;
     }
-    table(matches.map((e) => ({ Name: e.name, Description: e.desc, Category: e.cat })));
-    info("Install with: agentforge skills install <name>");
-    info("Or see examples: check skills/skill-creator/SKILL.md");
-  });
+  }
 }
 
-// src/commands/cron.ts
-import readline4 from "readline";
-function prompt3(q) {
-  const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((r) => rl.question(q, (a) => {
-    rl.close();
-    r(a.trim());
-  }));
+processDir(dir);
+console.log(JSON.stringify({ changes, totalFiles: changes.length, totalReplacements: changes.reduce((s, c) => s + c.count, 0) }));
+`);
+  return files;
 }
-function registerCronCommand(program2) {
-  const cron = program2.command("cron").description("Manage cron jobs");
-  cron.command("list").option("--json", "Output as JSON").description("List all cron jobs").action(async (opts) => {
-    const client = await createClient();
-    const result = await safeCall(() => client.query("cronJobs:list", {}), "Failed to list cron jobs");
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
+function generateCodeReviewSkill() {
+  const files = /* @__PURE__ */ new Map();
+  files.set("SKILL.md", `---
+name: code-review
+description: Systematic code review following best practices for quality, security, and style
+version: 1.0.0
+tags:
+  - development
+  - review
+  - quality
+---
+
+# Code Review
+
+You are a code reviewer. When reviewing code, follow this systematic process:
+
+## Review Process
+
+1. **Critical Issues** \u2014 Security vulnerabilities, memory leaks, logic bugs, missing error handling
+2. **Code Quality** \u2014 Functions over 50 lines, code duplication, confusing names, missing types
+3. **Style Guide** \u2014 Check references/style-guide.md for naming and organization conventions
+4. **Performance** \u2014 Unnecessary re-renders, N+1 queries, missing memoization, large bundle imports
+5. **Testing** \u2014 Missing test coverage, edge cases not handled, brittle assertions
+
+## Feedback Format
+
+Provide feedback in this structure:
+
+**Summary**: One sentence overview of the code quality
+
+**Critical Issues**: List with file paths and line numbers
+- \`file.ts:42\` \u2014 Description of the issue
+
+**Suggestions**: Improvements that would help
+- Description of suggestion with code example
+
+**Positive Notes**: What the code does well
+
+## What to Look Out For
+
+- Unused variables and imports
+- Missing error handling (try/catch, null checks)
+- Security vulnerabilities (SQL injection, XSS, secrets in code)
+- Performance issues (unnecessary loops, missing indexes)
+- TypeScript: any types, missing return types, loose generics
+- React: missing keys, stale closures, missing deps in useEffect
+
+## Scripts
+
+- \`scripts/lint.ts\` \u2014 Run linting checks on a file or directory
+`);
+  files.set("references/style-guide.md", `# Code Style Guide
+
+## TypeScript Conventions
+- Use \`const\` by default, \`let\` only when reassignment is needed
+- Prefer \`interface\` over \`type\` for object shapes
+- Always specify return types for exported functions
+- Use \`unknown\` instead of \`any\` where possible
+- Prefer \`readonly\` for properties that shouldn't change
+
+## Naming Conventions
+- **Files**: kebab-case (\`my-component.tsx\`)
+- **Components**: PascalCase (\`MyComponent\`)
+- **Functions**: camelCase (\`getUserById\`)
+- **Constants**: UPPER_SNAKE_CASE (\`MAX_RETRIES\`)
+- **Types/Interfaces**: PascalCase (\`UserProfile\`)
+
+## File Organization
+- One component per file
+- Co-locate tests with source files (\`*.test.ts\`)
+- Group by feature, not by type
+- Keep files under 300 lines
+
+## Error Handling
+- Always handle promise rejections
+- Use typed errors with error codes
+- Log errors with context (user ID, request ID)
+- Never swallow errors silently
+`);
+  files.set("scripts/lint.ts", `#!/usr/bin/env npx tsx
+/**
+ * Simple Lint Script \u2014 Checks for common issues
+ *
+ * Usage: npx tsx scripts/lint.ts <file-or-directory>
+ */
+
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+
+const target = process.argv[2];
+if (!target) {
+  console.error('Usage: npx tsx scripts/lint.ts <file-or-directory>');
+  process.exit(1);
+}
+
+interface LintIssue {
+  file: string;
+  line: number;
+  severity: 'error' | 'warning';
+  message: string;
+}
+
+const issues: LintIssue[] = [];
+
+function lintFile(filePath: string) {
+  const content = readFileSync(filePath, 'utf-8');
+  const lines = content.split('\\n');
+
+  lines.forEach((line, i) => {
+    const lineNum = i + 1;
+    // Check for console.log
+    if (line.includes('console.log') && !filePath.includes('test')) {
+      issues.push({ file: filePath, line: lineNum, severity: 'warning', message: 'console.log found \u2014 remove before production' });
     }
-    header("Cron Jobs");
-    const items = result || [];
-    if (items.length === 0) {
-      info("No cron jobs. Create one with: agentforge cron create");
-      return;
+    // Check for debugger
+    if (line.trim() === 'debugger' || line.trim() === 'debugger;') {
+      issues.push({ file: filePath, line: lineNum, severity: 'error', message: 'debugger statement found' });
     }
-    table(items.map((c) => ({
-      ID: c._id?.slice(-8) || "N/A",
-      Name: c.name,
-      Schedule: c.schedule,
-      Agent: c.agentId,
-      Enabled: c.isEnabled ? "\u2714" : "\u2716",
-      "Last Run": c.lastRunAt ? formatDate(c.lastRunAt) : "Never",
-      "Next Run": c.nextRunAt ? formatDate(c.nextRunAt) : "N/A"
-    })));
-  });
-  cron.command("create").description("Create a new cron job (interactive)").option("--name <name>", "Job name").option("--schedule <cron>", "Cron expression").option("--agent <id>", "Agent ID").option("--action <action>", "Action to execute").action(async (opts) => {
-    const name = opts.name || await prompt3("Job name: ");
-    const schedule = opts.schedule || await prompt3('Cron schedule (e.g., "0 */5 * * * *" for every 5 min): ');
-    const agentId = opts.agent || await prompt3("Agent ID: ");
-    const action = opts.action || await prompt3("Action (message to send to agent): ");
-    if (!name || !schedule || !agentId || !action) {
-      error("All fields are required.");
-      process.exit(1);
+    // Check for any type
+    if (line.includes(': any') || line.includes('<any>')) {
+      issues.push({ file: filePath, line: lineNum, severity: 'warning', message: 'Use of "any" type \u2014 prefer "unknown" or specific type' });
+    }
+    // Check for var usage
+    if (/\\bvar\\s+/.test(line)) {
+      issues.push({ file: filePath, line: lineNum, severity: 'error', message: 'Use "const" or "let" instead of "var"' });
+    }
+    // Check for TODO/FIXME
+    if (/\\/\\/\\s*(TODO|FIXME|HACK|XXX)/.test(line)) {
+      issues.push({ file: filePath, line: lineNum, severity: 'warning', message: 'Unresolved TODO/FIXME comment' });
     }
-    const client = await createClient();
-    await safeCall(
-      () => client.mutation("cronJobs:create", { name, schedule, agentId, action, isEnabled: true }),
-      "Failed to create cron job"
-    );
-    success(`Cron job "${name}" created.`);
-  });
-  cron.command("delete").argument("<id>", "Cron job ID").description("Delete a cron job").action(async (id) => {
-    const client = await createClient();
-    await safeCall(() => client.mutation("cronJobs:remove", { _id: id }), "Failed to delete");
-    success(`Cron job "${id}" deleted.`);
-  });
-  cron.command("enable").argument("<id>", "Cron job ID").description("Enable a cron job").action(async (id) => {
-    const client = await createClient();
-    await safeCall(() => client.mutation("cronJobs:update", { _id: id, isEnabled: true }), "Failed");
-    success(`Cron job "${id}" enabled.`);
-  });
-  cron.command("disable").argument("<id>", "Cron job ID").description("Disable a cron job").action(async (id) => {
-    const client = await createClient();
-    await safeCall(() => client.mutation("cronJobs:update", { _id: id, isEnabled: false }), "Failed");
-    success(`Cron job "${id}" disabled.`);
   });
 }
 
-// src/commands/mcp.ts
-import readline5 from "readline";
-function prompt4(q) {
-  const rl = readline5.createInterface({ input: process.stdin, output: process.stdout });
+function processPath(p: string) {
+  const stat = statSync(p);
+  if (stat.isFile() && ['.ts', '.tsx', '.js', '.jsx'].includes(extname(p))) {
+    lintFile(p);
+  } else if (stat.isDirectory()) {
+    for (const entry of readdirSync(p)) {
+      if (!entry.startsWith('.') && entry !== 'node_modules' && entry !== 'dist') {
+        processPath(join(p, entry));
+      }
+    }
+  }
+}
+
+processPath(target);
+console.log(JSON.stringify({ issues, total: issues.length, errors: issues.filter(i => i.severity === 'error').length, warnings: issues.filter(i => i.severity === 'warning').length }));
+`);
+  return files;
+}
+function generateDataAnalystSkill() {
+  const files = /* @__PURE__ */ new Map();
+  files.set("SKILL.md", `---
+name: data-analyst
+description: Analyze CSV, JSON, and tabular data to generate summaries, statistics, and insights
+version: 1.0.0
+tags:
+  - data
+  - analysis
+  - csv
+  - json
+---
+
+# Data Analyst
+
+You are a data analysis assistant. Help users understand and extract insights from structured data.
+
+## Capabilities
+
+1. **Load Data** \u2014 Read CSV, JSON, and TSV files from the workspace
+2. **Summarize** \u2014 Generate column statistics (min, max, mean, median, mode)
+3. **Filter & Query** \u2014 Filter rows by conditions, select columns
+4. **Aggregate** \u2014 Group by columns and compute aggregates
+5. **Detect Anomalies** \u2014 Find outliers and missing values
+
+## How to Analyze
+
+1. First, read the data file using workspace filesystem tools
+2. Use \`scripts/analyze.ts\` for statistical analysis
+3. Present findings in a clear table format
+4. Suggest follow-up analyses based on initial findings
+
+## Scripts
+
+- \`scripts/analyze.ts\` \u2014 Compute statistics on CSV/JSON data
+
+## Output Format
+
+Present analysis results as:
+- **Dataset Overview**: Row count, column count, column types
+- **Key Statistics**: Per-column min, max, mean, median
+- **Missing Data**: Columns with null/empty values and their percentages
+- **Insights**: Notable patterns, correlations, or anomalies
+
+## Guidelines
+
+- Always show a sample of the data (first 5 rows) before analysis
+- Handle missing values gracefully \u2014 report them, don't crash
+- Use appropriate precision for numbers (2 decimal places for percentages)
+- Suggest visualizations when patterns would be clearer in chart form
+`);
+  files.set("scripts/analyze.ts", `#!/usr/bin/env npx tsx
+/**
+ * Data Analysis Script \u2014 Basic statistics for CSV/JSON data
+ *
+ * Usage: npx tsx scripts/analyze.ts <file.csv|file.json>
+ */
+
+import { readFileSync } from 'fs';
+import { extname } from 'path';
+
+const filePath = process.argv[2];
+if (!filePath) {
+  console.error('Usage: npx tsx scripts/analyze.ts <file.csv|file.json>');
+  process.exit(1);
+}
+
+function parseCSV(content: string): Record<string, string>[] {
+  const lines = content.trim().split('\\n');
+  const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+  return lines.slice(1).map(line => {
+    const values = line.split(',').map(v => v.trim().replace(/^"|"$/g, ''));
+    return Object.fromEntries(headers.map((h, i) => [h, values[i] ?? '']));
+  });
+}
+
+const content = readFileSync(filePath, 'utf-8');
+const ext = extname(filePath).toLowerCase();
+let data: Record<string, string>[];
+
+if (ext === '.json') {
+  const parsed = JSON.parse(content);
+  data = Array.isArray(parsed) ? parsed : [parsed];
+} else {
+  data = parseCSV(content);
+}
+
+const columns = Object.keys(data[0] || {});
+const stats: Record<string, any> = {};
+
+for (const col of columns) {
+  const values = data.map(row => row[col]).filter(v => v !== '' && v !== null && v !== undefined);
+  const numValues = values.map(Number).filter(n => !isNaN(n));
+
+  stats[col] = {
+    total: data.length,
+    nonNull: values.length,
+    missing: data.length - values.length,
+    missingPct: ((data.length - values.length) / data.length * 100).toFixed(1) + '%',
+    unique: new Set(values).size,
+  };
+
+  if (numValues.length > 0) {
+    numValues.sort((a, b) => a - b);
+    stats[col].type = 'numeric';
+    stats[col].min = Math.min(...numValues);
+    stats[col].max = Math.max(...numValues);
+    stats[col].mean = +(numValues.reduce((s, n) => s + n, 0) / numValues.length).toFixed(2);
+    stats[col].median = numValues.length % 2 === 0
+      ? +((numValues[numValues.length / 2 - 1] + numValues[numValues.length / 2]) / 2).toFixed(2)
+      : numValues[Math.floor(numValues.length / 2)];
+  } else {
+    stats[col].type = 'string';
+    stats[col].sample = values.slice(0, 3);
+  }
+}
+
+console.log(JSON.stringify({
+  rows: data.length,
+  columns: columns.length,
+  columnNames: columns,
+  stats,
+  sample: data.slice(0, 5),
+}, null, 2));
+`);
+  return files;
+}
+function generateApiTesterSkill() {
+  const files = /* @__PURE__ */ new Map();
+  files.set("SKILL.md", `---
+name: api-tester
+description: Test REST APIs with structured request/response validation
+version: 1.0.0
+tags:
+  - api
+  - testing
+  - http
+  - rest
+---
+
+# API Tester
+
+You are an API testing assistant. Help users test and validate REST API endpoints.
+
+## Capabilities
+
+1. **Send Requests** \u2014 GET, POST, PUT, PATCH, DELETE with headers and body
+2. **Validate Responses** \u2014 Check status codes, response structure, and timing
+3. **Chain Requests** \u2014 Use output from one request as input to another
+4. **Generate Reports** \u2014 Summarize test results with pass/fail status
+
+## How to Test
+
+Use \`scripts/request.ts\` to make HTTP requests:
+
+\`\`\`bash
+npx tsx scripts/request.ts GET https://api.example.com/users
+npx tsx scripts/request.ts POST https://api.example.com/users --body '{"name":"test"}'
+\`\`\`
+
+## Report Format
+
+For each API test, report:
+- **Endpoint**: METHOD URL
+- **Status**: HTTP status code (with pass/fail indicator)
+- **Response Time**: Duration in milliseconds
+- **Response Body**: Formatted JSON (truncated if large)
+- **Headers**: Key response headers
+
+## Guidelines
+
+- Always show the full request details (method, URL, headers, body)
+- Time every request and flag slow responses (>2s)
+- Validate JSON response structure when a schema is provided
+- Never send real credentials \u2014 use placeholders and warn the user
+- Group related tests together (e.g., CRUD operations on one resource)
+`);
+  files.set("scripts/request.ts", `#!/usr/bin/env npx tsx
+/**
+ * HTTP Request Script \u2014 Make API requests from the command line
+ *
+ * Usage: npx tsx scripts/request.ts <METHOD> <URL> [--header "Key: Value"] [--body '{"key":"value"}']
+ */
+
+const args = process.argv.slice(2);
+const method = args[0]?.toUpperCase() || 'GET';
+const url = args[1];
+
+if (!url) {
+  console.error('Usage: npx tsx scripts/request.ts <METHOD> <URL> [--header "K: V"] [--body JSON]');
+  process.exit(1);
+}
+
+const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+let body: string | undefined;
+
+for (let i = 2; i < args.length; i++) {
+  if (args[i] === '--header' && args[i + 1]) {
+    const [key, ...valueParts] = args[++i].split(':');
+    headers[key.trim()] = valueParts.join(':').trim();
+  }
+  if (args[i] === '--body' && args[i + 1]) {
+    body = args[++i];
+  }
+}
+
+async function makeRequest() {
+  const start = Date.now();
+  const res = await fetch(url, {
+    method,
+    headers,
+    ...(body && method !== 'GET' ? { body } : {}),
+  });
+  const elapsed = Date.now() - start;
+  const responseHeaders: Record<string, string> = {};
+  res.headers.forEach((v, k) => { responseHeaders[k] = v; });
+
+  let responseBody: any;
+  const contentType = res.headers.get('content-type') || '';
+  if (contentType.includes('json')) {
+    responseBody = await res.json();
+  } else {
+    responseBody = await res.text();
+  }
+
+  console.log(JSON.stringify({
+    request: { method, url, headers, body: body ? JSON.parse(body) : undefined },
+    response: {
+      status: res.status,
+      statusText: res.statusText,
+      headers: responseHeaders,
+      body: responseBody,
+      timeMs: elapsed,
+    },
+  }, null, 2));
+}
+
+makeRequest().catch((err) => {
+  console.error(JSON.stringify({ error: err.message }));
+  process.exit(1);
+});
+`);
+  return files;
+}
+function generateGitWorkflowSkill() {
+  const files = /* @__PURE__ */ new Map();
+  files.set("SKILL.md", `---
+name: git-workflow
+description: Git workflow automation including conventional commits, branch management, and changelog generation
+version: 1.0.0
+tags:
+  - git
+  - workflow
+  - development
+---
+
+# Git Workflow
+
+You are a Git workflow assistant. Help users follow best practices for version control.
+
+## Capabilities
+
+1. **Conventional Commits** \u2014 Generate commit messages following the Conventional Commits spec
+2. **Branch Management** \u2014 Create, switch, and clean up branches following naming conventions
+3. **PR Descriptions** \u2014 Generate pull request descriptions from commit history
+4. **Changelog** \u2014 Generate changelogs from commit history
+
+## Conventional Commit Format
+
+\`\`\`
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer(s)]
+\`\`\`
+
+### Types
+- \`feat\`: New feature (MINOR version bump)
+- \`fix\`: Bug fix (PATCH version bump)
+- \`docs\`: Documentation changes
+- \`style\`: Code style changes (formatting, semicolons)
+- \`refactor\`: Code refactoring (no feature/fix)
+- \`perf\`: Performance improvements
+- \`test\`: Adding or updating tests
+- \`chore\`: Build process, tooling, dependencies
+
+## Branch Naming
+
+- \`feat/<ticket>-<description>\` \u2014 New features
+- \`fix/<ticket>-<description>\` \u2014 Bug fixes
+- \`chore/<description>\` \u2014 Maintenance tasks
+- \`release/<version>\` \u2014 Release branches
+
+## Scripts
+
+- \`scripts/changelog.ts\` \u2014 Generate changelog from git log
+
+## Guidelines
+
+- One logical change per commit
+- Write commit messages in imperative mood ("Add feature" not "Added feature")
+- Reference issue/ticket numbers in commits
+- Keep PR descriptions focused on the "what" and "why"
+- Squash fix-up commits before merging
+`);
+  files.set("references/commit-examples.md", `# Commit Message Examples
+
+## Good Examples
+\`\`\`
+feat(auth): add OAuth2 login with Google provider
+fix(api): handle null response from payment gateway
+docs(readme): add deployment instructions for Cloudflare
+refactor(db): extract query builder into separate module
+perf(search): add index on user_email column
+test(auth): add integration tests for JWT refresh flow
+chore(deps): upgrade @mastra/core to 1.4.0
+\`\`\`
+
+## Bad Examples
+\`\`\`
+fixed stuff
+update
+WIP
+asdf
+changes
+\`\`\`
+`);
+  files.set("scripts/changelog.ts", `#!/usr/bin/env npx tsx
+/**
+ * Changelog Generator \u2014 Generate changelog from git log
+ *
+ * Usage: npx tsx scripts/changelog.ts [--since v1.0.0] [--until HEAD]
+ */
+
+import { execSync } from 'child_process';
+
+const args = process.argv.slice(2);
+let since = '';
+let until = 'HEAD';
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--since' && args[i + 1]) since = args[++i];
+  if (args[i] === '--until' && args[i + 1]) until = args[++i];
+}
+
+const range = since ? \`\${since}..\${until}\` : until;
+const log = execSync(\`git log \${range} --pretty=format:"%H|%s|%an|%ai" 2>/dev/null || echo ""\`, { encoding: 'utf-8' });
+
+interface Commit {
+  hash: string;
+  message: string;
+  author: string;
+  date: string;
+  type: string;
+  scope: string;
+  description: string;
+}
+
+const commits: Commit[] = log.trim().split('\\n').filter(Boolean).map(line => {
+  const [hash, message, author, date] = line.split('|');
+  const match = message.match(/^(\\w+)(?:\\(([^)]+)\\))?:\\s*(.+)$/);
+  return {
+    hash: hash.slice(0, 7),
+    message,
+    author,
+    date: date.split(' ')[0],
+    type: match?.[1] || 'other',
+    scope: match?.[2] || '',
+    description: match?.[3] || message,
+  };
+});
+
+const grouped: Record<string, Commit[]> = {};
+for (const c of commits) {
+  if (!grouped[c.type]) grouped[c.type] = [];
+  grouped[c.type].push(c);
+}
+
+const typeLabels: Record<string, string> = {
+  feat: 'Features',
+  fix: 'Bug Fixes',
+  docs: 'Documentation',
+  refactor: 'Refactoring',
+  perf: 'Performance',
+  test: 'Tests',
+  chore: 'Chores',
+};
+
+let changelog = '# Changelog\\n\\n';
+for (const [type, label] of Object.entries(typeLabels)) {
+  if (grouped[type]?.length) {
+    changelog += \`## \${label}\\n\\n\`;
+    for (const c of grouped[type]) {
+      const scope = c.scope ? \`**\${c.scope}**: \` : '';
+      changelog += \`- \${scope}\${c.description} (\${c.hash})\\n\`;
+    }
+    changelog += '\\n';
+  }
+}
+
+console.log(JSON.stringify({ changelog, totalCommits: commits.length, types: Object.keys(grouped) }));
+`);
+  return files;
+}
+function generateBrowserAutomationSkill() {
+  const files = /* @__PURE__ */ new Map();
+  files.set("SKILL.md", `---
+name: browser-automation
+description: Browser automation using Playwright. Navigate web pages, interact with elements, extract content, take screenshots, and run JavaScript.
+version: 1.0.0
+tags:
+  - web
+  - browser
+  - automation
+  - scraping
+---
+
+# Browser Automation
+
+You are a browser automation assistant. Help users interact with web pages programmatically.
+
+## Capabilities
+
+1. **Navigate** \u2014 Go to any URL and wait for the page to load
+2. **Click** \u2014 Click elements by CSS selector
+3. **Type** \u2014 Fill text into input fields
+4. **Screenshot** \u2014 Capture the current page as an image
+5. **Extract Text** \u2014 Get readable text content from pages or specific elements
+6. **Snapshot** \u2014 Get the accessibility tree for understanding page structure
+7. **Evaluate** \u2014 Run arbitrary JavaScript on the page
+8. **Wait** \u2014 Wait for elements to appear or for a specific duration
+9. **Scroll** \u2014 Scroll the page up or down
+10. **Select** \u2014 Choose options from dropdown menus
+11. **Hover** \u2014 Hover over elements to trigger menus or tooltips
+12. **Navigation** \u2014 Go back, forward, or reload the page
+
+## How to Use
+
+### Setup
+
+\`\`\`typescript
+import { createBrowserTool, MCPServer } from '@agentforge-ai/core';
+
+const server = new MCPServer({ name: 'my-tools' });
+const { tool, shutdown } = createBrowserTool({ headless: true });
+server.registerTool(tool);
+\`\`\`
+
+### Docker Sandbox Mode
+
+For secure, isolated execution:
+
+\`\`\`typescript
+const { tool, shutdown } = createBrowserTool({
+  sandboxMode: true,
+  headless: true,
+});
+\`\`\`
+
+## Agent Instructions
+
+1. Navigate to the target URL first
+2. Wait for key elements before interacting
+3. Use snapshot to understand page structure
+4. Use extractText to get readable content
+5. Use click and type for form interactions
+6. Take screenshots for visual verification
+7. Always close sessions when done
+
+## Guidelines
+
+- Prefer \`#id\` selectors over class-based selectors
+- Use \`wait\` before clicking or typing on dynamic pages
+- Use \`extractText\` with a selector for specific content
+- Take screenshots before and after critical actions
+- Close sessions to free resources
+`);
+  files.set("references/selectors.md", `# CSS Selector Guide for Browser Automation
+
+## Recommended Selectors (most to least reliable)
+
+1. \`#id\` \u2014 Element with a specific ID
+2. \`[data-testid="value"]\` \u2014 Test ID attributes
+3. \`[aria-label="value"]\` \u2014 Accessibility labels
+4. \`button:has-text("Click me")\` \u2014 Playwright text selectors
+5. \`.class-name\` \u2014 CSS class selectors
+6. \`tag.class\` \u2014 Tag + class combination
+
+## Examples
+
+\`\`\`
+#login-button           \u2192 Click the login button
+input[name="email"]      \u2192 Type into email field
+.nav-menu a:first-child \u2192 Click first nav link
+form button[type=submit] \u2192 Submit a form
+\`\`\`
+
+## Tips
+
+- Avoid fragile selectors like \`div > div > span:nth-child(3)\`
+- Use Playwright's text selectors: \`text=Submit\`
+- For dynamic content, wait for the element first
+- Use \`snapshot\` action to discover available selectors
+`);
+  files.set("scripts/scrape.ts", `#!/usr/bin/env npx tsx
+/**
+ * Example: Scrape a web page and extract its text content
+ *
+ * Usage: npx tsx scripts/scrape.ts <url>
+ */
+
+const url = process.argv[2];
+if (!url) {
+  console.error('Usage: npx tsx scripts/scrape.ts <url>');
+  process.exit(1);
+}
+
+console.log(JSON.stringify({
+  instruction: 'Use the browser tool to scrape this URL',
+  url,
+  steps: [
+    { action: 'navigate', url },
+    { action: 'wait', timeMs: 2000 },
+    { action: 'extractText' },
+    { action: 'screenshot', fullPage: true },
+    { action: 'close' },
+  ],
+}));
+`);
+  return files;
+}
+function registerSkillsCommand(program2) {
+  const skills = program2.command("skills").description("Manage agent skills (Mastra Workspace Skills)");
+  skills.command("list").option("--json", "Output as JSON").option("--registry", "Show available skills from the registry").description("List installed skills or browse the registry").action(async (opts) => {
+    if (opts.registry) {
+      header("AgentForge Skills Registry");
+      if (opts.json) {
+        console.log(JSON.stringify(BUILTIN_REGISTRY, null, 2));
+        return;
+      }
+      table(BUILTIN_REGISTRY.map((s) => ({
+        Name: s.name,
+        Description: truncate(s.description, 60),
+        Version: s.version,
+        Tags: s.tags.join(", ")
+      })));
+      info(`Install with: ${colors.cyan}agentforge skills install <name>${colors.reset}`);
+      return;
+    }
+    const skillsDir = resolveSkillsDir();
+    header("Installed Skills");
+    if (!fs6.existsSync(skillsDir)) {
+      info("No skills directory found. Install a skill with:");
+      dim(`  agentforge skills install <name>`);
+      dim(`  agentforge skills list --registry   # browse available skills`);
+      return;
+    }
+    const dirs = fs6.readdirSync(skillsDir).filter((d) => {
+      const fullPath = path6.join(skillsDir, d);
+      return fs6.statSync(fullPath).isDirectory() && fs6.existsSync(path6.join(fullPath, "SKILL.md"));
+    });
+    if (dirs.length === 0) {
+      info("No skills installed. Browse available skills with:");
+      dim(`  agentforge skills list --registry`);
+      return;
+    }
+    const lock = readSkillsLock(skillsDir);
+    const skillData = dirs.map((d) => {
+      const meta = readSkillMetadata(path6.join(skillsDir, d));
+      const lockEntry = lock.skills[d];
+      return {
+        Name: meta?.name || d,
+        Description: truncate(meta?.description || "", 50),
+        Version: meta?.version || "?",
+        Tags: (meta?.tags || []).join(", "),
+        Source: lockEntry?.source || "local",
+        Installed: lockEntry?.installedAt ? new Date(lockEntry.installedAt).toLocaleDateString() : "\u2014"
+      };
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(skillData, null, 2));
+      return;
+    }
+    table(skillData);
+    dim(`  Skills directory: ${skillsDir}`);
+    info("Skills are auto-discovered by the Mastra Workspace.");
+  });
+  skills.command("install").argument("<name>", "Skill name from registry, GitHub URL, or local path").option("--from <source>", "Source: registry (default), github, local", "registry").description("Install a skill into the workspace").action(async (name, opts) => {
+    const skillsDir = resolveSkillsDir();
+    const targetDir = path6.join(skillsDir, name.split("/").pop().replace(/\.git$/, ""));
+    if (fs6.existsSync(targetDir) && fs6.existsSync(path6.join(targetDir, "SKILL.md"))) {
+      warn(`Skill "${name}" is already installed at ${targetDir}`);
+      const overwrite = await prompt2("Overwrite? (y/N): ");
+      if (overwrite.toLowerCase() !== "y") {
+        info("Installation cancelled.");
+        return;
+      }
+      fs6.removeSync(targetDir);
+    }
+    fs6.mkdirSync(skillsDir, { recursive: true });
+    let source = opts.from;
+    let installedName = name;
+    if (opts.from === "local" || fs6.existsSync(name)) {
+      source = "local";
+      const sourcePath = path6.resolve(name);
+      if (!fs6.existsSync(sourcePath)) {
+        error(`Local path not found: ${sourcePath}`);
+        process.exit(1);
+      }
+      if (!fs6.existsSync(path6.join(sourcePath, "SKILL.md"))) {
+        error(`No SKILL.md found in ${sourcePath}. Not a valid skill directory.`);
+        process.exit(1);
+      }
+      installedName = path6.basename(sourcePath);
+      const dest = path6.join(skillsDir, installedName);
+      fs6.copySync(sourcePath, dest);
+      success(`Skill "${installedName}" installed from local path.`);
+    } else if (opts.from === "github" || name.includes("github.com") || name.includes("/")) {
+      source = "github";
+      const repoUrl = name.includes("github.com") ? name : `https://github.com/${name}`;
+      installedName = name.split("/").pop().replace(/\.git$/, "");
+      const dest = path6.join(skillsDir, installedName);
+      info(`Cloning skill from ${repoUrl}...`);
+      try {
+        execSync3(`git clone --depth 1 ${repoUrl} ${dest} 2>&1`, { encoding: "utf-8" });
+        fs6.removeSync(path6.join(dest, ".git"));
+        if (!fs6.existsSync(path6.join(dest, "SKILL.md"))) {
+          error(`Cloned repo does not contain a SKILL.md. Not a valid skill.`);
+          fs6.removeSync(dest);
+          process.exit(1);
+        }
+        success(`Skill "${installedName}" installed from GitHub.`);
+      } catch (err) {
+        error(`Failed to clone: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      source = "builtin";
+      const entry = findInRegistry(name);
+      if (!entry) {
+        error(`Skill "${name}" not found in the registry.`);
+        info("Available skills:");
+        BUILTIN_REGISTRY.forEach((s) => {
+          dim(`  ${colors.cyan}${s.name}${colors.reset} \u2014 ${s.description}`);
+        });
+        info(`
+Or install from GitHub: ${colors.cyan}agentforge skills install owner/repo --from github${colors.reset}`);
+        process.exit(1);
+      }
+      installedName = entry.name;
+      const files = generateBuiltinSkill(entry.name);
+      if (!files) {
+        error(`No content generator for skill "${entry.name}".`);
+        process.exit(1);
+      }
+      const dest = path6.join(skillsDir, installedName);
+      fs6.mkdirSync(dest, { recursive: true });
+      for (const [filePath, content] of files) {
+        const fullPath = path6.join(dest, filePath);
+        fs6.mkdirSync(path6.dirname(fullPath), { recursive: true });
+        fs6.writeFileSync(fullPath, content);
+      }
+      success(`Skill "${installedName}" installed from AgentForge registry.`);
+    }
+    const lock = readSkillsLock(skillsDir);
+    const meta = readSkillMetadata(path6.join(skillsDir, installedName));
+    lock.skills[installedName] = {
+      name: installedName,
+      version: meta?.version || "1.0.0",
+      source,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeSkillsLock(skillsDir, lock);
+    if (meta) {
+      console.log();
+      details({
+        Name: meta.name,
+        Description: meta.description,
+        Version: meta.version,
+        Tags: (meta.tags || []).join(", ") || "\u2014",
+        Path: path6.join(skillsDir, installedName)
+      });
+    }
+    info("The skill is now available to agents via the Mastra Workspace.");
+    dim("  Skills in the workspace/skills/ directory are auto-discovered.");
+    try {
+      const client = await createClient();
+      await safeCall(
+        () => client.mutation("skills:create", {
+          name: installedName,
+          displayName: meta?.name || installedName,
+          description: meta?.description || "",
+          category: (meta?.tags || [])[0] || "custom",
+          version: meta?.version || "1.0.0",
+          author: meta?.author || "Unknown",
+          code: `// Skill: ${installedName}
+// This skill uses the Agent Skills Specification (SKILL.md format)
+// See: workspace/skills/${installedName}/SKILL.md`
+        }),
+        "Failed to sync skill to Convex"
+      );
+      dim("  Skill synced to Convex database.");
+    } catch {
+      dim("  Convex not connected \u2014 skill installed locally only.");
+    }
+  });
+  skills.command("remove").argument("<name>", "Skill name to remove").option("--force", "Skip confirmation prompt", false).description("Remove an installed skill").action(async (name, opts) => {
+    const skillsDir = resolveSkillsDir();
+    const skillDir = path6.join(skillsDir, name);
+    if (!fs6.existsSync(skillDir)) {
+      error(`Skill "${name}" not found in ${skillsDir}`);
+      info("List installed skills with: agentforge skills list");
+      process.exit(1);
+    }
+    if (!opts.force) {
+      const confirm = await prompt2(`Remove skill "${name}" and delete all files? (y/N): `);
+      if (confirm.toLowerCase() !== "y") {
+        info("Removal cancelled.");
+        return;
+      }
+    }
+    fs6.removeSync(skillDir);
+    success(`Skill "${name}" removed from disk.`);
+    const lock = readSkillsLock(skillsDir);
+    delete lock.skills[name];
+    writeSkillsLock(skillsDir, lock);
+    try {
+      const client = await createClient();
+      const skills2 = await client.query("skills:list", {});
+      const skill = skills2.find((s) => s.name === name);
+      if (skill) {
+        await client.mutation("skills:remove", { id: skill._id });
+        dim("  Skill removed from Convex database.");
+      }
+    } catch {
+    }
+    info("Skill removed. Agents will no longer discover it.");
+  });
+  skills.command("search").argument("<query>", "Search query").description("Search for skills in the registry").action(async (query) => {
+    header("Skill Search Results");
+    const q = query.toLowerCase();
+    const matches = BUILTIN_REGISTRY.filter(
+      (e) => e.name.includes(q) || e.description.toLowerCase().includes(q) || e.tags.some((t) => t.includes(q))
+    );
+    if (matches.length === 0) {
+      info(`No skills matching "${query}".`);
+      info("Browse all skills: agentforge skills list --registry");
+      return;
+    }
+    table(matches.map((e) => ({
+      Name: e.name,
+      Description: truncate(e.description, 60),
+      Tags: e.tags.join(", "),
+      Version: e.version
+    })));
+    info(`Install with: ${colors.cyan}agentforge skills install <name>${colors.reset}`);
+  });
+  skills.command("create").description("Create a new skill (interactive)").option("--name <name>", "Skill name (kebab-case)").option("--description <desc>", "Skill description").option("--tags <tags>", "Comma-separated tags").action(async (opts) => {
+    const name = opts.name || await prompt2("Skill name (kebab-case): ");
+    const description = opts.description || await prompt2("Description: ");
+    const tagsInput = opts.tags || await prompt2("Tags (comma-separated, e.g. web,search): ");
+    const tags = tagsInput ? tagsInput.split(",").map((t) => t.trim()).filter(Boolean) : [];
+    if (!name) {
+      error("Skill name is required.");
+      process.exit(1);
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+      error("Skill name must be kebab-case (lowercase letters, numbers, hyphens).");
+      process.exit(1);
+    }
+    const skillsDir = resolveSkillsDir();
+    const skillDir = path6.join(skillsDir, name);
+    if (fs6.existsSync(skillDir)) {
+      error(`Skill "${name}" already exists at ${skillDir}`);
+      process.exit(1);
+    }
+    fs6.mkdirSync(path6.join(skillDir, "references"), { recursive: true });
+    fs6.mkdirSync(path6.join(skillDir, "scripts"), { recursive: true });
+    const tagsYaml = tags.length > 0 ? `tags:
+${tags.map((t) => `  - ${t}`).join("\n")}` : "tags: []";
+    fs6.writeFileSync(path6.join(skillDir, "SKILL.md"), `---
+name: ${name}
+description: ${description}
+version: 1.0.0
+${tagsYaml}
+---
+
+# ${name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")}
+
+${description}
+
+## Instructions
+
+<!-- Add instructions for how the agent should use this skill -->
+
+1. Step one
+2. Step two
+3. Step three
+
+## References
+
+See \`references/\` for supporting documentation.
+
+## Scripts
+
+See \`scripts/\` for executable scripts the agent can run.
+
+## Guidelines
+
+- Guideline one
+- Guideline two
+`);
+    fs6.writeFileSync(
+      path6.join(skillDir, "references", "README.md"),
+      `# References for ${name}
+
+Add supporting documentation here.
+`
+    );
+    fs6.writeFileSync(
+      path6.join(skillDir, "scripts", "example.ts"),
+      `#!/usr/bin/env npx tsx
+/**
+ * Example script for ${name}
+ */
+console.log('Hello from ${name}!');
+`
+    );
+    const lock = readSkillsLock(skillsDir);
+    lock.skills[name] = {
+      name,
+      version: "1.0.0",
+      source: "local",
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeSkillsLock(skillsDir, lock);
+    success(`Skill "${name}" created at ${skillDir}/`);
+    info("Files created:");
+    dim(`  ${skillDir}/SKILL.md`);
+    dim(`  ${skillDir}/references/README.md`);
+    dim(`  ${skillDir}/scripts/example.ts`);
+    console.log();
+    info(`Edit ${colors.cyan}SKILL.md${colors.reset} to add instructions for your agent.`);
+    info("The skill will be auto-discovered by the Mastra Workspace.");
+  });
+  skills.command("info").argument("<name>", "Skill name").description("Show detailed information about a skill").action(async (name) => {
+    const skillsDir = resolveSkillsDir();
+    const skillDir = path6.join(skillsDir, name);
+    if (fs6.existsSync(skillDir) && fs6.existsSync(path6.join(skillDir, "SKILL.md"))) {
+      const meta = readSkillMetadata(skillDir);
+      const lock = readSkillsLock(skillsDir);
+      const lockEntry = lock.skills[name];
+      header(`Skill: ${meta?.name || name}`);
+      details({
+        Name: meta?.name || name,
+        Description: meta?.description || "\u2014",
+        Version: meta?.version || "\u2014",
+        Tags: (meta?.tags || []).join(", ") || "\u2014",
+        Author: meta?.author || "\u2014",
+        Source: lockEntry?.source || "local",
+        "Installed At": lockEntry?.installedAt || "\u2014",
+        Path: skillDir
+      });
+      dim("  Files:");
+      const listFiles = (dir, prefix = "") => {
+        const entries = fs6.readdirSync(dir);
+        for (const entry2 of entries) {
+          const fullPath = path6.join(dir, entry2);
+          const stat = fs6.statSync(fullPath);
+          if (stat.isDirectory()) {
+            dim(`  ${prefix}${entry2}/`);
+            listFiles(fullPath, prefix + "  ");
+          } else {
+            dim(`  ${prefix}${entry2}`);
+          }
+        }
+      };
+      listFiles(skillDir, "  ");
+      console.log();
+      const content = fs6.readFileSync(path6.join(skillDir, "SKILL.md"), "utf-8");
+      const { content: body } = parseSkillMd(content);
+      info("Instructions preview:");
+      dim(body.trim().split("\n").slice(0, 10).map((l) => `  ${l}`).join("\n"));
+      if (body.trim().split("\n").length > 10) {
+        dim("  ...");
+      }
+      return;
+    }
+    const entry = findInRegistry(name);
+    if (entry) {
+      header(`Registry Skill: ${entry.name}`);
+      details({
+        Name: entry.name,
+        Description: entry.description,
+        Version: entry.version,
+        Tags: entry.tags.join(", "),
+        Author: entry.author,
+        Source: entry.source,
+        Status: "Not installed"
+      });
+      info(`Install with: ${colors.cyan}agentforge skills install ${entry.name}${colors.reset}`);
+      return;
+    }
+    error(`Skill "${name}" not found (installed or in registry).`);
+  });
+  program2.command("install").argument("<name>", "Skill name to install").option("--from <source>", "Source: registry (default), github, local", "registry").description("Install a skill (alias for: agentforge skills install)").action(async (name, opts) => {
+    const skillsCmd = skills.commands.find((c) => c.name() === "install");
+    if (skillsCmd) {
+      await skillsCmd.parseAsync([name, ...opts.from !== "registry" ? ["--from", opts.from] : []], { from: "user" });
+    }
+  });
+}
+
+// src/commands/cron.ts
+import readline4 from "readline";
+function prompt3(q) {
+  const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function registerCronCommand(program2) {
+  const cron = program2.command("cron").description("Manage cron jobs");
+  cron.command("list").option("--json", "Output as JSON").description("List all cron jobs").action(async (opts) => {
+    const client = await createClient();
+    const result = await safeCall(() => client.query("cronJobs:list", {}), "Failed to list cron jobs");
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    header("Cron Jobs");
+    const items = result || [];
+    if (items.length === 0) {
+      info("No cron jobs. Create one with: agentforge cron create");
+      return;
+    }
+    table(items.map((c) => ({
+      ID: c._id?.slice(-8) || "N/A",
+      Name: c.name,
+      Schedule: c.schedule,
+      Agent: c.agentId,
+      Enabled: c.isEnabled ? "\u2714" : "\u2716",
+      "Last Run": c.lastRun ? formatDate(c.lastRun) : "Never",
+      "Next Run": c.nextRun ? formatDate(c.nextRun) : "N/A"
+    })));
+  });
+  cron.command("create").description("Create a new cron job (interactive)").option("--name <name>", "Job name").option("--schedule <cron>", "Cron expression").option("--agent <id>", "Agent ID").option("--action <action>", "Action to execute").action(async (opts) => {
+    const name = opts.name || await prompt3("Job name: ");
+    const schedule = opts.schedule || await prompt3('Cron schedule (e.g., "0 */5 * * * *" for every 5 min): ');
+    const agentId = opts.agent || await prompt3("Agent ID: ");
+    const action = opts.action || await prompt3("Action (message to send to agent): ");
+    if (!name || !schedule || !agentId || !action) {
+      error("All fields are required.");
+      process.exit(1);
+    }
+    const client = await createClient();
+    await safeCall(
+      () => client.mutation("cronJobs:create", { name, schedule, agentId, prompt: action }),
+      "Failed to create cron job"
+    );
+    success(`Cron job "${name}" created.`);
+  });
+  cron.command("delete").argument("<id>", "Cron job ID").description("Delete a cron job").action(async (id) => {
+    const client = await createClient();
+    await safeCall(() => client.mutation("cronJobs:remove", { id }), "Failed to delete");
+    success(`Cron job "${id}" deleted.`);
+  });
+  cron.command("enable").argument("<id>", "Cron job ID").description("Enable a cron job").action(async (id) => {
+    const client = await createClient();
+    await safeCall(() => client.mutation("cronJobs:update", { id, isEnabled: true }), "Failed");
+    success(`Cron job "${id}" enabled.`);
+  });
+  cron.command("disable").argument("<id>", "Cron job ID").description("Disable a cron job").action(async (id) => {
+    const client = await createClient();
+    await safeCall(() => client.mutation("cronJobs:update", { id, isEnabled: false }), "Failed");
+    success(`Cron job "${id}" disabled.`);
+  });
+}
+
+// src/commands/mcp.ts
+import readline5 from "readline";
+function prompt4(q) {
+  const rl = readline5.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((r) => rl.question(q, (a) => {
     rl.close();
     r(a.trim());
@@ -1533,8 +2864,8 @@ function registerMcpCommand(program2) {
     table(items.map((c) => ({
       ID: c._id?.slice(-8) || "N/A",
       Name: c.name,
-      Type: c.type,
-      Endpoint: c.endpoint,
+      Type: c.protocol,
+      Endpoint: c.serverUrl,
       Connected: c.isConnected ? "\u2714" : "\u2716",
       Enabled: c.isEnabled ? "\u2714" : "\u2716"
     })));
@@ -1551,10 +2882,8 @@ function registerMcpCommand(program2) {
     await safeCall(
       () => client.mutation("mcpConnections:create", {
         name,
-        type,
-        endpoint,
-        isConnected: false,
-        isEnabled: true
+        serverUrl: endpoint,
+        protocol: type
       }),
       "Failed to add connection"
     );
@@ -1562,7 +2891,7 @@ function registerMcpCommand(program2) {
   });
   mcp.command("remove").argument("<id>", "Connection ID").description("Remove an MCP connection").action(async (id) => {
     const client = await createClient();
-    await safeCall(() => client.mutation("mcpConnections:remove", { _id: id }), "Failed");
+    await safeCall(() => client.mutation("mcpConnections:remove", { id }), "Failed");
     success(`Connection "${id}" removed.`);
   });
   mcp.command("test").argument("<id>", "Connection ID").description("Test an MCP connection").action(async (id) => {
@@ -1574,12 +2903,12 @@ function registerMcpCommand(program2) {
       error(`Connection "${id}" not found.`);
       process.exit(1);
     }
-    if (conn.type === "http" || conn.type === "sse") {
+    if (conn.protocol === "http" || conn.protocol === "sse") {
       try {
-        const res = await fetch(conn.endpoint, { method: "HEAD", signal: AbortSignal.timeout(5e3) });
+        const res = await fetch(conn.serverUrl, { method: "HEAD", signal: AbortSignal.timeout(5e3) });
         if (res.ok) {
           success(`Connection "${conn.name}" is reachable (HTTP ${res.status}).`);
-          await client.mutation("mcpConnections:update", { _id: conn._id, isConnected: true });
+          await client.mutation("mcpConnections:updateStatus", { id: conn._id, isConnected: true });
         } else {
           error(`Connection "${conn.name}" returned HTTP ${res.status}.`);
         }
@@ -1587,18 +2916,18 @@ function registerMcpCommand(program2) {
         error(`Connection "${conn.name}" failed: ${e.message}`);
       }
     } else {
-      info(`Connection type "${conn.type}" \u2014 manual verification required.`);
-      info(`Endpoint: ${conn.endpoint}`);
+      info(`Connection type "${conn.protocol}" \u2014 manual verification required.`);
+      info(`Endpoint: ${conn.serverUrl}`);
     }
   });
   mcp.command("enable").argument("<id>", "Connection ID").description("Enable a connection").action(async (id) => {
     const client = await createClient();
-    await safeCall(() => client.mutation("mcpConnections:update", { _id: id, isEnabled: true }), "Failed");
+    await safeCall(() => client.mutation("mcpConnections:update", { id, isEnabled: true }), "Failed");
     success(`Connection "${id}" enabled.`);
   });
   mcp.command("disable").argument("<id>", "Connection ID").description("Disable a connection").action(async (id) => {
     const client = await createClient();
-    await safeCall(() => client.mutation("mcpConnections:update", { _id: id, isEnabled: false }), "Failed");
+    await safeCall(() => client.mutation("mcpConnections:update", { id, isEnabled: false }), "Failed");
     success(`Connection "${id}" disabled.`);
   });
 }
@@ -1628,7 +2957,7 @@ function registerFilesCommand(program2) {
       Type: f.mimeType,
       Size: formatSize(f.size),
       Folder: f.folderId || "root",
-      Created: formatDate(f.createdAt)
+      Uploaded: formatDate(f.uploadedAt)
     })));
   });
   files.command("upload").argument("<filepath>", "Path to file to upload").option("--folder <id>", "Folder ID to upload to").option("--project <id>", "Project ID to associate with").description("Upload a file").action(async (filepath, opts) => {
@@ -1659,8 +2988,10 @@ function registerFilesCommand(program2) {
     await safeCall(
       () => client.mutation("files:create", {
         name,
+        originalName: name,
         mimeType,
         size: stat.size,
+        url: "pending-upload",
         folderId: opts.folder,
         projectId: opts.project
       }),
@@ -1671,7 +3002,7 @@ function registerFilesCommand(program2) {
   });
   files.command("delete").argument("<id>", "File ID").description("Delete a file").action(async (id) => {
     const client = await createClient();
-    await safeCall(() => client.mutation("files:remove", { _id: id }), "Failed to delete file");
+    await safeCall(() => client.mutation("files:remove", { id }), "Failed to delete file");
     success(`File "${id}" deleted.`);
   });
   const folders = program2.command("folders").description("Manage folders");
@@ -1705,7 +3036,7 @@ function registerFilesCommand(program2) {
   });
   folders.command("delete").argument("<id>", "Folder ID").description("Delete a folder").action(async (id) => {
     const client = await createClient();
-    await safeCall(() => client.mutation("folders:remove", { _id: id }), "Failed to delete folder");
+    await safeCall(() => client.mutation("folders:remove", { id }), "Failed to delete folder");
     success(`Folder "${id}" deleted.`);
   });
 }
@@ -1742,7 +3073,6 @@ function registerProjectsCommand(program2) {
     table(items.map((p) => ({
       ID: p._id?.slice(-8) || "N/A",
       Name: p.name,
-      Status: p.status,
       Description: (p.description || "").slice(0, 40),
       Created: formatDate(p.createdAt)
     })));
@@ -1751,7 +3081,7 @@ function registerProjectsCommand(program2) {
     const description = opts.description || await prompt5("Description (optional): ");
     const client = await createClient();
     await safeCall(
-      () => client.mutation("projects:create", { name, description, status: "active" }),
+      () => client.mutation("projects:create", { name, description: description || void 0 }),
       "Failed to create project"
     );
     success(`Project "${name}" created.`);
@@ -1768,7 +3098,6 @@ function registerProjectsCommand(program2) {
     details({
       ID: project._id,
       Name: project.name,
-      Status: project.status,
       Description: project.description || "N/A",
       Created: formatDate(project.createdAt),
       Updated: formatDate(project.updatedAt)
@@ -1783,7 +3112,7 @@ function registerProjectsCommand(program2) {
       }
     }
     const client = await createClient();
-    await safeCall(() => client.mutation("projects:remove", { _id: id }), "Failed");
+    await safeCall(() => client.mutation("projects:remove", { id }), "Failed");
     success(`Project "${id}" deleted.`);
   });
   projects.command("switch").argument("<id>", "Project ID to switch to").description("Set the active project").action(async (id) => {
@@ -2001,7 +3330,7 @@ function registerVaultCommand(program2) {
       Name: s.name,
       Category: s.category || "general",
       Provider: s.provider || "N/A",
-      "Last Rotated": s.lastRotatedAt ? formatDate(s.lastRotatedAt) : "Never",
+      "Last Updated": s.updatedAt ? formatDate(s.updatedAt) : "Never",
       Created: formatDate(s.createdAt)
     })));
   });
@@ -2017,7 +3346,7 @@ function registerVaultCommand(program2) {
     await safeCall(
       () => client.mutation("vault:store", {
         name,
-        encryptedValue: value,
+        value,
         category: opts.category,
         provider: opts.provider
       }),
@@ -2034,15 +3363,11 @@ function registerVaultCommand(program2) {
       process.exit(1);
     }
     if (opts.reveal) {
-      const value = await safeCall(
-        () => client.query("vault:getDecrypted", { _id: secret._id }),
-        "Failed to retrieve secret"
-      );
-      console.log(value);
+      info(`${name} = ${secret.maskedValue || "****"}`);
+      dim("  Note: Full decryption is only available server-side for security.");
     } else {
-      const masked = secret.encryptedValue ? secret.encryptedValue.slice(0, 4) + "****" + secret.encryptedValue.slice(-4) : "****";
-      info(`${name} = ${masked}`);
-      dim("  Use --reveal to show the full value.");
+      info(`${name} = ${secret.maskedValue || "****"}`);
+      dim("  Use --reveal to attempt to show more details.");
     }
   });
   vault.command("delete").argument("<name>", "Secret name").option("-f, --force", "Skip confirmation").description("Delete a secret").action(async (name, opts) => {
@@ -2060,7 +3385,7 @@ function registerVaultCommand(program2) {
       error(`Secret "${name}" not found.`);
       process.exit(1);
     }
-    await safeCall(() => client.mutation("vault:remove", { _id: secret._id }), "Failed");
+    await safeCall(() => client.mutation("vault:remove", { id: secret._id }), "Failed");
     success(`Secret "${name}" deleted.`);
   });
   vault.command("rotate").argument("<name>", "Secret name").description("Rotate a secret (set a new value)").action(async (name) => {
@@ -2077,7 +3402,7 @@ function registerVaultCommand(program2) {
       process.exit(1);
     }
     await safeCall(
-      () => client.mutation("vault:rotate", { _id: secret._id, newValue }),
+      () => client.mutation("vault:update", { id: secret._id, value: newValue }),
       "Failed to rotate secret"
     );
     success(`Secret "${name}" rotated.`);
@@ -2100,7 +3425,7 @@ function maskKey(key) {
 }
 function promptSecret2(question) {
   return new Promise((resolve2) => {
-    const readline10 = __require("readline");
+    const readline12 = __require("readline");
     if (process.stdin.isTTY) {
       process.stdout.write(question);
       process.stdin.setRawMode(true);
@@ -2128,7 +3453,7 @@ function promptSecret2(question) {
       };
       process.stdin.on("data", onData);
     } else {
-      const rl = readline10.createInterface({ input: process.stdin, output: process.stdout });
+      const rl = readline12.createInterface({ input: process.stdin, output: process.stdout });
       rl.question(question, (ans) => {
         rl.close();
         resolve2(ans.trim());
@@ -2219,8 +3544,8 @@ function registerKeysCommand(program2) {
     }
     const target = items[0];
     if (!opts.force) {
-      const readline10 = __require("readline");
-      const rl = readline10.createInterface({ input: process.stdin, output: process.stdout });
+      const readline12 = __require("readline");
+      const rl = readline12.createInterface({ input: process.stdin, output: process.stdout });
       const answer = await new Promise((resolve2) => {
         rl.question(`Delete "${target.keyName}" for ${provider}? (y/N): `, (ans) => {
           rl.close();
@@ -2448,7 +3773,7 @@ function registerStatusCommand(program2) {
     const args = {};
     if (opts.agent) args.agentId = opts.agent;
     const result = await safeCall(
-      () => client.query("heartbeat:listPending", args),
+      () => client.query("heartbeat:listActive", args),
       "Failed to check heartbeat"
     );
     const items = result || [];
@@ -2456,26 +3781,26 @@ function registerStatusCommand(program2) {
       success("All tasks complete. No pending work.");
       return;
     }
-    info(`Found ${items.length} pending task(s):`);
+    info(`Found ${items.length} active heartbeat(s):`);
     items.forEach((task, i) => {
-      console.log(`  ${colors.yellow}${i + 1}.${colors.reset} [${task.agentId}] ${task.taskDescription || "Unnamed task"}`);
-      console.log(`     ${colors.dim}Status: ${task.status} | Thread: ${task.threadId || "N/A"}${colors.reset}`);
+      console.log(`  ${colors.yellow}${i + 1}.${colors.reset} [${task.agentId}] ${task.currentTask || "No current task"}`);
+      console.log(`     ${colors.dim}Status: ${task.status} | Pending: ${(task.pendingTasks || []).length} task(s)${colors.reset}`);
     });
     console.log();
     const rl = readline9.createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await new Promise((r) => rl.question("Resume pending tasks? (y/N): ", (a) => {
+    const answer = await new Promise((r) => rl.question("Reset stalled heartbeats? (y/N): ", (a) => {
       rl.close();
       r(a.trim());
     }));
     if (answer.toLowerCase() === "y") {
       for (const task of items) {
-        info(`Resuming task for agent "${task.agentId}"...`);
+        info(`Resetting heartbeat for agent "${task.agentId}"...`);
         await safeCall(
-          () => client.mutation("heartbeat:resume", { _id: task._id }),
-          "Failed to resume task"
+          () => client.mutation("heartbeat:updateStatus", { agentId: task.agentId, status: "active", currentTask: void 0 }),
+          "Failed to reset heartbeat"
         );
       }
-      success("All pending tasks resumed.");
+      success("All heartbeats reset.");
     }
   });
 }
@@ -2618,6 +3943,844 @@ function registerLoginCommand(program2) {
   });
 }
 
+// src/commands/channel-telegram.ts
+import fs10 from "fs-extra";
+import path10 from "path";
+import readline10 from "readline";
+function prompt8(q) {
+  const rl = readline10.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function readEnvValue(key) {
+  const cwd = process.cwd();
+  const envFiles = [".env.local", ".env", ".env.production"];
+  for (const envFile of envFiles) {
+    const envPath = path10.join(cwd, envFile);
+    if (fs10.existsSync(envPath)) {
+      const content = fs10.readFileSync(envPath, "utf-8");
+      const match = content.match(new RegExp(`^${key}=(.+)$`, "m"));
+      if (match) return match[1].trim().replace(/["']/g, "");
+    }
+  }
+  return void 0;
+}
+function writeEnvValue(key, value, envFile = ".env.local") {
+  const envPath = path10.join(process.cwd(), envFile);
+  let content = "";
+  if (fs10.existsSync(envPath)) {
+    content = fs10.readFileSync(envPath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
+  if (idx >= 0) {
+    lines[idx] = `${key}=${value}`;
+  } else {
+    lines.push(`${key}=${value}`);
+  }
+  fs10.writeFileSync(envPath, lines.join("\n"));
+}
+function registerChannelTelegramCommand(program2) {
+  const channel = program2.command("channel:telegram").description("Manage the Telegram messaging channel");
+  channel.command("start").description("Start the Telegram bot and begin routing messages to an agent").option("-a, --agent <id>", "Agent ID to route messages to").option("-t, --token <token>", "Telegram Bot Token (overrides .env)").option("--webhook-url <url>", "Use webhook mode with this URL").option("--webhook-secret <secret>", "Webhook verification secret").option("--bot-username <username>", "Bot username for @mention detection").option("--polling-interval <ms>", "Polling interval in milliseconds", "1000").option("--log-level <level>", "Log level: debug, info, warn, error", "info").option("--group-mention-only", "Only respond to @mentions in groups", true).action(async (opts) => {
+    header("Telegram Channel");
+    const botToken = opts.token || readEnvValue("TELEGRAM_BOT_TOKEN") || process.env.TELEGRAM_BOT_TOKEN;
+    if (!botToken) {
+      error("Telegram Bot Token not found.");
+      info("Set it with: agentforge channel:telegram configure");
+      info("Or pass it with: --token <bot-token>");
+      info("Or set TELEGRAM_BOT_TOKEN in your .env.local file");
+      process.exit(1);
+    }
+    const convexUrl = readEnvValue("CONVEX_URL") || process.env.CONVEX_URL;
+    if (!convexUrl) {
+      error("CONVEX_URL not found. Run `npx convex dev` first.");
+      process.exit(1);
+    }
+    let agentId = opts.agent;
+    if (!agentId) {
+      agentId = readEnvValue("AGENTFORGE_AGENT_ID") || process.env.AGENTFORGE_AGENT_ID;
+    }
+    if (!agentId) {
+      info("No agent specified. Fetching available agents...");
+      const client = await createClient();
+      const agents = await safeCall(
+        () => client.query("agents:list", {}),
+        "Failed to list agents"
+      );
+      if (!agents || agents.length === 0) {
+        error("No agents found. Create one first: agentforge agents create");
+        process.exit(1);
+      }
+      console.log();
+      agents.forEach((a, i) => {
+        console.log(
+          `  ${colors.cyan}${i + 1}.${colors.reset} ${a.name} ${colors.dim}(${a.id})${colors.reset} \u2014 ${a.model}`
+        );
+      });
+      console.log();
+      const choice = await prompt8("Select agent (number or ID): ");
+      const idx = parseInt(choice) - 1;
+      agentId = idx >= 0 && idx < agents.length ? agents[idx].id : choice;
+    }
+    info(`Agent:    ${agentId}`);
+    info(`Convex:   ${convexUrl}`);
+    info(`Mode:     ${opts.webhookUrl ? "Webhook" : "Long-polling"}`);
+    info(`Log:      ${opts.logLevel}`);
+    console.log();
+    let TelegramChannel;
+    try {
+      const corePkg = "@agentforge-ai/core/channels/telegram";
+      const mod = await import(
+        /* @vite-ignore */
+        corePkg
+      );
+      TelegramChannel = mod.TelegramChannel;
+    } catch (importError) {
+      error("Could not import @agentforge-ai/core. Using built-in Telegram runner.");
+      dim(`  Error: ${importError.message}`);
+      console.log();
+      await runMinimalTelegramBot({
+        botToken,
+        agentId,
+        convexUrl,
+        logLevel: opts.logLevel,
+        pollingIntervalMs: parseInt(opts.pollingInterval)
+      });
+      return;
+    }
+    try {
+      const channel2 = new TelegramChannel({
+        botToken,
+        agentId,
+        convexUrl,
+        useWebhook: !!opts.webhookUrl,
+        webhookUrl: opts.webhookUrl,
+        webhookSecret: opts.webhookSecret,
+        botUsername: opts.botUsername,
+        groupMentionOnly: opts.groupMentionOnly,
+        pollingIntervalMs: parseInt(opts.pollingInterval),
+        logLevel: opts.logLevel
+      });
+      await channel2.start();
+      success("Telegram bot is running!");
+      dim("  Press Ctrl+C to stop.");
+      await new Promise(() => {
+      });
+    } catch (startError) {
+      error(`Failed to start Telegram bot: ${startError.message}`);
+      process.exit(1);
+    }
+  });
+  channel.command("configure").description("Configure the Telegram bot token and settings").action(async () => {
+    header("Configure Telegram Channel");
+    const currentToken = readEnvValue("TELEGRAM_BOT_TOKEN");
+    if (currentToken) {
+      const masked = currentToken.slice(0, 6) + "****" + currentToken.slice(-4);
+      info(`Current token: ${masked}`);
+    }
+    console.log();
+    info("To get a bot token:");
+    dim("  1. Open Telegram and search for @BotFather");
+    dim("  2. Send /newbot and follow the instructions");
+    dim("  3. Copy the token provided");
+    console.log();
+    const token = await prompt8("Telegram Bot Token: ");
+    if (!token) {
+      error("Bot token is required.");
+      process.exit(1);
+    }
+    info("Validating token...");
+    try {
+      const response = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+      const data = await response.json();
+      if (!data.ok) {
+        error("Invalid bot token. Please check and try again.");
+        process.exit(1);
+      }
+      success(`Bot verified: @${data.result?.username} (${data.result?.first_name})`);
+      if (data.result?.username) {
+        writeEnvValue("TELEGRAM_BOT_USERNAME", data.result.username);
+      }
+    } catch (fetchError) {
+      warn(`Could not validate token (network error): ${fetchError.message}`);
+      info("Saving token anyway. You can validate later with: agentforge channel:telegram status");
+    }
+    writeEnvValue("TELEGRAM_BOT_TOKEN", token);
+    success("Token saved to .env.local");
+    console.log();
+    const defaultAgent = await prompt8("Default agent ID (optional, press Enter to skip): ");
+    if (defaultAgent) {
+      writeEnvValue("AGENTFORGE_AGENT_ID", defaultAgent);
+      success(`Default agent set to: ${defaultAgent}`);
+    }
+    console.log();
+    success("Configuration complete!");
+    info("Start the bot with: agentforge channel:telegram start");
+  });
+  channel.command("status").description("Check the Telegram bot configuration and connectivity").action(async () => {
+    header("Telegram Channel Status");
+    const token = readEnvValue("TELEGRAM_BOT_TOKEN");
+    const agentId = readEnvValue("AGENTFORGE_AGENT_ID");
+    const convexUrl = readEnvValue("CONVEX_URL");
+    const botUsername = readEnvValue("TELEGRAM_BOT_USERNAME");
+    const statusData = {
+      "Bot Token": token ? `${token.slice(0, 6)}****${token.slice(-4)}` : `${colors.red}Not configured${colors.reset}`,
+      "Bot Username": botUsername ? `@${botUsername}` : `${colors.dim}Unknown${colors.reset}`,
+      "Default Agent": agentId || `${colors.dim}Not set${colors.reset}`,
+      "Convex URL": convexUrl || `${colors.red}Not configured${colors.reset}`
+    };
+    details(statusData);
+    if (token) {
+      info("Checking bot connectivity...");
+      try {
+        const response = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+        const data = await response.json();
+        if (data.ok) {
+          success(`Bot online: @${data.result?.username} (ID: ${data.result?.id})`);
+        } else {
+          error("Bot token is invalid or expired.");
+        }
+      } catch {
+        warn("Could not reach Telegram API (network error).");
+      }
+    }
+    if (convexUrl) {
+      info("Checking Convex connectivity...");
+      try {
+        const client = await createClient();
+        const agents = await client.query("agents:list", {});
+        success(`Convex connected. ${agents.length} agents available.`);
+      } catch {
+        warn("Could not reach Convex deployment.");
+      }
+    }
+  });
+}
+async function runMinimalTelegramBot(config) {
+  const { botToken, agentId, convexUrl } = config;
+  const apiBase = `https://api.telegram.org/bot${botToken}`;
+  const convexBase = convexUrl.replace(/\/$/, "");
+  const threadMap = /* @__PURE__ */ new Map();
+  let lastUpdateId = 0;
+  info("Verifying bot token...");
+  const meRes = await fetch(`${apiBase}/getMe`);
+  const meData = await meRes.json();
+  if (!meData.ok) {
+    error("Invalid bot token.");
+    process.exit(1);
+  }
+  success(`Bot connected: @${meData.result?.username}`);
+  await fetch(`${apiBase}/deleteWebhook`, { method: "POST" });
+  info("Polling for messages...");
+  dim("  Press Ctrl+C to stop.");
+  console.log();
+  process.on("SIGINT", () => {
+    console.log("\nStopping...");
+    process.exit(0);
+  });
+  async function convexMutation(fn, args) {
+    const res = await fetch(`${convexBase}/api/mutation`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: fn, args })
+    });
+    const data = await res.json();
+    if (data.status === "error") throw new Error(data.errorMessage);
+    return data.value;
+  }
+  async function convexAction(fn, args) {
+    const res = await fetch(`${convexBase}/api/action`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: fn, args })
+    });
+    const data = await res.json();
+    if (data.status === "error") throw new Error(data.errorMessage);
+    return data.value;
+  }
+  async function sendTelegramMessage(chatId, text) {
+    await fetch(`${apiBase}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text })
+    });
+  }
+  async function sendTyping(chatId) {
+    await fetch(`${apiBase}/sendChatAction`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, action: "typing" })
+    }).catch(() => {
+    });
+  }
+  async function getOrCreateThread(chatId, senderName) {
+    const cached = threadMap.get(chatId);
+    if (cached) return cached;
+    const threadId = await convexMutation("chat:createThread", {
+      agentId,
+      name: senderName ? `Telegram: ${senderName}` : `Telegram Chat ${chatId}`,
+      userId: `telegram:${chatId}`
+    });
+    threadMap.set(chatId, threadId);
+    return threadId;
+  }
+  while (true) {
+    try {
+      const res = await fetch(`${apiBase}/getUpdates`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          offset: lastUpdateId + 1,
+          timeout: 30,
+          allowed_updates: ["message"]
+        })
+      });
+      const data = await res.json();
+      if (!data.ok || !data.result) continue;
+      for (const update of data.result) {
+        lastUpdateId = update.update_id;
+        const msg = update.message;
+        if (!msg?.text) continue;
+        const chatId = String(msg.chat.id);
+        const senderName = msg.from?.first_name || "User";
+        const text = msg.text.trim();
+        if (text === "/start") {
+          threadMap.delete(chatId);
+          await sendTelegramMessage(chatId, `\u{1F44B} Welcome! I'm powered by AgentForge.
+
+Send me a message and I'll respond using AI.
+
+Commands:
+/new \u2014 Start a new conversation
+/help \u2014 Show help`);
+          continue;
+        }
+        if (text === "/new") {
+          threadMap.delete(chatId);
+          await sendTelegramMessage(chatId, "\u{1F504} New conversation started. Send me a message!");
+          continue;
+        }
+        if (text === "/help") {
+          await sendTelegramMessage(chatId, "\u{1F916} AgentForge Telegram Bot\n\nJust send me a message and I'll respond using AI.\n\nCommands:\n/start \u2014 Reset and show welcome\n/new \u2014 Start a fresh conversation\n/help \u2014 Show this help");
+          continue;
+        }
+        console.log(`[${senderName}] ${text}`);
+        await sendTyping(chatId);
+        try {
+          const threadId = await getOrCreateThread(chatId, senderName);
+          const result = await convexAction("chat:sendMessage", {
+            agentId,
+            threadId,
+            content: text,
+            userId: `telegram:${msg.from?.id || chatId}`
+          });
+          if (result?.response) {
+            const response = result.response;
+            if (response.length <= 4096) {
+              await sendTelegramMessage(chatId, response);
+            } else {
+              const chunks = response.match(/.{1,4096}/gs) || [];
+              for (const chunk of chunks) {
+                await sendTelegramMessage(chatId, chunk);
+              }
+            }
+            console.log(`[Agent] ${response.substring(0, 100)}${response.length > 100 ? "..." : ""}`);
+          } else {
+            await sendTelegramMessage(chatId, "\u{1F914} I couldn't generate a response. Please try again.");
+          }
+        } catch (routeError) {
+          console.error(`Error: ${routeError.message}`);
+          await sendTelegramMessage(chatId, "\u26A0\uFE0F Sorry, I encountered an error. Please try again.");
+        }
+      }
+    } catch (pollError) {
+      if (pollError.message?.includes("ECONNREFUSED") || pollError.message?.includes("fetch failed")) {
+        warn("Network error. Retrying in 5s...");
+        await new Promise((r) => setTimeout(r, 5e3));
+      } else {
+        console.error(`Poll error: ${pollError.message}`);
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+    }
+  }
+}
+
+// src/commands/channel-whatsapp.ts
+import fs11 from "fs-extra";
+import path11 from "path";
+import readline11 from "readline";
+function prompt9(q) {
+  const rl = readline11.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((r) => rl.question(q, (a) => {
+    rl.close();
+    r(a.trim());
+  }));
+}
+function readEnvValue2(key) {
+  const cwd = process.cwd();
+  const envFiles = [".env.local", ".env", ".env.production"];
+  for (const envFile of envFiles) {
+    const envPath = path11.join(cwd, envFile);
+    if (fs11.existsSync(envPath)) {
+      const content = fs11.readFileSync(envPath, "utf-8");
+      const match = content.match(new RegExp(`^${key}=(.+)$`, "m"));
+      if (match) return match[1].trim().replace(/["']/g, "");
+    }
+  }
+  return void 0;
+}
+function writeEnvValue2(key, value, envFile = ".env.local") {
+  const envPath = path11.join(process.cwd(), envFile);
+  let content = "";
+  if (fs11.existsSync(envPath)) {
+    content = fs11.readFileSync(envPath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
+  if (idx >= 0) {
+    lines[idx] = `${key}=${value}`;
+  } else {
+    lines.push(`${key}=${value}`);
+  }
+  fs11.writeFileSync(envPath, lines.join("\n"));
+}
+function registerChannelWhatsAppCommand(program2) {
+  const channel = program2.command("channel:whatsapp").description("Manage the WhatsApp messaging channel");
+  channel.command("start").description("Start the WhatsApp webhook server and begin routing messages to an agent").option("-a, --agent <id>", "Agent ID to route messages to").option("--access-token <token>", "WhatsApp Cloud API access token (overrides .env)").option("--phone-number-id <id>", "WhatsApp Business Phone Number ID (overrides .env)").option("--verify-token <token>", "Webhook verify token (overrides .env)").option("--webhook-port <port>", "Port for the webhook server", "3001").option("--webhook-path <path>", "Path for the webhook endpoint", "/webhook/whatsapp").option("--api-version <version>", "WhatsApp Cloud API version", "v21.0").option("--log-level <level>", "Log level: debug, info, warn, error", "info").action(async (opts) => {
+    header("WhatsApp Channel");
+    const accessToken = opts.accessToken || readEnvValue2("WHATSAPP_ACCESS_TOKEN") || process.env.WHATSAPP_ACCESS_TOKEN;
+    if (!accessToken) {
+      error("WhatsApp Access Token not found.");
+      info("Set it with: agentforge channel:whatsapp configure");
+      info("Or pass it with: --access-token <token>");
+      info("Or set WHATSAPP_ACCESS_TOKEN in your .env.local file");
+      process.exit(1);
+    }
+    const phoneNumberId = opts.phoneNumberId || readEnvValue2("WHATSAPP_PHONE_NUMBER_ID") || process.env.WHATSAPP_PHONE_NUMBER_ID;
+    if (!phoneNumberId) {
+      error("WhatsApp Phone Number ID not found.");
+      info("Set it with: agentforge channel:whatsapp configure");
+      info("Or pass it with: --phone-number-id <id>");
+      info("Or set WHATSAPP_PHONE_NUMBER_ID in your .env.local file");
+      process.exit(1);
+    }
+    const verifyToken = opts.verifyToken || readEnvValue2("WHATSAPP_VERIFY_TOKEN") || process.env.WHATSAPP_VERIFY_TOKEN;
+    if (!verifyToken) {
+      error("WhatsApp Verify Token not found.");
+      info("Set it with: agentforge channel:whatsapp configure");
+      info("Or pass it with: --verify-token <token>");
+      info("Or set WHATSAPP_VERIFY_TOKEN in your .env.local file");
+      process.exit(1);
+    }
+    const convexUrl = readEnvValue2("CONVEX_URL") || process.env.CONVEX_URL;
+    if (!convexUrl) {
+      error("CONVEX_URL not found. Run `npx convex dev` first.");
+      process.exit(1);
+    }
+    let agentId = opts.agent;
+    if (!agentId) {
+      agentId = readEnvValue2("AGENTFORGE_AGENT_ID") || process.env.AGENTFORGE_AGENT_ID;
+    }
+    if (!agentId) {
+      info("No agent specified. Fetching available agents...");
+      const client = await createClient();
+      const agents = await safeCall(
+        () => client.query("agents:list", {}),
+        "Failed to list agents"
+      );
+      if (!agents || agents.length === 0) {
+        error("No agents found. Create one first: agentforge agents create");
+        process.exit(1);
+      }
+      console.log();
+      agents.forEach((a, i) => {
+        console.log(
+          `  ${colors.cyan}${i + 1}.${colors.reset} ${a.name} ${colors.dim}(${a.id})${colors.reset} \u2014 ${a.model}`
+        );
+      });
+      console.log();
+      const choice = await prompt9("Select agent (number or ID): ");
+      const idx = parseInt(choice) - 1;
+      agentId = idx >= 0 && idx < agents.length ? agents[idx].id : choice;
+    }
+    const webhookPort = parseInt(opts.webhookPort);
+    const webhookPath = opts.webhookPath;
+    info(`Agent:       ${agentId}`);
+    info(`Convex:      ${convexUrl}`);
+    info(`Webhook:     http://localhost:${webhookPort}${webhookPath}`);
+    info(`API Version: ${opts.apiVersion}`);
+    info(`Log:         ${opts.logLevel}`);
+    console.log();
+    let WhatsAppChannel;
+    try {
+      const corePkg = "@agentforge-ai/core/channels/whatsapp";
+      const mod = await import(
+        /* @vite-ignore */
+        corePkg
+      );
+      WhatsAppChannel = mod.WhatsAppChannel;
+    } catch (importError) {
+      error("Could not import @agentforge-ai/core. Using built-in WhatsApp runner.");
+      dim(`  Error: ${importError.message}`);
+      console.log();
+      await runMinimalWhatsAppBot({
+        accessToken,
+        phoneNumberId,
+        verifyToken,
+        agentId,
+        convexUrl,
+        webhookPort,
+        webhookPath,
+        logLevel: opts.logLevel
+      });
+      return;
+    }
+    try {
+      const channel2 = new WhatsAppChannel({
+        accessToken,
+        phoneNumberId,
+        verifyToken,
+        agentId,
+        convexUrl,
+        webhookPort,
+        webhookPath,
+        apiVersion: opts.apiVersion,
+        logLevel: opts.logLevel
+      });
+      await channel2.start();
+      success("WhatsApp webhook server is running!");
+      dim(`  Webhook URL: http://localhost:${webhookPort}${webhookPath}`);
+      dim("  Configure this URL in your Meta App Dashboard.");
+      dim("  Press Ctrl+C to stop.");
+      await new Promise(() => {
+      });
+    } catch (startError) {
+      error(`Failed to start WhatsApp channel: ${startError.message}`);
+      process.exit(1);
+    }
+  });
+  channel.command("configure").description("Configure the WhatsApp Cloud API credentials").action(async () => {
+    header("Configure WhatsApp Channel");
+    console.log();
+    info("To set up WhatsApp Cloud API:");
+    dim("  1. Go to https://developers.facebook.com/apps/");
+    dim("  2. Create or select a Meta App with WhatsApp product");
+    dim("  3. Go to WhatsApp > API Setup");
+    dim("  4. Copy the Access Token, Phone Number ID, and set a Verify Token");
+    console.log();
+    const currentToken = readEnvValue2("WHATSAPP_ACCESS_TOKEN");
+    if (currentToken) {
+      const masked = currentToken.slice(0, 10) + "****" + currentToken.slice(-4);
+      info(`Current access token: ${masked}`);
+    }
+    const accessToken = await prompt9("WhatsApp Access Token: ");
+    if (!accessToken) {
+      error("Access token is required.");
+      process.exit(1);
+    }
+    info("Validating access token...");
+    try {
+      const response = await fetch("https://graph.facebook.com/v21.0/me", {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      });
+      const data = await response.json();
+      if (data.error) {
+        warn(`Token validation warning: ${data.error.message}`);
+        info("Saving token anyway. You can validate later with: agentforge channel:whatsapp status");
+      } else {
+        success(`Token verified: ${data.name || data.id}`);
+      }
+    } catch (fetchError) {
+      warn(`Could not validate token (network error): ${fetchError.message}`);
+      info("Saving token anyway.");
+    }
+    writeEnvValue2("WHATSAPP_ACCESS_TOKEN", accessToken);
+    success("Access token saved to .env.local");
+    console.log();
+    const currentPhoneId = readEnvValue2("WHATSAPP_PHONE_NUMBER_ID");
+    if (currentPhoneId) {
+      info(`Current Phone Number ID: ${currentPhoneId}`);
+    }
+    const phoneNumberId = await prompt9("WhatsApp Phone Number ID: ");
+    if (!phoneNumberId) {
+      error("Phone Number ID is required.");
+      process.exit(1);
+    }
+    info("Validating phone number...");
+    try {
+      const response = await fetch(`https://graph.facebook.com/v21.0/${phoneNumberId}`, {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      });
+      const data = await response.json();
+      if (data.error) {
+        warn(`Phone number validation warning: ${data.error.message}`);
+      } else {
+        success(`Phone number verified: ${data.display_phone_number} (${data.verified_name})`);
+      }
+    } catch {
+      warn("Could not validate phone number (network error).");
+    }
+    writeEnvValue2("WHATSAPP_PHONE_NUMBER_ID", phoneNumberId);
+    success("Phone Number ID saved to .env.local");
+    console.log();
+    const currentVerifyToken = readEnvValue2("WHATSAPP_VERIFY_TOKEN");
+    if (currentVerifyToken) {
+      info(`Current verify token: ${currentVerifyToken.slice(0, 6)}****`);
+    }
+    let verifyToken = await prompt9("Webhook Verify Token (press Enter to auto-generate): ");
+    if (!verifyToken) {
+      verifyToken = `agentforge_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
+      info(`Generated verify token: ${verifyToken}`);
+    }
+    writeEnvValue2("WHATSAPP_VERIFY_TOKEN", verifyToken);
+    success("Verify token saved to .env.local");
+    console.log();
+    const defaultAgent = await prompt9("Default agent ID (optional, press Enter to skip): ");
+    if (defaultAgent) {
+      writeEnvValue2("AGENTFORGE_AGENT_ID", defaultAgent);
+      success(`Default agent set to: ${defaultAgent}`);
+    }
+    console.log();
+    success("Configuration complete!");
+    info("Start the webhook server with: agentforge channel:whatsapp start");
+    console.log();
+    info("Next steps:");
+    dim("  1. Start the webhook server: agentforge channel:whatsapp start");
+    dim("  2. Expose the webhook URL (e.g., with ngrok or cloudflared)");
+    dim("  3. Configure the webhook URL in your Meta App Dashboard");
+    dim('  4. Subscribe to "messages" webhook field');
+  });
+  channel.command("status").description("Check the WhatsApp channel configuration and connectivity").action(async () => {
+    header("WhatsApp Channel Status");
+    const accessToken = readEnvValue2("WHATSAPP_ACCESS_TOKEN");
+    const phoneNumberId = readEnvValue2("WHATSAPP_PHONE_NUMBER_ID");
+    const verifyToken = readEnvValue2("WHATSAPP_VERIFY_TOKEN");
+    const agentId = readEnvValue2("AGENTFORGE_AGENT_ID");
+    const convexUrl = readEnvValue2("CONVEX_URL");
+    const statusData = {
+      "Access Token": accessToken ? `${accessToken.slice(0, 10)}****${accessToken.slice(-4)}` : `${colors.red}Not configured${colors.reset}`,
+      "Phone Number ID": phoneNumberId || `${colors.red}Not configured${colors.reset}`,
+      "Verify Token": verifyToken ? `${verifyToken.slice(0, 6)}****` : `${colors.red}Not configured${colors.reset}`,
+      "Default Agent": agentId || `${colors.dim}Not set${colors.reset}`,
+      "Convex URL": convexUrl || `${colors.red}Not configured${colors.reset}`
+    };
+    details(statusData);
+    if (accessToken && phoneNumberId) {
+      info("Checking WhatsApp Cloud API connectivity...");
+      try {
+        const response = await fetch(`https://graph.facebook.com/v21.0/${phoneNumberId}`, {
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        const data = await response.json();
+        if (data.error) {
+          error(`API error: ${data.error.message}`);
+        } else {
+          success(`WhatsApp Business: ${data.verified_name || data.display_phone_number} (ID: ${data.id})`);
+        }
+      } catch {
+        warn("Could not reach WhatsApp Cloud API (network error).");
+      }
+    }
+    if (convexUrl) {
+      info("Checking Convex connectivity...");
+      try {
+        const client = await createClient();
+        const agents = await client.query("agents:list", {});
+        success(`Convex connected. ${agents.length} agents available.`);
+      } catch {
+        warn("Could not reach Convex deployment.");
+      }
+    }
+  });
+}
+async function runMinimalWhatsAppBot(config) {
+  const { accessToken, phoneNumberId, verifyToken, agentId, convexUrl, webhookPort, webhookPath } = config;
+  const apiBase = `https://graph.facebook.com/v21.0`;
+  const convexBase = convexUrl.replace(/\/$/, "");
+  const threadMap = /* @__PURE__ */ new Map();
+  info("Verifying WhatsApp access token...");
+  try {
+    const res = await fetch(`${apiBase}/${phoneNumberId}`, {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    const data = await res.json();
+    if (data.error) {
+      error(`API error: ${data.error.message}`);
+      process.exit(1);
+    }
+    success(`WhatsApp Business: ${data.verified_name || data.display_phone_number}`);
+  } catch (fetchError) {
+    warn(`Could not verify token: ${fetchError.message}`);
+    info("Continuing anyway...");
+  }
+  async function convexMutation(fn, args) {
+    const res = await fetch(`${convexBase}/api/mutation`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: fn, args })
+    });
+    const data = await res.json();
+    if (data.status === "error") throw new Error(data.errorMessage);
+    return data.value;
+  }
+  async function convexAction(fn, args) {
+    const res = await fetch(`${convexBase}/api/action`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: fn, args })
+    });
+    const data = await res.json();
+    if (data.status === "error") throw new Error(data.errorMessage);
+    return data.value;
+  }
+  async function sendWhatsAppMessage(to, text) {
+    await fetch(`${apiBase}/${phoneNumberId}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        messaging_product: "whatsapp",
+        to,
+        type: "text",
+        text: { body: text }
+      })
+    });
+  }
+  async function markAsRead(messageId) {
+    await fetch(`${apiBase}/${phoneNumberId}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        messaging_product: "whatsapp",
+        status: "read",
+        message_id: messageId
+      })
+    }).catch(() => {
+    });
+  }
+  async function getOrCreateThread(phoneNumber, senderName) {
+    const cached = threadMap.get(phoneNumber);
+    if (cached) return cached;
+    const threadId = await convexMutation("chat:createThread", {
+      agentId,
+      name: senderName ? `WhatsApp: ${senderName}` : `WhatsApp +${phoneNumber}`,
+      userId: `whatsapp:${phoneNumber}`
+    });
+    threadMap.set(phoneNumber, threadId);
+    return threadId;
+  }
+  const http = await import("http");
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url || "/", `http://localhost:${webhookPort}`);
+    if (url.pathname !== webhookPath) {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+    if (req.method === "GET") {
+      const mode = url.searchParams.get("hub.mode");
+      const token = url.searchParams.get("hub.verify_token");
+      const challenge = url.searchParams.get("hub.challenge");
+      if (mode === "subscribe" && token === verifyToken) {
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end(challenge);
+      } else {
+        res.writeHead(403);
+        res.end("Forbidden");
+      }
+      return;
+    }
+    if (req.method === "POST") {
+      try {
+        const chunks = [];
+        for await (const chunk of req) {
+          chunks.push(chunk);
+        }
+        const body = JSON.parse(Buffer.concat(chunks).toString());
+        res.writeHead(200);
+        res.end("OK");
+        if (body.object !== "whatsapp_business_account") return;
+        for (const entry of body.entry || []) {
+          for (const change of entry.changes || []) {
+            if (change.field !== "messages") continue;
+            const contacts = change.value.contacts || [];
+            const messages = change.value.messages || [];
+            for (const msg of messages) {
+              if (msg.type !== "text" || !msg.text?.body) continue;
+              const from = msg.from;
+              const text = msg.text.body.trim();
+              const contact = contacts.find((c) => c.wa_id === from);
+              const senderName = contact?.profile?.name || from;
+              console.log(`[${senderName}] ${text}`);
+              await markAsRead(msg.id);
+              try {
+                const threadId = await getOrCreateThread(from, senderName);
+                const result = await convexAction("chat:sendMessage", {
+                  agentId,
+                  threadId,
+                  content: text,
+                  userId: `whatsapp:${from}`
+                });
+                if (result?.response) {
+                  const response = result.response;
+                  if (response.length <= 4096) {
+                    await sendWhatsAppMessage(from, response);
+                  } else {
+                    const chunks2 = response.match(/.{1,4096}/gs) || [];
+                    for (const chunk of chunks2) {
+                      await sendWhatsAppMessage(from, chunk);
+                    }
+                  }
+                  console.log(`[Agent] ${response.substring(0, 100)}${response.length > 100 ? "..." : ""}`);
+                } else {
+                  await sendWhatsAppMessage(from, "\u{1F914} I couldn't generate a response. Please try again.");
+                }
+              } catch (routeError) {
+                console.error(`Error: ${routeError.message}`);
+                await sendWhatsAppMessage(from, "\u26A0\uFE0F Sorry, I encountered an error. Please try again.");
+              }
+            }
+          }
+        }
+      } catch (parseError) {
+        console.error(`Parse error: ${parseError.message}`);
+        if (!res.headersSent) {
+          res.writeHead(400);
+          res.end("Bad Request");
+        }
+      }
+      return;
+    }
+    res.writeHead(405);
+    res.end("Method Not Allowed");
+  });
+  process.on("SIGINT", () => {
+    console.log("\nStopping...");
+    server.close();
+    process.exit(0);
+  });
+  server.listen(webhookPort, () => {
+    success(`Webhook server listening on port ${webhookPort}`);
+    info(`Webhook URL: http://localhost:${webhookPort}${webhookPath}`);
+    console.log();
+    info("Next steps:");
+    dim("  1. Expose this URL publicly (e.g., ngrok http " + webhookPort + ")");
+    dim("  2. Configure the webhook URL in your Meta App Dashboard");
+    dim('  3. Subscribe to "messages" webhook field');
+    dim("  Press Ctrl+C to stop.");
+  });
+  await new Promise(() => {
+  });
+}
+
 // src/index.ts
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -2630,7 +4793,7 @@ program.name("agentforge").description("AgentForge \u2014 NanoClaw: A minimalist
 program.command("create").argument("<project-name>", "Name of the project to create").description("Create a new AgentForge project").option("-t, --template <template>", "Project template to use", "default").action(async (projectName, options) => {
   await createProject(projectName, options);
 });
-program.command("run").description("Start the local development environment").option("-p, --port <port>", "Port for the dev server", "3000").action(async (options) => {
+program.command("run").description("Start the local development environment").option("-p, --port <port>", "Port for the dev server", "3000").option("-s, --sandbox <type>", "Sandbox provider for agent execution (local, docker, e2b, none)", "local").action(async (options) => {
   await runProject(options);
 });
 program.command("deploy").description("Deploy the project to production").option("--env <path>", "Path to environment file", ".env.production").option("--dry-run", "Preview deployment without executing", false).option("--rollback", "Rollback to previous deployment", false).option("--force", "Skip confirmation prompts", false).option("--provider <provider>", "Deployment provider (convex or cloud)", "convex").option("--project <projectId>", "Project ID for cloud deployments").option("--version <tag>", "Version tag for the deployment").action(async (options) => {
@@ -2649,6 +4812,8 @@ registerProjectsCommand(program);
 registerConfigCommand(program);
 registerVaultCommand(program);
 registerKeysCommand(program);
+registerChannelTelegramCommand(program);
+registerChannelWhatsAppCommand(program);
 registerStatusCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map