assistme 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  claimTask,
   clearConfig,
   completeTask,
   createSession,
@@ -248,26 +249,11 @@ var SessionManager = class {
     if (!this.session || !this.userId || !this.conversationId) return;
     log.info(`Running scheduled task: "${scheduledTask.name}"`);
     try {
-      const task = await createTask(
-        this.conversationId,
-        this.userId,
-        this.session.id,
+      await this.submitTask(
         `[Scheduled: ${scheduledTask.name}] ${scheduledTask.prompt}`
       );
-      if (this.onTask) {
-        this.processing = true;
-        await setSessionBusy(this.session.id, true);
-        try {
-          await this.onTask(task);
-        } catch (err) {
-          log.error(`Scheduled task error: ${err}`);
-        } finally {
-          await setSessionBusy(this.session.id, false);
-          this.processing = false;
-        }
-      }
     } catch (err) {
-      log.error(`Failed to create scheduled task: ${err}`);
+      log.error(`Scheduled task error: ${err}`);
     }
   }
   async pollForTasks() {
@@ -330,6 +316,34 @@ var SessionManager = class {
       log.debug(`Stale session cleanup error: ${err}`);
     }
   }
+  /**
+   * Submit a task from the interactive prompt or scheduled job.
+   * Sets processing=true BEFORE creating the task so the poll loop
+   * never races to pick it up.
+   */
+  async submitTask(prompt) {
+    if (!this.session || !this.userId || !this.conversationId || !this.onTask) {
+      throw new Error("Session not started");
+    }
+    this.processing = true;
+    await setSessionBusy(this.session.id, true);
+    try {
+      const task = await createTask(
+        this.conversationId,
+        this.userId,
+        this.session.id,
+        prompt
+      );
+      await claimTask(task.id);
+      await this.onTask(task);
+    } catch (err) {
+      log.error(`Task error: ${err}`);
+      throw err;
+    } finally {
+      await setSessionBusy(this.session.id, false);
+      this.processing = false;
+    }
+  }
   /**
    * Stop the session with a safety timeout to prevent hanging on shutdown.
    */
@@ -811,554 +825,82 @@ function getBrowser(port = 9222) {
   return browserInstance;
 }
 
-// src/tools/filesystem.ts
-import { readFile, writeFile, readdir, stat, mkdir } from "fs/promises";
-import { resolve, relative, join } from "path";
-import { glob } from "glob";
-function assertWithinWorkspace(filePath) {
-  const config = getConfig();
-  const resolved = resolve(config.workspacePath, filePath);
-  if (!resolved.startsWith(config.workspacePath)) {
-    throw new Error(
-      `Access denied: path "${filePath}" is outside workspace "${config.workspacePath}"`
-    );
+// src/agent/memory.ts
+var MemoryManager = class {
+  userId;
+  constructor(userId) {
+    this.userId = userId;
   }
-  return resolved;
-}
-async function readFileContent(path, offset, limit) {
-  const resolved = assertWithinWorkspace(path);
-  const content = await readFile(resolved, "utf-8");
-  const lines = content.split("\n");
-  const start = offset || 0;
-  const end = limit ? start + limit : lines.length;
-  const selected = lines.slice(start, end);
-  return selected.map((line, i) => `${String(start + i + 1).padStart(5)} | ${line}`).join("\n");
-}
-async function writeFileContent(path, content) {
-  const resolved = assertWithinWorkspace(path);
-  const dir = resolve(resolved, "..");
-  await mkdir(dir, { recursive: true });
-  await writeFile(resolved, content, "utf-8");
-  return `File written: ${path} (${content.length} bytes)`;
-}
-async function searchFiles(pattern, directory) {
-  const config = getConfig();
-  const cwd = directory ? assertWithinWorkspace(directory) : config.workspacePath;
-  const matches = await glob(pattern, {
-    cwd,
-    nodir: false,
-    ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**"]
-  });
-  if (matches.length === 0) return "No files found matching the pattern.";
-  return matches.slice(0, 50).map((m) => relative(config.workspacePath, join(cwd, m))).join("\n");
-}
-async function listDirectory(path) {
-  const config = getConfig();
-  const resolved = path ? assertWithinWorkspace(path) : config.workspacePath;
-  const entries = await readdir(resolved, { withFileTypes: true });
-  const results = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") && entry.name !== ".env.example") continue;
-    const icon = entry.isDirectory() ? "\u{1F4C1}" : "\u{1F4C4}";
-    const info = entry.isFile() ? await stat(join(resolved, entry.name)).then(
-      (s) => ` (${formatSize(s.size)})`
-    ) : "";
-    results.push(`${icon} ${entry.name}${info}`);
+  /**
+   * Store a new memory. Called by the agent after completing tasks
+   * to remember important facts about the user.
+   */
+  async remember(content, category = "general", options) {
+    const sb = getSupabase();
+    const expiresAt = options?.expiresInDays ? new Date(
+      Date.now() + options.expiresInDays * 864e5
+    ).toISOString() : null;
+    const { data, error } = await sb.from("agent_memories").insert({
+      user_id: this.userId,
+      category,
+      content,
+      importance: options?.importance ?? 5,
+      tags: options?.tags ?? [],
+      source_message_id: options?.sourceMessageId ?? null,
+      expires_at: expiresAt
+    }).select().single();
+    if (error) throw new Error(`Failed to store memory: ${error.message}`);
+    log.debug(`Memory stored: [${category}] ${content.slice(0, 80)}...`);
+    return data;
   }
-  return results.join("\n") || "Empty directory.";
-}
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-async function searchContent(pattern, fileGlob, directory) {
-  const config = getConfig();
-  const cwd = directory ? assertWithinWorkspace(directory) : config.workspacePath;
-  const files = await glob(fileGlob || "**/*", {
-    cwd,
-    nodir: true,
-    ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**"]
-  });
-  const regex = new RegExp(pattern, "gi");
-  const results = [];
-  for (const file of files.slice(0, 200)) {
-    try {
-      const content = await readFile(join(cwd, file), "utf-8");
-      const lines = content.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (regex.test(lines[i])) {
-          const relPath = relative(config.workspacePath, join(cwd, file));
-          results.push(`${relPath}:${i + 1}: ${lines[i].trim()}`);
-          regex.lastIndex = 0;
-          if (results.length >= 30) break;
-        }
-      }
-      if (results.length >= 30) break;
-    } catch {
+  /**
+   * Search memories by query text. Uses ILIKE + tag containment.
+   */
+  async search(query2, limit = 10) {
+    const sb = getSupabase();
+    const sanitized = query2.replace(/[%_]/g, "\\$&");
+    const { data, error } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).or(
+      `content.ilike.%${sanitized}%,tags.cs.{${sanitized}}`
+    ).order("importance", { ascending: false }).limit(limit);
+    if (error) {
+      log.warn(`Memory search failed: ${error.message}`);
+      return [];
+    }
+    if (data && data.length > 0) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await Promise.all(
+        data.map(
+          (m) => sb.from("agent_memories").update({
+            access_count: m.access_count + 1,
+            last_accessed_at: now
+          }).eq("id", m.id)
+        )
+      );
     }
+    return data || [];
   }
-  return results.length > 0 ? results.join("\n") : "No matches found.";
-}
-
-// src/tools/shell.ts
-import { exec } from "child_process";
-var TIMEOUT_MS = 3e4;
-var MAX_OUTPUT = 5e4;
-var BLOCKED_PATTERNS = [
-  /rm\s+(-\w*\s+)*-\w*r\w*\s+\/($|\s)/i,
-  // rm -rf /, rm -fr /, etc.
-  /rm\s+(-\w*\s+)*-\w*r\w*\s+~($|\s|\/)/i,
-  // rm -rf ~, rm -fr ~/, etc.
-  /\bmkfs\b/i,
-  // mkfs (any form)
-  /\bdd\s+.*\bif=/i,
-  // dd if=
-  /:\s*\(\s*\)\s*\{/,
-  // fork bomb :(){}
-  /\bchmod\s+(-\w+\s+)*-R\s+777\s+\//i,
-  // chmod -R 777 /
-  />\s*\/dev\/sd[a-z]/i,
-  // write to raw disk
-  /\bshutdown\b/i,
-  // shutdown
-  /\breboot\b/i,
-  // reboot
-  /\bsystemctl\s+(start|stop|disable|mask)\b/i
-  // dangerous systemctl ops
-];
-function isBlocked(command) {
-  return BLOCKED_PATTERNS.some((pattern) => pattern.test(command));
-}
-async function executeShell(command, cwd) {
-  if (isBlocked(command)) {
-    throw new Error(`Command blocked for safety: "${command}"`);
-  }
-  const config = getConfig();
-  const workDir = cwd || config.workspacePath;
-  return new Promise((resolve2) => {
-    exec(
-      command,
-      {
-        cwd: workDir,
-        timeout: TIMEOUT_MS,
-        maxBuffer: 1024 * 1024,
-        // 1MB buffer
-        env: { ...process.env, TERM: "dumb" }
-      },
-      (error, stdout, stderr) => {
-        let output = "";
-        if (stdout) {
-          output += stdout;
-        }
-        if (stderr) {
-          output += stderr ? `
-[stderr]
-${stderr}` : "";
-        }
-        if (error && !stdout && !stderr) {
-          output = `Error: ${error.message}`;
-        }
-        if (output.length > MAX_OUTPUT) {
-          output = output.slice(0, MAX_OUTPUT) + `
-
-[Output truncated at ${MAX_OUTPUT} bytes]`;
-        }
-        resolve2(output || "(no output)");
-      }
-    );
-  });
-}
-
-// src/tools/index.ts
-function getToolDefinitions() {
-  return [
-    // ── File System Tools ───────────────────────────────────────
-    {
-      name: "read_file",
-      description: "Read the contents of a file. Returns line-numbered content. Use offset/limit for large files.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path relative to workspace" },
-          offset: { type: "number", description: "Start line (0-indexed)" },
-          limit: { type: "number", description: "Max lines to read" }
-        },
-        required: ["path"]
-      }
-    },
-    {
-      name: "write_file",
-      description: "Write content to a file. Creates parent directories if needed.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path relative to workspace" },
-          content: { type: "string", description: "Content to write" }
-        },
-        required: ["path", "content"]
-      }
-    },
-    {
-      name: "search_files",
-      description: "Search for files matching a glob pattern (e.g. '**/*.ts').",
-      input_schema: {
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "Glob pattern" },
-          directory: { type: "string", description: "Directory (relative to workspace)" }
-        },
-        required: ["pattern"]
-      }
-    },
-    {
-      name: "search_content",
-      description: "Search file contents for a regex pattern. Returns matching lines.",
-      input_schema: {
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "Regex pattern" },
-          file_glob: { type: "string", description: "File glob filter (default: **/*)" },
-          directory: { type: "string", description: "Directory (relative to workspace)" }
-        },
-        required: ["pattern"]
-      }
-    },
-    {
-      name: "list_directory",
-      description: "List files and directories in a path.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Directory path (default: workspace root)" }
-        }
-      }
-    },
-    {
-      name: "execute_command",
-      description: "Execute a shell command in the workspace directory.",
-      input_schema: {
-        type: "object",
-        properties: {
-          command: { type: "string", description: "Shell command" },
-          cwd: { type: "string", description: "Working directory (relative)" }
-        },
-        required: ["command"]
-      }
-    },
-    // ── Browser Tools (CDP - controls user's real Chrome) ───────
-    {
-      name: "browser_connect",
-      description: "Connect to the user's real Chrome browser via CDP. The user must have Chrome running with --remote-debugging-port=9222. This shares the user's actual browser session including all logins and cookies.",
-      input_schema: {
-        type: "object",
-        properties: {
-          tab_index: {
-            type: "number",
-            description: "Tab index to connect to (default: 0, the first tab). Use browser_list_tabs to see available tabs."
-          }
-        }
-      }
-    },
-    {
-      name: "browser_navigate",
-      description: "Navigate the user's browser to a URL. Opens the page in the currently connected tab, using the user's real browser with all their cookies and logins.",
-      input_schema: {
-        type: "object",
-        properties: {
-          url: { type: "string", description: "URL to navigate to" }
-        },
-        required: ["url"]
-      }
-    },
-    {
-      name: "browser_read_page",
-      description: "Read the text content of the currently open page in the user's browser. Returns the page title, URL, and main text content. Use this to understand what's on the page.",
-      input_schema: { type: "object", properties: {} }
-    },
-    {
-      name: "browser_screenshot",
-      description: "Take a screenshot of the current browser page. Returns a base64-encoded PNG image. Use this when you need to visually understand the page layout, verify an action worked, or see dynamic content.",
-      input_schema: { type: "object", properties: {} }
-    },
-    {
-      name: "browser_click",
-      description: "Click on an element in the user's browser using a CSS selector. Use browser_get_elements first to find clickable elements.",
-      input_schema: {
-        type: "object",
-        properties: {
-          selector: {
-            type: "string",
-            description: "CSS selector of the element to click (e.g. '#submit-btn', 'a.nav-link', 'button:nth-of-type(2)')"
-          }
-        },
-        required: ["selector"]
-      }
-    },
-    {
-      name: "browser_type",
-      description: "Type text into an input field in the user's browser. Focuses the element and sets its value.",
-      input_schema: {
-        type: "object",
-        properties: {
-          selector: {
-            type: "string",
-            description: "CSS selector of the input element"
-          },
-          text: {
-            type: "string",
-            description: "Text to type into the element"
-          }
-        },
-        required: ["selector", "text"]
-      }
-    },
-    {
-      name: "browser_press_key",
-      description: "Press a keyboard key in the browser. Supports: Enter, Tab, Escape, Backspace, ArrowDown, ArrowUp, or any single character.",
-      input_schema: {
-        type: "object",
-        properties: {
-          key: { type: "string", description: "Key to press" }
-        },
-        required: ["key"]
-      }
-    },
-    {
-      name: "browser_scroll",
-      description: "Scroll the page up or down.",
-      input_schema: {
-        type: "object",
-        properties: {
-          direction: {
-            type: "string",
-            description: "'down' or 'up'"
-          }
-        },
-        required: ["direction"]
-      }
-    },
-    {
-      name: "browser_get_elements",
-      description: "Find all interactive elements (links, buttons, inputs, etc.) on the current page. Returns their tag, text, selector, and attributes. Use this to understand what you can interact with.",
-      input_schema: { type: "object", properties: {} }
-    },
-    {
-      name: "browser_evaluate",
-      description: "Execute JavaScript in the browser page context. Use for advanced interactions or data extraction that other tools can't handle.",
-      input_schema: {
-        type: "object",
-        properties: {
-          expression: {
-            type: "string",
-            description: "JavaScript expression to evaluate"
-          }
-        },
-        required: ["expression"]
-      }
-    },
-    {
-      name: "browser_list_tabs",
-      description: "List all open tabs in the user's browser. Shows title, URL, and which tab is currently connected.",
-      input_schema: { type: "object", properties: {} }
-    },
-    {
-      name: "browser_switch_tab",
-      description: "Switch to a different browser tab by index.",
-      input_schema: {
-        type: "object",
-        properties: {
-          index: {
-            type: "number",
-            description: "Tab index (from browser_list_tabs)"
-          }
-        },
-        required: ["index"]
-      }
-    },
-    {
-      name: "browser_new_tab",
-      description: "Open a new tab in the user's browser, optionally navigating to a URL.",
-      input_schema: {
-        type: "object",
-        properties: {
-          url: { type: "string", description: "URL to open (default: blank)" }
-        }
-      }
-    },
-    {
-      name: "browser_request_user_action",
-      description: "Request the user to perform an action in their browser that the AI cannot do. Use this when: (1) a page requires login/authentication, (2) a CAPTCHA needs solving, (3) two-factor auth is needed, (4) any action requiring the user's personal credentials. The user will see a notification on the web UI and in the terminal.",
-      input_schema: {
-        type: "object",
-        properties: {
-          message: {
-            type: "string",
-            description: "Clear description of what the user needs to do. E.g.: 'Please log in to amazon.com in your browser. The login page is currently open in the active tab.'"
-          },
-          wait_seconds: {
-            type: "number",
-            description: "How long to wait for the user to complete the action (default: 60)"
-          }
-        },
-        required: ["message"]
-      }
-    }
-  ];
-}
-async function executeTool(name, input) {
-  const browser = getBrowser();
-  switch (name) {
-    // ── Filesystem ──────────────────────────────────────────
-    case "read_file":
-      return readFileContent(
-        input.path,
-        input.offset,
-        input.limit
-      );
-    case "write_file":
-      return writeFileContent(input.path, input.content);
-    case "search_files":
-      return searchFiles(input.pattern, input.directory);
-    case "search_content":
-      return searchContent(
-        input.pattern,
-        input.file_glob,
-        input.directory
-      );
-    case "list_directory":
-      return listDirectory(input.path);
-    case "execute_command":
-      return executeShell(input.command, input.cwd);
-    // ── Browser (CDP) ───────────────────────────────────────
-    case "browser_connect":
-      return browser.connect(input.tab_index);
-    case "browser_navigate":
-      if (!browser.isConnected()) await browser.connect();
-      return browser.navigate(input.url);
-    case "browser_read_page":
-      return browser.readPage();
-    case "browser_screenshot":
-      return browser.screenshot();
-    case "browser_click":
-      return browser.click(input.selector);
-    case "browser_type":
-      return browser.typeText(input.selector, input.text);
-    case "browser_press_key":
-      return browser.pressKey(input.key);
-    case "browser_scroll":
-      return input.direction === "up" ? browser.scrollUp() : browser.scrollDown();
-    case "browser_get_elements":
-      return browser.getInteractiveElements();
-    case "browser_evaluate":
-      return browser.evaluate(input.expression);
-    case "browser_list_tabs":
-      return browser.listTabs();
-    case "browser_switch_tab":
-      return browser.switchTab(input.index);
-    case "browser_new_tab":
-      return browser.openNewTab(input.url);
-    case "browser_request_user_action": {
-      const message = input.message;
-      const waitSeconds = input.wait_seconds || 60;
-      console.log("\n");
-      console.log("\u2501".repeat(60));
-      console.log("  \u{1F64B} USER ACTION REQUIRED");
-      console.log("\u2501".repeat(60));
-      console.log(`  ${message}`);
-      console.log(`  (Waiting up to ${waitSeconds}s for you to complete this)`);
-      console.log("\u2501".repeat(60));
-      console.log("\n");
-      await new Promise((r) => setTimeout(r, waitSeconds * 1e3));
-      try {
-        const pageInfo = await browser.readPage();
-        return `User action wait completed. Current page state:
-${pageInfo.slice(0, 3e3)}`;
-      } catch {
-        return "User action wait completed. Could not read page state.";
-      }
-    }
-    default:
-      return `Unknown tool: ${name}`;
-  }
-}
-
-// src/agent/memory.ts
-var MemoryManager = class {
-  userId;
-  constructor(userId) {
-    this.userId = userId;
-  }
-  /**
-   * Store a new memory. Called by the agent after completing tasks
-   * to remember important facts about the user.
-   */
-  async remember(content, category = "general", options) {
-    const sb = getSupabase();
-    const expiresAt = options?.expiresInDays ? new Date(
-      Date.now() + options.expiresInDays * 864e5
-    ).toISOString() : null;
-    const { data, error } = await sb.from("agent_memories").insert({
-      user_id: this.userId,
-      category,
-      content,
-      importance: options?.importance ?? 5,
-      tags: options?.tags ?? [],
-      source_message_id: options?.sourceMessageId ?? null,
-      expires_at: expiresAt
-    }).select().single();
-    if (error) throw new Error(`Failed to store memory: ${error.message}`);
-    log.debug(`Memory stored: [${category}] ${content.slice(0, 80)}...`);
-    return data;
-  }
-  /**
-   * Search memories by query text. Uses ILIKE + tag containment.
-   */
-  async search(query2, limit = 10) {
-    const sb = getSupabase();
-    const sanitized = query2.replace(/[%_]/g, "\\$&");
-    const { data, error } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).or(
-      `content.ilike.%${sanitized}%,tags.cs.{${sanitized}}`
-    ).order("importance", { ascending: false }).limit(limit);
-    if (error) {
-      log.warn(`Memory search failed: ${error.message}`);
-      return [];
-    }
-    if (data && data.length > 0) {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      await Promise.all(
-        data.map(
-          (m) => sb.from("agent_memories").update({
-            access_count: m.access_count + 1,
-            last_accessed_at: now
-          }).eq("id", m.id)
-        )
-      );
-    }
-    return data || [];
-  }
-  /**
-   * Get the most important/recent memories to include in context.
-   * Called before each task to build the agent's "working memory".
-   * Automatically filters out expired memories.
-   */
-  async getContext(maxItems = 20) {
-    const sb = getSupabase();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const { data: instructions } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).eq("category", "instruction").or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).limit(5);
-    const { data: preferences } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).eq("category", "preference").or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).limit(5);
-    const { data: general } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).not("category", "in", '("instruction","preference")').or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).order("updated_at", { ascending: false }).limit(maxItems - 10);
-    const all = [
-      ...instructions || [],
-      ...preferences || [],
-      ...general || []
-    ];
-    const seen = /* @__PURE__ */ new Set();
-    return all.filter((m) => {
-      if (seen.has(m.id)) return false;
-      seen.add(m.id);
-      return true;
-    });
+  /**
+   * Get the most important/recent memories to include in context.
+   * Called before each task to build the agent's "working memory".
+   * Automatically filters out expired memories.
+   */
+  async getContext(maxItems = 20) {
+    const sb = getSupabase();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const { data: instructions } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).eq("category", "instruction").or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).limit(5);
+    const { data: preferences } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).eq("category", "preference").or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).limit(5);
+    const { data: general } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).not("category", "in", '("instruction","preference")').or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).order("updated_at", { ascending: false }).limit(maxItems - 10);
+    const all = [
+      ...instructions || [],
+      ...preferences || [],
+      ...general || []
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    return all.filter((m) => {
+      if (seen.has(m.id)) return false;
+      seen.add(m.id);
+      return true;
+    });
   }
   /**
    * Format memories into a string for the system prompt.
@@ -1431,7 +973,7 @@ import {
   unlinkSync,
   rmSync
 } from "fs";
-import { join as join2, basename, dirname } from "path";
+import { join, basename, dirname } from "path";
 import { homedir } from "os";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
@@ -1552,8 +1094,8 @@ function bigrams(tokens) {
   }
   return result;
 }
-var SKILLS_DIR = join2(homedir(), ".config", "assistme", "skills");
-var BUNDLED_SKILLS_DIR = join2(
+var SKILLS_DIR = join(homedir(), ".config", "assistme", "skills");
+var BUNDLED_SKILLS_DIR = join(
   new URL(".", import.meta.url).pathname,
   "..",
   "..",
@@ -1639,11 +1181,11 @@ var SkillManager = class {
     try {
       const entries = readdirSync(dir);
       for (const entry of entries) {
-        const fullPath = join2(dir, entry);
+        const fullPath = join(dir, entry);
         const stat2 = statSync(fullPath);
         if (stat2.isDirectory()) {
-          const skillMd = join2(fullPath, "SKILL.md");
-          const skillMdLower = join2(fullPath, "skill.md");
+          const skillMd = join(fullPath, "SKILL.md");
+          const skillMdLower = join(fullPath, "skill.md");
           const mdPath = existsSync(skillMd) ? skillMd : existsSync(skillMdLower) ? skillMdLower : null;
           if (mdPath) {
             const skill = parseSkillFile(mdPath, source);
@@ -1752,9 +1294,9 @@ var SkillManager = class {
    */
   create(name, description, content) {
     ensureSkillsDir();
-    const skillDir = join2(SKILLS_DIR, name);
+    const skillDir = join(SKILLS_DIR, name);
     mkdirSync(skillDir, { recursive: true });
-    const filePath = join2(skillDir, "SKILL.md");
+    const filePath = join(skillDir, "SKILL.md");
     const fileContent = `---
 name: ${name}
 description: ${description}
@@ -1793,7 +1335,7 @@ ${content}
       gitUrl += ".git";
     }
     const name = basename(gitUrl, ".git");
-    const targetDir = join2(SKILLS_DIR, name);
+    const targetDir = join(SKILLS_DIR, name);
     if (existsSync(targetDir)) {
       throw new Error(`Skill "${name}" already exists. Remove it first.`);
     }
@@ -1809,8 +1351,8 @@ ${content}
         `Failed to clone: ${err instanceof Error ? err.message : err}`
       );
     }
-    const skillMd = join2(targetDir, "SKILL.md");
-    const skillMdLower = join2(targetDir, "skill.md");
+    const skillMd = join(targetDir, "SKILL.md");
+    const skillMdLower = join(targetDir, "skill.md");
     if (!existsSync(skillMd) && !existsSync(skillMdLower)) {
       rmSync(targetDir, { recursive: true, force: true });
       throw new Error(
@@ -1836,9 +1378,9 @@ ${content}
         throw new Error(`HTTP ${dlResp.status}`);
       }
       const buffer = Buffer.from(await dlResp.arrayBuffer());
-      const skillDir = join2(SKILLS_DIR, name);
+      const skillDir = join(SKILLS_DIR, name);
       mkdirSync(skillDir, { recursive: true });
-      const zipPath = join2(skillDir, "_download.zip");
+      const zipPath = join(skillDir, "_download.zip");
       writeFileSync(zipPath, buffer);
       const { exec: execCb } = await import("child_process");
       const { promisify: promisifyUtil } = await import("util");
@@ -1857,12 +1399,12 @@ ${content}
           throw new Error(`Could not fetch SKILL.md`);
         }
         writeFileSync(
-          join2(skillDir, "SKILL.md"),
+          join(skillDir, "SKILL.md"),
           await fileResp.text(),
           "utf-8"
         );
       }
-      const skillMd = join2(skillDir, "SKILL.md");
+      const skillMd = join(skillDir, "SKILL.md");
       if (!existsSync(skillMd)) {
         rmSync(skillDir, { recursive: true, force: true });
         throw new Error("No SKILL.md in downloaded package");
@@ -2256,27 +1798,305 @@ ${taskResult.slice(0, 1500)}
   }
 }
 
-// src/utils/rate-limiter.ts
-var RateLimiter = class {
-  tokens;
-  maxTokens;
-  refillRate;
-  // tokens per second
-  lastRefill;
-  maxWaitMs;
-  constructor(opts) {
-    this.maxTokens = opts.maxTokens;
-    this.refillRate = opts.refillRate;
-    this.tokens = opts.maxTokens;
-    this.lastRefill = Date.now();
-    this.maxWaitMs = opts.maxWaitMs ?? 1e4;
+// src/utils/retry.ts
+async function withRetry(fn, opts = {}) {
+  const {
+    maxRetries = 3,
+    baseDelayMs = 500,
+    maxDelayMs = 1e4,
+    backoffFactor = 2,
+    retryIf,
+    label
+  } = opts;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (retryIf && !retryIf(err)) {
+        throw err;
+      }
+      if (attempt < maxRetries) {
+        const delay = Math.min(
+          baseDelayMs * Math.pow(backoffFactor, attempt),
+          maxDelayMs
+        );
+        if (label) {
+          log.debug(`${label}: attempt ${attempt + 1} failed, retrying in ${delay}ms`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
+      }
+    }
   }
-  refill() {
-    const now = Date.now();
-    const elapsed = (now - this.lastRefill) / 1e3;
-    this.tokens = Math.min(
-      this.maxTokens,
-      this.tokens + elapsed * this.refillRate
+  throw lastError;
+}
+
+// src/agent/mcp-servers.ts
+import {
+  createSdkMcpServer,
+  tool
+} from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod/v4";
+
+// src/tools/filesystem.ts
+import { readFile, writeFile, readdir, stat, mkdir } from "fs/promises";
+import { resolve, relative, join as join2 } from "path";
+import { glob } from "glob";
+function assertWithinWorkspace(filePath) {
+  const config = getConfig();
+  const resolved = resolve(config.workspacePath, filePath);
+  if (!resolved.startsWith(config.workspacePath)) {
+    throw new Error(
+      `Access denied: path "${filePath}" is outside workspace "${config.workspacePath}"`
+    );
+  }
+  return resolved;
+}
+async function readFileContent(path, offset, limit) {
+  const resolved = assertWithinWorkspace(path);
+  const content = await readFile(resolved, "utf-8");
+  const lines = content.split("\n");
+  const start = offset || 0;
+  const end = limit ? start + limit : lines.length;
+  const selected = lines.slice(start, end);
+  return selected.map((line, i) => `${String(start + i + 1).padStart(5)} | ${line}`).join("\n");
+}
+async function writeFileContent(path, content) {
+  const resolved = assertWithinWorkspace(path);
+  const dir = resolve(resolved, "..");
+  await mkdir(dir, { recursive: true });
+  await writeFile(resolved, content, "utf-8");
+  return `File written: ${path} (${content.length} bytes)`;
+}
+async function searchFiles(pattern, directory) {
+  const config = getConfig();
+  const cwd = directory ? assertWithinWorkspace(directory) : config.workspacePath;
+  const matches = await glob(pattern, {
+    cwd,
+    nodir: false,
+    ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**"]
+  });
+  if (matches.length === 0) return "No files found matching the pattern.";
+  return matches.slice(0, 50).map((m) => relative(config.workspacePath, join2(cwd, m))).join("\n");
+}
+async function listDirectory(path) {
+  const config = getConfig();
+  const resolved = path ? assertWithinWorkspace(path) : config.workspacePath;
+  const entries = await readdir(resolved, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".env.example") continue;
+    const icon = entry.isDirectory() ? "\u{1F4C1}" : "\u{1F4C4}";
+    const info = entry.isFile() ? await stat(join2(resolved, entry.name)).then(
+      (s) => ` (${formatSize(s.size)})`
+    ) : "";
+    results.push(`${icon} ${entry.name}${info}`);
+  }
+  return results.join("\n") || "Empty directory.";
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+async function searchContent(pattern, fileGlob, directory) {
+  const config = getConfig();
+  const cwd = directory ? assertWithinWorkspace(directory) : config.workspacePath;
+  const files = await glob(fileGlob || "**/*", {
+    cwd,
+    nodir: true,
+    ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**"]
+  });
+  const regex = new RegExp(pattern, "gi");
+  const results = [];
+  for (const file of files.slice(0, 200)) {
+    try {
+      const content = await readFile(join2(cwd, file), "utf-8");
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          const relPath = relative(config.workspacePath, join2(cwd, file));
+          results.push(`${relPath}:${i + 1}: ${lines[i].trim()}`);
+          regex.lastIndex = 0;
+          if (results.length >= 30) break;
+        }
+      }
+      if (results.length >= 30) break;
+    } catch {
+    }
+  }
+  return results.length > 0 ? results.join("\n") : "No matches found.";
+}
+
+// src/tools/shell.ts
+import { exec } from "child_process";
+var TIMEOUT_MS = 3e4;
+var MAX_OUTPUT = 5e4;
+var BLOCKED_PATTERNS = [
+  /rm\s+(-\w*\s+)*-\w*r\w*\s+\/($|\s)/i,
+  // rm -rf /, rm -fr /, etc.
+  /rm\s+(-\w*\s+)*-\w*r\w*\s+~($|\s|\/)/i,
+  // rm -rf ~, rm -fr ~/, etc.
+  /\bmkfs\b/i,
+  // mkfs (any form)
+  /\bdd\s+.*\bif=/i,
+  // dd if=
+  /:\s*\(\s*\)\s*\{/,
+  // fork bomb :(){}
+  /\bchmod\s+(-\w+\s+)*-R\s+777\s+\//i,
+  // chmod -R 777 /
+  />\s*\/dev\/sd[a-z]/i,
+  // write to raw disk
+  /\bshutdown\b/i,
+  // shutdown
+  /\breboot\b/i,
+  // reboot
+  /\bsystemctl\s+(start|stop|disable|mask)\b/i
+  // dangerous systemctl ops
+];
+function isBlocked(command) {
+  return BLOCKED_PATTERNS.some((pattern) => pattern.test(command));
+}
+async function executeShell(command, cwd) {
+  if (isBlocked(command)) {
+    throw new Error(`Command blocked for safety: "${command}"`);
+  }
+  const config = getConfig();
+  const workDir = cwd || config.workspacePath;
+  return new Promise((resolve2) => {
+    exec(
+      command,
+      {
+        cwd: workDir,
+        timeout: TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+        // 1MB buffer
+        env: { ...process.env, TERM: "dumb" }
+      },
+      (error, stdout, stderr) => {
+        let output = "";
+        if (stdout) {
+          output += stdout;
+        }
+        if (stderr) {
+          output += stderr ? `
+[stderr]
+${stderr}` : "";
+        }
+        if (error && !stdout && !stderr) {
+          output = `Error: ${error.message}`;
+        }
+        if (output.length > MAX_OUTPUT) {
+          output = output.slice(0, MAX_OUTPUT) + `
+
+[Output truncated at ${MAX_OUTPUT} bytes]`;
+        }
+        resolve2(output || "(no output)");
+      }
+    );
+  });
+}
+
+// src/tools/index.ts
+async function executeTool(name, input) {
+  const browser = getBrowser();
+  switch (name) {
+    // ── Filesystem ──────────────────────────────────────────
+    case "read_file":
+      return readFileContent(
+        input.path,
+        input.offset,
+        input.limit
+      );
+    case "write_file":
+      return writeFileContent(input.path, input.content);
+    case "search_files":
+      return searchFiles(input.pattern, input.directory);
+    case "search_content":
+      return searchContent(
+        input.pattern,
+        input.file_glob,
+        input.directory
+      );
+    case "list_directory":
+      return listDirectory(input.path);
+    case "execute_command":
+      return executeShell(input.command, input.cwd);
+    // ── Browser (CDP) ───────────────────────────────────────
+    case "browser_connect":
+      return browser.connect(input.tab_index);
+    case "browser_navigate":
+      if (!browser.isConnected()) await browser.connect();
+      return browser.navigate(input.url);
+    case "browser_read_page":
+      return browser.readPage();
+    case "browser_screenshot":
+      return browser.screenshot();
+    case "browser_click":
+      return browser.click(input.selector);
+    case "browser_type":
+      return browser.typeText(input.selector, input.text);
+    case "browser_press_key":
+      return browser.pressKey(input.key);
+    case "browser_scroll":
+      return input.direction === "up" ? browser.scrollUp() : browser.scrollDown();
+    case "browser_get_elements":
+      return browser.getInteractiveElements();
+    case "browser_evaluate":
+      return browser.evaluate(input.expression);
+    case "browser_list_tabs":
+      return browser.listTabs();
+    case "browser_switch_tab":
+      return browser.switchTab(input.index);
+    case "browser_new_tab":
+      return browser.openNewTab(input.url);
+    case "browser_request_user_action": {
+      const message = input.message;
+      const waitSeconds = input.wait_seconds || 60;
+      console.log("\n");
+      console.log("\u2501".repeat(60));
+      console.log("  \u{1F64B} USER ACTION REQUIRED");
+      console.log("\u2501".repeat(60));
+      console.log(`  ${message}`);
+      console.log(`  (Waiting up to ${waitSeconds}s for you to complete this)`);
+      console.log("\u2501".repeat(60));
+      console.log("\n");
+      await new Promise((r) => setTimeout(r, waitSeconds * 1e3));
+      try {
+        const pageInfo = await browser.readPage();
+        return `User action wait completed. Current page state:
+${pageInfo.slice(0, 3e3)}`;
+      } catch {
+        return "User action wait completed. Could not read page state.";
+      }
+    }
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+
+// src/utils/rate-limiter.ts
+var RateLimiter = class {
+  tokens;
+  maxTokens;
+  refillRate;
+  // tokens per second
+  lastRefill;
+  maxWaitMs;
+  constructor(opts) {
+    this.maxTokens = opts.maxTokens;
+    this.refillRate = opts.refillRate;
+    this.tokens = opts.maxTokens;
+    this.lastRefill = Date.now();
+    this.maxWaitMs = opts.maxWaitMs ?? 1e4;
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = (now - this.lastRefill) / 1e3;
+    this.tokens = Math.min(
+      this.maxTokens,
+      this.tokens + elapsed * this.refillRate
     );
     this.lastRefill = now;
   }
@@ -2331,47 +2151,373 @@ var toolRateLimiters = {
   filesystem: new RateLimiter({ maxTokens: 40, refillRate: 20 })
 };
 function getLimiterForTool(toolName) {
-  if (toolName.startsWith("browser_")) return toolRateLimiters.browser;
-  if (toolName === "execute_command") return toolRateLimiters.shell;
-  if (["read_file", "write_file", "search_files", "search_content", "list_directory"].includes(
-    toolName
-  ))
+  if (toolName.includes("assistme-browser") || toolName.startsWith("browser_"))
+    return toolRateLimiters.browser;
+  if (toolName === "Bash" || toolName === "execute_command")
+    return toolRateLimiters.shell;
+  if ([
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "read_file",
+    "write_file",
+    "search_files",
+    "search_content",
+    "list_directory"
+  ].includes(toolName))
     return toolRateLimiters.filesystem;
   return null;
 }
 
-// src/utils/retry.ts
-async function withRetry(fn, opts = {}) {
-  const {
-    maxRetries = 3,
-    baseDelayMs = 500,
-    maxDelayMs = 1e4,
-    backoffFactor = 2,
-    retryIf,
-    label
-  } = opts;
-  let lastError;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      if (retryIf && !retryIf(err)) {
-        throw err;
-      }
-      if (attempt < maxRetries) {
-        const delay = Math.min(
-          baseDelayMs * Math.pow(backoffFactor, attempt),
-          maxDelayMs
-        );
-        if (label) {
-          log.debug(`${label}: attempt ${attempt + 1} failed, retrying in ${delay}ms`);
+// src/agent/mcp-servers.ts
+async function callTool(name, input) {
+  const limiter = getLimiterForTool(name);
+  if (limiter) await limiter.acquire();
+  const result = await executeTool(name, input);
+  return { content: [{ type: "text", text: result }] };
+}
+var BROWSER_TOOL_NAMES = [
+  "browser_connect",
+  "browser_navigate",
+  "browser_read_page",
+  "browser_screenshot",
+  "browser_click",
+  "browser_type",
+  "browser_press_key",
+  "browser_scroll",
+  "browser_get_elements",
+  "browser_evaluate",
+  "browser_list_tabs",
+  "browser_switch_tab",
+  "browser_new_tab",
+  "browser_request_user_action"
+];
+function createBrowserMcpServer() {
+  return createSdkMcpServer({
+    name: "assistme-browser",
+    version: "1.0.0",
+    tools: [
+      tool(
+        "browser_connect",
+        "Connect to the user's real Chrome browser via CDP. The user must have Chrome running with --remote-debugging-port=9222.",
+        { tab_index: z.number().optional().describe("Tab index (default: 0)") },
+        async (args) => callTool("browser_connect", args)
+      ),
+      tool(
+        "browser_navigate",
+        "Navigate the user's browser to a URL, using the user's real browser with all their cookies and logins.",
+        { url: z.string().describe("URL to navigate to") },
+        async (args) => callTool("browser_navigate", args)
+      ),
+      tool(
+        "browser_read_page",
+        "Read the text content of the currently open page. Returns page title, URL, and main text content.",
+        {},
+        async () => callTool("browser_read_page", {})
+      ),
+      tool(
+        "browser_screenshot",
+        "Take a screenshot of the current browser page. Returns a base64-encoded PNG image.",
+        {},
+        async () => {
+          const limiter = getLimiterForTool("browser_screenshot");
+          if (limiter) await limiter.acquire();
+          const base64 = await executeTool("browser_screenshot", {});
+          if (base64.length > 100) {
+            return {
+              content: [
+                {
+                  type: "image",
+                  data: base64,
+                  mimeType: "image/png"
+                }
+              ]
+            };
+          }
+          return { content: [{ type: "text", text: base64 }] };
         }
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
-      }
+      ),
+      tool(
+        "browser_click",
+        "Click on an element in the user's browser using a CSS selector.",
+        { selector: z.string().describe("CSS selector of the element to click") },
+        async (args) => callTool("browser_click", args)
+      ),
+      tool(
+        "browser_type",
+        "Type text into an input field in the user's browser.",
+        {
+          selector: z.string().describe("CSS selector of the input element"),
+          text: z.string().describe("Text to type")
+        },
+        async (args) => callTool("browser_type", args)
+      ),
+      tool(
+        "browser_press_key",
+        "Press a keyboard key in the browser. Supports: Enter, Tab, Escape, Backspace, ArrowDown, ArrowUp.",
+        { key: z.string().describe("Key to press") },
+        async (args) => callTool("browser_press_key", args)
+      ),
+      tool(
+        "browser_scroll",
+        "Scroll the page up or down.",
+        { direction: z.string().describe("'down' or 'up'") },
+        async (args) => callTool("browser_scroll", args)
+      ),
+      tool(
+        "browser_get_elements",
+        "Find all interactive elements (links, buttons, inputs) on the current page.",
+        {},
+        async () => callTool("browser_get_elements", {})
+      ),
+      tool(
+        "browser_evaluate",
+        "Execute JavaScript in the browser page context.",
+        { expression: z.string().describe("JavaScript expression to evaluate") },
+        async (args) => callTool("browser_evaluate", args)
+      ),
+      tool(
+        "browser_list_tabs",
+        "List all open tabs in the user's browser.",
+        {},
+        async () => callTool("browser_list_tabs", {})
+      ),
+      tool(
+        "browser_switch_tab",
+        "Switch to a different browser tab by index.",
+        { index: z.number().describe("Tab index") },
+        async (args) => callTool("browser_switch_tab", args)
+      ),
+      tool(
+        "browser_new_tab",
+        "Open a new tab in the user's browser, optionally navigating to a URL.",
+        { url: z.string().optional().describe("URL to open (default: blank)") },
+        async (args) => callTool("browser_new_tab", args)
+      ),
+      tool(
+        "browser_request_user_action",
+        "Request the user to perform an action in their browser (login, CAPTCHA, 2FA, etc.).",
+        {
+          message: z.string().describe("Clear description of what the user needs to do"),
+          wait_seconds: z.number().optional().describe("How long to wait (default: 60)")
+        },
+        async (args) => callTool("browser_request_user_action", args)
+      )
+    ]
+  });
+}
+function createAgentToolsServer(deps) {
+  const { memoryManager, skillManager, taskId } = deps;
+  return createSdkMcpServer({
+    name: "assistme-agent",
+    version: "1.0.0",
+    tools: [
+      tool(
+        "memory_store",
+        "Store a memory about the user that persists across conversations. Use when you learn preferences, habits, or standing instructions.",
+        {
+          content: z.string().describe("What to remember (concise, factual statement)"),
+          category: z.string().optional().describe(
+            "Category: general, preference, instruction, context, skill_learned, fact"
+          ),
+          importance: z.number().optional().describe("Importance 1-10 (default: 5). Use 8+ for instructions"),
+          tags: z.array(z.string()).optional().describe("Optional tags for searchability")
+        },
+        async (args) => {
+          if (!memoryManager) {
+            return {
+              content: [
+                { type: "text", text: "Memory manager not available." }
+              ]
+            };
+          }
+          const mem = await memoryManager.remember(
+            args.content,
+            args.category || "general",
+            {
+              importance: args.importance || 5,
+              tags: args.tags || [],
+              sourceMessageId: taskId
+            }
+          );
+          const result = `Memory stored: "${mem.content}" [${mem.category}, importance: ${mem.importance}]`;
+          return { content: [{ type: "text", text: result }] };
+        }
+      ),
+      tool(
+        "skill_create",
+        "Create a new reusable skill from a workflow you just executed. Write generic, reusable instructions with placeholders like {product}, {query}.",
+        {
+          name: z.string().describe("Skill name in kebab-case, e.g. 'flight-booking'"),
+          description: z.string().describe("One-line description of what this skill does"),
+          instructions: z.string().describe("Markdown step-by-step instructions"),
+          emoji: z.string().optional().describe("Single emoji representing this skill")
+        },
+        async (args) => {
+          const existing = skillManager.findSimilar(args.name);
+          if (existing) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `A similar skill "${existing.name}" already exists. Use skill_improve to update it instead.`
+                }
+              ]
+            };
+          }
+          const filePath = skillManager.create(
+            args.name,
+            args.description,
+            args.instructions
+          );
+          if (args.emoji) {
+            const skill = skillManager.get(args.name);
+            if (skill) {
+              skill.metadata.emoji = args.emoji;
+              const { writeFileSync: writeFileSync2 } = await import("fs");
+              const metaJson = JSON.stringify({
+                openclaw: { emoji: args.emoji }
+              });
+              const fileContent = `---
+name: ${args.name}
+description: ${args.description}
+version: 1.0.0
+user-invocable: true
+metadata: ${metaJson}
+---
+
+${args.instructions}
+`;
+              writeFileSync2(filePath, fileContent, "utf-8");
+            }
+          }
+          log.success(`Self-improvement: created skill "${args.name}"`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill "${args.name}" created and saved to ${filePath}. It will be automatically matched to future similar tasks.`
+              }
+            ]
+          };
+        }
+      ),
+      tool(
+        "skill_improve",
+        "Improve an existing skill with better instructions based on what you just learned. Version auto-bumped.",
+        {
+          name: z.string().describe("Name of the existing skill to improve"),
+          improved_instructions: z.string().describe("Full updated markdown instructions (not a diff)"),
+          description: z.string().optional().describe("Updated description (optional)")
+        },
+        async (args) => {
+          const existing = skillManager.get(args.name);
+          if (!existing) {
+            const available = skillManager.getAll().map((s) => s.name).join(", ");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" not found. Available skills: ${available}`
+                }
+              ]
+            };
+          }
+          if (existing.source === "bundled") {
+            skillManager.create(
+              args.name,
+              args.description || existing.description,
+              args.improved_instructions
+            );
+            log.success(
+              `Self-improvement: overrode bundled skill "${args.name}"`
+            );
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Bundled skill "${args.name}" overridden with improved version.`
+                }
+              ]
+            };
+          }
+          const updated = skillManager.update(
+            args.name,
+            args.improved_instructions,
+            args.description
+          );
+          if (updated) {
+            log.success(`Self-improvement: improved skill "${args.name}"`);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" improved and version bumped.`
+                }
+              ]
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Failed to update skill "${args.name}".`
+              }
+            ]
+          };
+        }
+      )
+    ]
+  });
+}
+
+// src/agent/event-hooks.ts
+function stripMcpPrefix(toolName) {
+  const match = toolName.match(/^mcp__[^_]+(?:__)?(.+)$/);
+  return match ? match[1] : toolName;
+}
+function createEventHooks(taskId, toolCallRecords) {
+  const preToolUseHook = async (input) => {
+    if (input.hook_event_name !== "PreToolUse") return { continue: true };
+    const rawName = input.tool_name;
+    const displayName = stripMcpPrefix(rawName);
+    const toolInput = input.tool_input;
+    log.tool(displayName, JSON.stringify(toolInput).slice(0, 200));
+    await emitEvent(taskId, "tool_use_start", { name: displayName });
+    await emitEvent(taskId, "tool_use_input", { input: toolInput });
+    if (displayName === "browser_request_user_action") {
+      await emitEvent(taskId, "status_change", {
+        status: "waiting_for_user",
+        message: toolInput?.message
+      });
     }
-  }
-  throw lastError;
+    return { continue: true };
+  };
+  const postToolUseHook = async (input) => {
+    if (input.hook_event_name !== "PostToolUse") return {};
+    const rawName = input.tool_name;
+    const displayName = stripMcpPrefix(rawName);
+    const toolInput = input.tool_input;
+    const toolResponse = input.tool_response;
+    const resultStr = typeof toolResponse === "string" ? toolResponse : JSON.stringify(toolResponse);
+    log.result(resultStr.slice(0, 200));
+    await emitEvent(taskId, "tool_result", {
+      name: displayName,
+      result: resultStr.slice(0, 1e4)
+    });
+    toolCallRecords.push({
+      name: displayName,
+      input: toolInput || {},
+      result: resultStr.slice(0, 300)
+    });
+    return {};
+  };
+  return {
+    PreToolUse: [{ hooks: [preToolUseHook] }],
+    PostToolUse: [{ hooks: [postToolUseHook] }]
+  };
 }
 
 // src/agent/processor.ts
@@ -2385,21 +2531,23 @@ KEY PRINCIPLE: You operate the user's real browser, not a headless sandbox. This
 
 Available capabilities:
 1. BROWSER CONTROL (user's real Chrome via CDP):
-   - Navigate to any website (user's sessions are preserved)
-   - Read page content, take screenshots
-   - Click buttons, fill forms, scroll, switch tabs
-   - Open new tabs, interact with any web page
-   - If auth is needed: request the user to log in
+   - Use browser tools (browser_connect, browser_navigate, browser_read_page, browser_screenshot, browser_click, browser_type, browser_press_key, browser_scroll, browser_get_elements, browser_evaluate, browser_list_tabs, browser_switch_tab, browser_new_tab) to control the user's real Chrome
+   - If auth is needed: use browser_request_user_action to ask the user to log in
 
-2. FILE OPERATIONS:
-   - Read, write, search files in the workspace
-   - Execute shell commands
+2. FILE OPERATIONS & SHELL:
+   - Read, Write, Edit tools for file operations
+   - Bash tool for shell commands
+   - Glob and Grep for file search
 
 3. MEMORY:
    - You can remember things about the user using memory_store
    - Use this when you learn preferences, important facts, or standing instructions
    - Your stored memories persist across conversations
 
+4. SELF-IMPROVEMENT:
+   - If you discover a reusable workflow pattern, use skill_create to save it for future tasks
+   - If a skill's instructions could be improved based on your experience, use skill_improve
+
 Workflow for web tasks (e.g. "\u67E5\u4E00\u4E0B kindle \u6700\u65B0\u6B3E\u4EF7\u683C"):
 1. browser_connect \u2192 connect to user's Chrome
 2. browser_new_tab \u2192 open a new tab
@@ -2417,14 +2565,6 @@ Guidelines:
 - Be thorough: check multiple sources when comparing prices/products
 - Summarize results clearly at the end
 - When you learn something about the user (preferences, habits), use memory_store to remember it
-- If you discover a reusable workflow pattern, use skill_create to save it for future tasks
-- If a skill's instructions could be improved based on your experience, use skill_improve
-
-4. SELF-IMPROVEMENT:
-   - If you discover a good multi-step workflow during a task, use skill_create to save it as a reusable skill
-   - If you're using a skill but find a better approach, use skill_improve to update it
-   - Skills you create will be automatically matched to future similar tasks
-   - Example: After successfully comparing prices across 5 sites, save the workflow so next time it's even faster
 
 Workspace path: {workspace_path}`;
 var TaskProcessor = class {
@@ -2441,11 +2581,12 @@ var TaskProcessor = class {
     const config = getConfig();
     resetEventSequence();
     const taskTimeoutMs = (config.taskTimeoutMinutes || 10) * 6e4;
-    const correlationId = newCorrelationId();
+    newCorrelationId();
     log.info(`Processing task ${task.id.slice(0, 8)}...`);
     let finalResponse = "";
     const toolCallRecords = [];
     const usedSkillNames = [];
+    let tokenUsage;
     try {
       await emitEvent(task.id, "status_change", { status: "running" });
       let systemPrompt = BASE_SYSTEM_PROMPT.replace(
@@ -2470,271 +2611,148 @@ var TaskProcessor = class {
       for (const s of matchedSkills) {
         usedSkillNames.push(s.name);
       }
-      const toolDefs = [
-        ...getToolDefinitions(),
-        {
-          name: "memory_store",
-          description: "Store a memory about the user that persists across conversations. Use this when you learn something important about the user \u2014 their preferences, habits, work context, or standing instructions. Categories: general, preference, instruction, context, skill_learned, fact.",
-          input_schema: {
-            type: "object",
-            properties: {
-              content: {
-                type: "string",
-                description: "What to remember (concise, factual statement)"
-              },
-              category: {
-                type: "string",
-                description: "Category: general, preference, instruction, context, skill_learned, fact"
-              },
-              importance: {
-                type: "number",
-                description: "Importance 1-10 (default: 5). Use 8+ for instructions, 7 for preferences"
-              },
-              tags: {
-                type: "array",
-                items: { type: "string" },
-                description: "Optional tags for searchability"
-              }
-            },
-            required: ["content"]
-          }
-        },
-        {
-          name: "skill_create",
-          description: "Create a new reusable skill from a workflow you just executed. Use this when you discover a good multi-step approach that would be useful for future similar tasks. The skill will be saved as a SKILL.md file and automatically matched to future tasks. Write generic, reusable instructions with placeholders like {product}, {query}, {website}.",
-          input_schema: {
-            type: "object",
-            properties: {
-              name: {
-                type: "string",
-                description: "Skill name in kebab-case, e.g. 'flight-booking' or 'competitor-analysis'"
-              },
-              description: {
-                type: "string",
-                description: "One-line description of what this skill does"
-              },
-              instructions: {
-                type: "string",
-                description: "Markdown step-by-step instructions. Use ## headings, numbered steps, and **bold** for key actions. Replace specific values with {placeholders}."
-              },
-              emoji: {
-                type: "string",
-                description: "Single emoji that represents this skill"
-              }
-            },
-            required: ["name", "description", "instructions"]
-          }
-        },
-        {
-          name: "skill_improve",
-          description: "Improve an existing skill with better instructions based on what you just learned during this task. Use this when you followed a skill's workflow but found a better approach. The skill version will be auto-bumped.",
-          input_schema: {
-            type: "object",
-            properties: {
-              name: {
-                type: "string",
-                description: "Name of the existing skill to improve"
-              },
-              improved_instructions: {
-                type: "string",
-                description: "The full updated markdown instructions (not a diff, the complete new version)"
-              },
-              description: {
-                type: "string",
-                description: "Updated description (optional, keeps existing if not provided)"
-              }
-            },
-            required: ["name", "improved_instructions"]
-          }
-        }
+      const browserServer = createBrowserMcpServer();
+      const agentToolsServer = createAgentToolsServer({
+        memoryManager: this.memoryManager,
+        skillManager: this.skillManager,
+        taskId: task.id
+      });
+      const eventHooks = createEventHooks(task.id, toolCallRecords);
+      const allowedTools = [
+        // SDK built-in tools
+        "Read",
+        "Write",
+        "Edit",
+        "Bash",
+        "Glob",
+        "Grep",
+        // Browser MCP tools
+        ...BROWSER_TOOL_NAMES.map(
+          (n) => `mcp__assistme-browser__${n}`
+        ),
+        // Agent MCP tools (memory, skills)
+        "mcp__assistme-agent__memory_store",
+        "mcp__assistme-agent__skill_create",
+        "mcp__assistme-agent__skill_improve"
       ];
+      async function* promptMessages() {
+        yield {
+          type: "user",
+          message: {
+            role: "user",
+            content: task.prompt
+          },
+          parent_tool_use_id: null,
+          session_id: ""
+        };
+      }
+      const abortController = new AbortController();
       const options = {
         model: config.model,
         systemPrompt,
-        allowedTools: [
-          // File system tools
-          "read_file",
-          "write_file",
-          "search_files",
-          "search_content",
-          "list_directory",
-          "execute_command",
-          // Browser tools
-          "browser_connect",
-          "browser_navigate",
-          "browser_read_page",
-          "browser_screenshot",
-          "browser_click",
-          "browser_type",
-          "browser_press_key",
-          "browser_scroll",
-          "browser_get_elements",
-          "browser_evaluate",
-          "browser_list_tabs",
-          "browser_switch_tab",
-          "browser_new_tab",
-          "browser_request_user_action",
-          // Memory
-          "memory_store",
-          // Self-improvement
-          "skill_create",
-          "skill_improve"
-        ],
-        tools: toolDefs,
         cwd: config.workspacePath,
-        maxTurns: config.maxTurns
+        maxTurns: config.maxTurns,
+        allowedTools,
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        mcpServers: {
+          "assistme-browser": browserServer,
+          "assistme-agent": agentToolsServer
+        },
+        hooks: eventHooks,
+        persistSession: false,
+        abortController
       };
       const taskStartTime = Date.now();
-      for await (const message of query({
-        prompt: task.prompt,
-        options,
-        // Custom tool executor - the SDK calls this for our tools
-        onToolCall: async (toolName, toolInput) => {
+      const timeoutId = setTimeout(() => {
+        abortController.abort();
+      }, taskTimeoutMs);
+      try {
+        for await (const message of query({
+          prompt: promptMessages(),
+          options
+        })) {
           if (Date.now() - taskStartTime > taskTimeoutMs) {
-            throw new Error(
-              `Task timed out after ${Math.round(taskTimeoutMs / 6e4)} minutes`
-            );
+            finalResponse += "\n\n[Task timed out]";
+            break;
           }
-          log.tool(toolName, JSON.stringify(toolInput).slice(0, 200));
-          await emitEvent(task.id, "tool_use_start", { name: toolName });
-          await emitEvent(task.id, "tool_use_input", { input: toolInput });
-          let result;
-          try {
-            const limiter = getLimiterForTool(toolName);
-            if (limiter) {
-              await limiter.acquire();
-            }
-            if (toolName === "skill_create") {
-              const name = toolInput.name;
-              const description = toolInput.description;
-              const instructions = toolInput.instructions;
-              const emoji = toolInput.emoji || "";
-              const existing = this.skillManager.findSimilar(name);
-              if (existing) {
-                result = `A similar skill "${existing.name}" already exists. Use skill_improve to update it instead.`;
-              } else {
-                const content = emoji ? instructions : instructions;
-                const filePath = this.skillManager.create(name, description, content);
-                if (emoji) {
-                  const skill = this.skillManager.get(name);
-                  if (skill) {
-                    skill.metadata.emoji = emoji;
-                    const { writeFile: writeFile2 } = await import("fs/promises");
-                    const metaJson = JSON.stringify({ openclaw: { emoji } });
-                    const fileContent = `---
-name: ${name}
-description: ${description}
-version: 1.0.0
-user-invocable: true
-metadata: ${metaJson}
----
-
-${instructions}
-`;
-                    await writeFile2(filePath, fileContent, "utf-8");
-                  }
+          switch (message.type) {
+            case "assistant": {
+              const assistantMsg = message;
+              for (const block of assistantMsg.message.content) {
+                if (block.type === "text") {
+                  finalResponse += block.text;
+                  log.agent(block.text);
+                  await emitEvent(task.id, "text_delta", {
+                    text: block.text
+                  });
+                } else if (block.type === "thinking" && "thinking" in block) {
+                  const thinkingText = block.thinking;
+                  log.debug(
+                    `Thinking: ${thinkingText.slice(0, 100)}...`
+                  );
+                  await emitEvent(task.id, "thinking", {
+                    text: thinkingText
+                  });
                 }
-                result = `Skill "${name}" created and saved to ${filePath}. It will be automatically matched to future similar tasks.`;
-                log.success(`Self-improvement: created skill "${name}"`);
               }
-            } else if (toolName === "skill_improve") {
-              const name = toolInput.name;
-              const improvedInstructions = toolInput.improved_instructions;
-              const description = toolInput.description;
-              const existing = this.skillManager.get(name);
-              if (!existing) {
-                result = `Skill "${name}" not found. Available skills: ${this.skillManager.getAll().map((s) => s.name).join(", ")}`;
-              } else if (existing.source === "bundled") {
-                const overrideName = name;
-                this.skillManager.create(overrideName, description || existing.description, improvedInstructions);
-                result = `Bundled skill "${name}" overridden with improved version (user copy created).`;
-                log.success(`Self-improvement: overrode bundled skill "${name}"`);
+              break;
+            }
+            case "result": {
+              const resultMsg = message;
+              tokenUsage = {
+                input_tokens: resultMsg.usage.input_tokens,
+                output_tokens: resultMsg.usage.output_tokens
+              };
+              if (resultMsg.subtype === "success") {
+                const successMsg = resultMsg;
+                if (!finalResponse && successMsg.result) {
+                  finalResponse = successMsg.result;
+                }
+                log.info(
+                  `Task cost: $${successMsg.total_cost_usd.toFixed(4)}, turns: ${successMsg.num_turns}`
+                );
               } else {
-                const updated = this.skillManager.update(name, improvedInstructions, description);
-                if (updated) {
-                  result = `Skill "${name}" improved and version bumped. Changes will apply to future tasks.`;
-                  log.success(`Self-improvement: improved skill "${name}"`);
-                } else {
-                  result = `Failed to update skill "${name}".`;
+                const errorMsg = resultMsg;
+                log.warn(`SDK result: ${errorMsg.subtype}`);
+                for (const err of errorMsg.errors) {
+                  await emitEvent(task.id, "error", { message: err });
                 }
               }
-            } else if (toolName === "memory_store" && this.memoryManager) {
-              const mem = await this.memoryManager.remember(
-                toolInput.content,
-                toolInput.category || "general",
-                {
-                  importance: toolInput.importance || 5,
-                  tags: toolInput.tags || [],
-                  sourceMessageId: task.id
-                }
-              );
-              result = `Memory stored: "${mem.content}" [${mem.category}, importance: ${mem.importance}]`;
-            } else {
-              result = await executeTool(toolName, toolInput);
+              break;
             }
-            log.result(result.slice(0, 200));
-          } catch (err) {
-            result = `Error: ${err instanceof Error ? err.message : String(err)}`;
-            log.error(`Tool error: ${result}`);
+            default:
+              log.debug(`SDK message type: ${message.type}`);
+              break;
           }
-          toolCallRecords.push({
-            name: toolName,
-            input: toolInput,
-            result: result.slice(0, 300)
-          });
-          await emitEvent(task.id, "tool_result", {
-            name: toolName,
-            result: result.slice(0, 1e4)
-          });
-          if (toolName === "browser_request_user_action") {
-            await emitEvent(task.id, "status_change", {
-              status: "waiting_for_user",
-              message: toolInput.message
-            });
-          }
-          if (toolName === "browser_screenshot" && result.length > 100) {
-            return {
-              type: "image",
-              data: result,
-              mediaType: "image/png"
-            };
-          }
-          return result;
-        }
-      })) {
-        if (Date.now() - taskStartTime > taskTimeoutMs) {
-          log.warn("Task timed out \u2014 stopping agentic loop");
-          finalResponse += "\n\n[Task timed out]";
-          break;
-        }
-        if (isTextContent(message)) {
-          finalResponse += message.text;
-          log.agent(message.text);
-          await emitEvent(task.id, "text_delta", { text: message.text });
-        } else if (isThinkingContent(message)) {
-          log.debug(`Thinking: ${message.thinking.slice(0, 100)}...`);
-          await emitEvent(task.id, "thinking", { text: message.thinking });
         }
+      } finally {
+        clearTimeout(timeoutId);
       }
-      await withRetry(() => completeTask(task.id, finalResponse), {
-        maxRetries: 2,
-        baseDelayMs: 300,
-        label: "completeTask"
-      });
+      await withRetry(
+        () => completeTask(task.id, finalResponse, tokenUsage),
+        {
+          maxRetries: 2,
+          baseDelayMs: 300,
+          label: "completeTask"
+        }
+      );
       await emitEvent(task.id, "status_change", { status: "completed" });
       log.success("Task completed.");
       if (this.memoryManager && finalResponse) {
         const mm = this.memoryManager;
-        const taskId = task.id;
+        const taskIdRef = task.id;
         extractMemoriesWithLLM(task.prompt, finalResponse).then(async (memories) => {
           for (const mem of memories) {
             try {
               await mm.remember(mem.content, mem.category, {
                 importance: mem.importance,
                 tags: mem.tags,
-                sourceMessageId: taskId
+                sourceMessageId: taskIdRef
               });
-              log.info(`Memory extracted: [${mem.category}] ${mem.content.slice(0, 60)}...`);
+              log.info(
+                `Memory extracted: [${mem.category}] ${mem.content.slice(0, 60)}...`
+              );
             } catch {
             }
           }
@@ -2758,7 +2776,6 @@ ${instructions}
             );
             return;
           }
-          const metaJson = extracted.emoji ? JSON.stringify({ openclaw: { emoji: extracted.emoji } }) : "";
           const filePath = sm.create(
             extracted.name,
             extracted.description,
@@ -2766,12 +2783,15 @@ ${instructions}
           );
           if (extracted.emoji) {
             const { writeFile: writeFile2 } = await import("fs/promises");
+            const metaJson = JSON.stringify({
+              openclaw: { emoji: extracted.emoji }
+            });
             const fileContent = `---
 name: ${extracted.name}
 description: ${extracted.description}
 version: 1.0.0
-user-invocable: true${metaJson ? `
-metadata: ${metaJson}` : ""}
+user-invocable: true
+metadata: ${metaJson}
 ---
 
 ${extracted.steps}
@@ -2794,7 +2814,11 @@ ${extracted.steps}
           ).then(async (improvement) => {
             if (!improvement) return;
             if (skill.source === "bundled") {
-              sm.create(skillName, skill.description, improvement.improved_steps);
+              sm.create(
+                skillName,
+                skill.description,
+                improvement.improved_steps
+              );
             } else {
               sm.update(skillName, improvement.improved_steps);
             }
@@ -2823,12 +2847,6 @@ ${extracted.steps}
     }
   }
 };
-function isTextContent(msg) {
-  return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "text" && "text" in msg;
-}
-function isThinkingContent(msg) {
-  return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "thinking" && "thinking" in msg;
-}
 
 // src/index.ts
 import { createInterface } from "readline";
@@ -3080,18 +3098,7 @@ program.command("start", { isDefault: true }).description("Start the agent and l
       }
       log.agent(`Processing: "${input}"`);
       try {
-        const { createTask: createTask2 } = await import("./supabase-QU7MFNDI.js");
-        const session = sessionManager.getSession();
-        const conversationId = sessionManager.getConversationId();
-        if (session && conversationId) {
-          const task = await createTask2(
-            conversationId,
-            userId,
-            session.id,
-            input
-          );
-          await processor.processTask(task);
-        }
+        await sessionManager.submitTask(input);
       } catch (err) {
         log.error(`${err instanceof Error ? err.message : err}`);
       }