@todoforai/edge 0.13.13 → 0.13.15

package/dist/index.js

@@ -47695,7 +47695,7 @@ var require_ignore = __commonJS((exports, module) => {
       makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
       return this._added;
     }
-    test(path7, checkUnignored, mode) {
+    test(path8, checkUnignored, mode) {
       let ignored = false;
       let unignored = false;
       let matchedRule;
@@ -47704,7 +47704,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule[mode].test(path7);
+        const matched = rule[mode].test(path8);
         if (!matched) {
           return;
         }
@@ -47725,20 +47725,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path7, originalPath, doThrow) => {
-    if (!isString(path7)) {
+  var checkPath = (path8, originalPath, doThrow) => {
+    if (!isString(path8)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path7) {
+    if (!path8) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path7)) {
+    if (checkPath.isNotRelative(path8)) {
       const r = "`path.relative()`d";
       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+  var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p10) => p10;
 
@@ -47767,15 +47767,15 @@ var require_ignore = __commonJS((exports, module) => {
       return this.add(pattern);
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path7 = originalPath && checkPath.convert(originalPath);
-      checkPath(path7, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
-      return this._t(path7, cache, checkUnignored, slices);
+      const path8 = originalPath && checkPath.convert(originalPath);
+      checkPath(path8, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path8, cache, checkUnignored, slices);
     }
-    checkIgnore(path7) {
-      if (!REGEX_TEST_TRAILING_SLASH.test(path7)) {
-        return this.test(path7);
+    checkIgnore(path8) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path8)) {
+        return this.test(path8);
       }
-      const slices = path7.split(SLASH).filter(Boolean);
+      const slices = path8.split(SLASH).filter(Boolean);
       slices.pop();
       if (slices.length) {
         const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
@@ -47783,42 +47783,42 @@ var require_ignore = __commonJS((exports, module) => {
           return parent;
         }
       }
-      return this._rules.test(path7, false, MODE_CHECK_IGNORE);
+      return this._rules.test(path8, false, MODE_CHECK_IGNORE);
     }
-    _t(path7, cache, checkUnignored, slices) {
-      if (path7 in cache) {
-        return cache[path7];
+    _t(path8, cache, checkUnignored, slices) {
+      if (path8 in cache) {
+        return cache[path8];
       }
       if (!slices) {
-        slices = path7.split(SLASH).filter(Boolean);
+        slices = path8.split(SLASH).filter(Boolean);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path7] = this._rules.test(path7, checkUnignored, MODE_IGNORE);
+        return cache[path8] = this._rules.test(path8, checkUnignored, MODE_IGNORE);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path7] = parent.ignored ? parent : this._rules.test(path7, checkUnignored, MODE_IGNORE);
+      return cache[path8] = parent.ignored ? parent : this._rules.test(path8, checkUnignored, MODE_IGNORE);
     }
-    ignores(path7) {
-      return this._test(path7, this._ignoreCache, false).ignored;
+    ignores(path8) {
+      return this._test(path8, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path7) => !this.ignores(path7);
+      return (path8) => !this.ignores(path8);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path7) {
-      return this._test(path7, this._testCache, true);
+    test(path8) {
+      return this._test(path8, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore(options);
-  var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+  var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
   var setupWindows = () => {
     const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
     checkPath.convert = makePosix;
     const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-    checkPath.isNotRelative = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+    checkPath.isNotRelative = (path8) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
   };
   if (typeof process !== "undefined" && process.platform === "win32") {
     setupWindows();
@@ -48645,9 +48645,9 @@ class BrowserExtensionBridge {
 }
 
 // src/handlers.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import { mkdir, rm as rm2, writeFile } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 
 // src/path-utils.ts
 import path2 from "path";
@@ -48790,7 +48790,6 @@ var tool_catalog_default = {
     pkg: "tiktok-uploader",
     installer: "pip",
     label: "TikTok",
-    statusCmd: "python3 -c 'import tiktok_uploader' 2>&1",
     loginCmd: "npx @todoforai/tiktok-cookie-helper",
     credentialPaths: [
       "~/.tiktok/cookies.txt"
@@ -48806,7 +48805,6 @@ var tool_catalog_default = {
     label: "Instagram",
     capabilities: "Upload photos & reels, post stories, send DMs, like & comment, manage followers",
     description: 'Use for Instagram automation: upload photos/reels, post stories, DMs, like/comment, follower management. Python library; call via `python3 -c "from instagrapi import Client; ..."`.',
-    statusCmd: 'python3 -c "import instagrapi" 2>/dev/null',
     versionCmd: "pip show instagrapi 2>/dev/null | grep -oP 'Version: \\K.*'"
   },
   mudslide: {
@@ -48828,7 +48826,6 @@ var tool_catalog_default = {
     pkg: "telegram-send",
     installer: "pip",
     label: "Telegram",
-    statusCmd: "test -f ~/.config/telegram-send/telegram-send.conf && echo 'configured'",
     loginCmd: "telegram-send --configure",
     credentialPaths: [
       "~/.config/telegram-send/telegram-send.conf"
@@ -49052,7 +49049,6 @@ var tool_catalog_default = {
     pkg: "@shopify/cli",
     installer: "npm",
     label: "Shopify",
-    statusCmd: "test -f ~/.config/shopify/config.json && echo 'authenticated'",
     loginCmd: "shopify auth login",
     credentialPaths: [
       "~/.config/shopify/config.json"
@@ -49091,7 +49087,6 @@ var tool_catalog_default = {
     label: "TODOforAI",
     capabilities: "Create & manage TODOs, run workflows, API access",
     description: "Use to programmatically create/list/update TODOs in TODOforAI, kick off workflows, call the platform API.",
-    statusCmd: "todoai whoami >/dev/null 2>&1",
     installCmd: "bun add -g @todoforai/cli",
     versionCmd: "todoai --version 2>/dev/null | head -1",
     internal: true
@@ -49153,7 +49148,7 @@ var tool_catalog_default = {
       "~/.config/rclone/rclone.conf"
     ],
     capabilities: "Access Google Drive, OneDrive, Dropbox, S3 and 40+ cloud providers. List, copy, sync, move, mount files as virtual filesystem (FUSE). Use 'rclone config create <name> <provider>' to connect (opens browser for OAuth).",
-    description: "Use to access cloud storage (Drive/OneDrive/Dropbox/S3/40+). Connect: `rclone config create <name> <provider>` (OAuth via browser). Core ops: `rclone listremotes`, `rclone ls <remote>:<path>`, `rclone copy|sync <src> <dst>`. Mount as FUSE (lazy fetch): `rclone mount <remote>: ~/.todoforai/mnt/<remote> --vfs-cache-mode full --daemon`; unmount with `fusermount -u <path>`. See `subProviders` for per-provider connect commands.",
+    description: "Use to access cloud storage (Drive/OneDrive/Dropbox/S3/40+). Connect: `rclone config create <name> <provider>` (OAuth via browser). Core ops: `rclone listremotes`, `rclone lsf <remote>:<path>`, `rclone cat <remote>:<file>`, `rclone copy|sync <src> <dst>`. Mount as FUSE (lazy fetch): `rclone mount <remote>: ~/.todoforai/mnt/<remote> --vfs-cache-mode full --daemon`; unmount with `fusermount -u <path>`. Note: FUSE `mount` needs /dev/fuse + CAP_SYS_ADMIN — works on VM sandboxes and bridge devices, but NOT in lite sandboxes; there use `lsf`/`cat`/`copy`/`sync` (HTTPS-only) instead. See `subProviders` for per-provider connect commands.",
     subProviders: {
       gdrive: {
         label: "Google Drive",
@@ -49199,7 +49194,7 @@ var tool_catalog_default = {
     installer: "pip",
     label: "PDF",
     capabilities: "PDF text editing, extraction, merge, split",
-    description: "Use to programmatically read/edit/merge/split PDFs (text + positions). Call from `python3 -c`. Extract text: `pymupdf.open(p)[i].get_text()`; with bbox/font: `.get_text('dict')`. Replace text in place: `page.add_redact_annot(page.search_for('old')[0], text='new'); page.apply_redactions(); doc.save(out)`. For PDF → markdown prefer `firecrawl parse`.",
+    description: "Use to programmatically read/edit/merge/split PDFs (text + positions). Call from `python3 -c`. Extract text: `pymupdf.open(p)[i].get_text()`; with bbox/font: `.get_text('dict')`. Replace text in place: `page.add_redact_annot(page.search_for('old')[0], text='new'); page.apply_redactions(); doc.save(out)`.",
     versionCmd: "python3 -c 'import pymupdf; print(pymupdf.__version__)' 2>/dev/null",
     preinstallCloud: true
   },
@@ -49210,23 +49205,9 @@ var tool_catalog_default = {
     preinstallCloud: true,
     label: "Browser",
     capabilities: "Headless browser automation, web scraping, accessibility tree snapshots, screenshots, PDF generation",
-    description: "Headless browser for JS-rendered pages, automated flows, screenshots, PDF export. **Default browser choice** — use this unless the user's own session/cookies are required (then use `todoforai-browser`). Prefer `curl` for plain HTTP, `firecrawl` for bulk scrape/crawl. Commands: open <url>, click/type/fill <selector> <text>, snapshot (accessibility tree with @refs — use these for clicking), screenshot [path], pdf <path>, eval <js>, wait <selector|ms>.",
+    description: "Headless browser for JS-rendered pages, automated flows, screenshots, PDF export. **Default browser choice** — use this unless the user's own session/cookies are required (then use `todoforai-browser`). Prefer `curl` for plain HTTP. Commands: open <url>, click/type/fill <selector> <text>, snapshot (accessibility tree with @refs — use these for clicking), screenshot [path], pdf <path>, eval <js>, wait <selector|ms>.",
     versionCmd: "agent-browser --version 2>/dev/null | head -1"
   },
-  firecrawl: {
-    category: "development",
-    pkg: "firecrawl-cli",
-    installer: "npm",
-    label: "Firecrawl",
-    statusCmd: "firecrawl view-config 2>&1 | grep -q 'Authenticated' && echo authenticated",
-    loginCmd: "firecrawl login",
-    credentialPaths: [
-      "~/.config/firecrawl-cli"
-    ],
-    capabilities: "Web scraping, crawling, search, map URLs, parse local HTML/PDF/DOCX to markdown, AI agent extraction",
-    description: "Use for web → markdown at scale: single pages (`firecrawl scrape <url>`), whole sites (`firecrawl crawl <url>`), URL discovery (`firecrawl map <url>`), web search (`firecrawl search <query>`), local doc conversion (`firecrawl parse <file.pdf|docx|html|xlsx>`), AI-guided extraction (`firecrawl agent <prompt>`). Prefer over `curl` when you want markdown not HTML. Auth: `firecrawl login` or FIRECRAWL_API_KEY.",
-    versionCmd: "firecrawl --version 2>/dev/null | head -1"
-  },
   "todoforai-browser": {
     category: "development",
     pkg: "@todoforai/browser",
@@ -49267,7 +49248,6 @@ var tool_catalog_default = {
     capabilities: "Explore a codebase as a real TODO: read-only agent maps structure, surfaces relevant files, streams findings to terminal",
     description: 'Codebase exploration as a real TODO with patched permissions (read/grep/bash only) and live streaming. Usage: `tfa-explore [--repo <path>] "<question>"`. Creates a TODO visible in the UI and streams block events to stdout until DONE.',
     versionCmd: "tfa-explore --version 2>/dev/null | head -1",
-    statusCmd: "tfa-explore whoami",
     installCmd: "bun add -g @todoforai/tfa-explore",
     preinstall: true,
     preinstallCloud: true,
@@ -49281,7 +49261,6 @@ var tool_catalog_default = {
     capabilities: "Review a git diff as a real TODO: read-only agent assesses goal, finds issues, suggests simpler approaches",
     description: 'Capture `git diff` and ask a read-only sub-agent to review it as a real TODO. Usage: `tfa-review [--repo <path>] [--against <ref>] "<goal>"`. Default diffs uncommitted changes vs HEAD. Streams block events to stdout until DONE.',
     versionCmd: "tfa-review --version 2>/dev/null | head -1",
-    statusCmd: "tfa-review whoami",
     installCmd: "bun add -g @todoforai/tfa-review",
     preinstall: true,
     preinstallCloud: true,
@@ -49295,7 +49274,6 @@ var tool_catalog_default = {
     capabilities: "Summarize files or piped input as a real TODO with no-tools sub-agent",
     description: 'Summarize file contents or stdin as a real TODO. Usage: `tfa-summary [-f <file>]... [<files...>] [<focus>]` or `cat x | tfa-summary "focus"`. No tools (content is inlined); streams block events to stdout until DONE.',
     versionCmd: "tfa-summary --version 2>/dev/null | head -1",
-    statusCmd: "tfa-summary whoami",
     installCmd: "bun add -g @todoforai/tfa-summary",
     internal: true
   },
@@ -51390,12 +51368,7 @@ import { spawn as nodeSpawn } from "child_process";
 // src/shell-pause-detector.ts
 import os5 from "os";
 import { readFile, readlink } from "fs/promises";
-
-class NullDetector {
-  watch() {
-    return { cancel: () => {}, reset: () => {} };
-  }
-}
+var ECHO = 8;
 var READ_SYSCALL_NR = {
   x64: 0,
   arm64: 63,
@@ -51405,23 +51378,29 @@ var READ_SYSCALL_NR = {
 var READ_NR = READ_SYSCALL_NR[process.arch] ?? -1;
 var POLL_MS = 250;
 var GRACE_TICKS = 2;
+var IS_LINUX2 = os5.platform() === "linux" && READ_NR >= 0;
 
-class LinuxSyscallDetector {
-  watch(pid, onPaused) {
+class PtyPauseDetector {
+  watch(pid, onPaused, terminal) {
     let pausedTicks = 0;
     let signalled = false;
     let cancelled = false;
     let rootStdin = null;
-    readFdTarget(pid, 0).then((t) => {
-      rootStdin = t;
-    });
+    if (IS_LINUX2)
+      readFdTarget(pid, 0).then((t) => {
+        rootStdin = t;
+      });
     const tick = async () => {
       if (cancelled)
         return;
-      const fgPid = await getForegroundPid(pid);
-      const sc2 = fgPid != null ? await readSyscall(fgPid) : null;
-      const leafTarget = sc2 && sc2.nr === READ_NR && sc2.fd >= 0 && fgPid != null ? await readFdTarget(fgPid, sc2.fd) : null;
-      if (isTerminalReadPause(sc2, leafTarget, rootStdin)) {
+      let blocked = terminal != null && !(terminal.localFlags & ECHO);
+      if (!blocked && IS_LINUX2) {
+        const fgPid = await getForegroundPid(pid);
+        const sc2 = fgPid != null ? await readSyscall(fgPid) : null;
+        const leafTarget = sc2 && sc2.nr === READ_NR && sc2.fd >= 0 && fgPid != null ? await readFdTarget(fgPid, sc2.fd) : null;
+        blocked = isTerminalReadPause(sc2, leafTarget, rootStdin);
+      }
+      if (blocked) {
         if (!signalled && ++pausedTicks >= GRACE_TICKS) {
           signalled = true;
           onPaused();
@@ -51492,7 +51471,7 @@ async function readFdTarget(pid, fd3) {
     return null;
   }
 }
-var pauseDetector = os5.platform() === "linux" && READ_NR >= 0 ? new LinuxSyscallDetector : new NullDetector;
+var pauseDetector = new PtyPauseDetector;
 
 // src/shell.ts
 var IS_WIN = os6.platform() === "win32";
@@ -51652,13 +51631,13 @@ async function executeBlock(blockId, content, send, todoId, messageId, timeout,
       }
     }, timeout * 1000);
     let cancelPauseWatch = null;
-    const startPauseWatch = (pid) => {
+    const startPauseWatch = (pid, terminal) => {
       if (!keepAliveOnTimeout)
         return;
       const watcher = pauseDetector.watch(pid, () => {
         if (processes.has(blockId))
           resolveAlive();
-      });
+      }, terminal);
       cancelPauseWatch = watcher.cancel;
       const h = processes.get(blockId);
       if (h)
@@ -51708,7 +51687,7 @@ async function executeBlock(blockId, content, send, todoId, messageId, timeout,
       const handle = { terminal, proc, pid: proc.pid };
       processes.set(blockId, handle);
       const timer = startTimeout();
-      startPauseWatch(proc.pid);
+      startPauseWatch(proc.pid, terminal);
       proc.exited.then((code) => {
         terminal.close();
         onExit(code ?? -1, timer);
@@ -51889,9 +51868,9 @@ function consumeExitedOutput(pid) {
 }
 
 // src/functions.ts
-import fs10 from "fs";
-import path7 from "path";
-import os8 from "os";
+import fs11 from "fs";
+import path8 from "path";
+import os9 from "os";
 
 // src/skills.ts
 import fs9 from "fs";
@@ -52068,6 +52047,62 @@ function sanitize(s) {
   return s.split(/\s+/).filter(Boolean).join(" ");
 }
 
+// src/agent-md.ts
+import fs10 from "fs";
+import path7 from "path";
+import os8 from "os";
+var MAX_BYTES = 64 * 1024;
+var FILENAMES = ["AGENT.md", "AGENTS.md"];
+async function discoverAgentMd(rootPaths, opts = {}) {
+  const includeUserScope = opts.includeUserScope ?? true;
+  const maxBytes = opts.maxBytes ?? MAX_BYTES;
+  const dirs = [
+    ...rootPaths.map((p10) => ({ dir: p10, scope: "repo" }))
+  ];
+  if (includeUserScope) {
+    dirs.push({ dir: path7.join(os8.homedir(), ".agents"), scope: "user" });
+  }
+  const files = [];
+  const errors = [];
+  const seen = new Set;
+  for (const { dir, scope } of dirs) {
+    for (const name of FILENAMES) {
+      const full = path7.join(dir, name);
+      if (seen.has(full))
+        continue;
+      let stat;
+      try {
+        stat = fs10.statSync(full);
+      } catch {
+        continue;
+      }
+      if (!stat.isFile())
+        continue;
+      seen.add(full);
+      try {
+        const fd3 = fs10.openSync(full, "r");
+        const buf = Buffer.alloc(maxBytes);
+        let bytes;
+        try {
+          bytes = fs10.readSync(fd3, buf, 0, maxBytes, 0);
+        } finally {
+          fs10.closeSync(fd3);
+        }
+        files.push({
+          path: full,
+          scope,
+          content: buf.subarray(0, bytes).toString("utf-8"),
+          bytes: stat.size,
+          truncated: stat.size > maxBytes
+        });
+      } catch (e) {
+        errors.push({ path: full, message: `read failed: ${e?.message ?? e}` });
+      }
+    }
+  }
+  return { files, errors };
+}
+
 // src/functions.ts
 var FUNCTION_REGISTRY = new Map;
 function register(name, fn2) {
@@ -52083,12 +52118,12 @@ register("get_environment_variable", async (args) => ({
   value: process.env[args.var_name] ?? null
 }));
 register("get_system_info", async () => {
-  let system2 = os8.platform();
+  let system2 = os9.platform();
   if (system2 === "darwin")
     system2 = "macOS";
   else if (system2 === "linux") {
     try {
-      const release = fs10.readFileSync("/etc/os-release", "utf-8");
+      const release = fs11.readFileSync("/etc/os-release", "utf-8");
       const m = release.match(/PRETTY_NAME="(.+?)"/);
       if (m)
         system2 = m[1];
@@ -52098,10 +52133,10 @@ register("get_system_info", async () => {
       system2 = "Linux";
     }
   } else if (system2 === "win32") {
-    system2 = `Windows ${os8.release()}`;
+    system2 = `Windows ${os9.release()}`;
   }
-  const shell = process.env.SHELL ? path7.basename(process.env.SHELL) : "unknown";
-  const mount_path = path7.join(os8.homedir(), ".todoforai", "mnt", "todoforai");
+  const shell = process.env.SHELL ? path8.basename(process.env.SHELL) : "unknown";
+  const mount_path = path8.join(os9.homedir(), ".todoforai", "mnt", "todoforai");
   return { system: system2, shell, mount_path };
 });
 register("get_available_tools", async () => {
@@ -52145,11 +52180,11 @@ register("uninstall_tool", async (args) => {
 });
 register("get_workspace_tree", async (args) => {
   const { path: p10, max_depth = 2 } = args;
-  const root = path7.resolve(p10.replace(/^~/, process.env.HOME || "~"));
-  if (!fs10.existsSync(root) || !fs10.statSync(root).isDirectory()) {
+  const root = path8.resolve(p10.replace(/^~/, process.env.HOME || "~"));
+  if (!fs11.existsSync(root) || !fs11.statSync(root).isDirectory()) {
     return { tree: "", is_git: false };
   }
-  const isGit = fs10.existsSync(path7.join(root, ".git"));
+  const isGit = fs11.existsSync(path8.join(root, ".git"));
   if (process.platform !== "win32") {
     try {
       const { execSync: execSync2 } = await import("child_process");
@@ -52172,12 +52207,12 @@ register("get_workspace_tree", async (args) => {
   const ig2 = ignore();
   if (isGit) {
     let scanGitignores = function(dir) {
-      const giPath = path7.join(dir, ".gitignore");
-      if (fs10.existsSync(giPath)) {
+      const giPath = path8.join(dir, ".gitignore");
+      if (fs11.existsSync(giPath)) {
         try {
-          const relDir = path7.relative(root, dir).replace(/\\/g, "/");
+          const relDir = path8.relative(root, dir).replace(/\\/g, "/");
           const prefix = relDir === "" || relDir === "." ? "" : relDir + "/";
-          for (let line of fs10.readFileSync(giPath, "utf-8").split(`
+          for (let line of fs11.readFileSync(giPath, "utf-8").split(`
 `)) {
             line = line.trim();
             if (!line || line.startsWith("#"))
@@ -52191,21 +52226,21 @@ register("get_workspace_tree", async (args) => {
         } catch {}
       }
       try {
-        for (const e of fs10.readdirSync(dir, { withFileTypes: true })) {
+        for (const e of fs11.readdirSync(dir, { withFileTypes: true })) {
           if (e.isDirectory() && e.name !== ".git")
-            scanGitignores(path7.join(dir, e.name));
+            scanGitignores(path8.join(dir, e.name));
         }
       } catch {}
     };
     scanGitignores(root);
   }
-  const lines = [path7.basename(root) + "/"];
+  const lines = [path8.basename(root) + "/"];
   function walk(dirPath, prefix, depth) {
     if (depth > max_depth)
       return;
     let entries;
     try {
-      entries = fs10.readdirSync(dirPath, { withFileTypes: true });
+      entries = fs11.readdirSync(dirPath, { withFileTypes: true });
     } catch {
       return;
     }
@@ -52213,7 +52248,7 @@ register("get_workspace_tree", async (args) => {
       if (e.name === ".git")
         return false;
       if (isGit) {
-        let rel = path7.relative(root, path7.join(dirPath, e.name)).replace(/\\/g, "/");
+        let rel = path8.relative(root, path8.join(dirPath, e.name)).replace(/\\/g, "/");
         if (e.isDirectory())
           rel += "/";
         if (ig2.ignores(rel))
@@ -52235,7 +52270,7 @@ register("get_workspace_tree", async (args) => {
       lines.push(`${prefix}${connector}${entry.name}${suffix}`);
       if (entry.isDirectory()) {
         const extension2 = isLast ? "    " : "│   ";
-        walk(path7.join(dirPath, entry.name), prefix + extension2, depth + 1);
+        walk(path8.join(dirPath, entry.name), prefix + extension2, depth + 1);
       }
     }
   }
@@ -52248,25 +52283,30 @@ register("get_skills", async (args) => {
   const includeUserScope = args?.includeUserScope ?? true;
   return await discoverSkills(paths, { includeUserScope });
 });
+register("get_agent_md", async (args) => {
+  const paths = Array.isArray(args?.paths) ? args.paths : [];
+  const includeUserScope = args?.includeUserScope ?? true;
+  return await discoverAgentMd(paths, { includeUserScope });
+});
 register("get_os_aware_default_path", async () => {
   let p10 = getPlatformDefaultDirectory();
-  if (!p10.endsWith(path7.sep))
-    p10 += path7.sep;
+  if (!p10.endsWith(path8.sep))
+    p10 += path8.sep;
   return { path: p10 };
 });
 register("create_directory", async (args) => {
   const { name } = args;
   if (!name?.trim())
     throw new Error("Folder name cannot be empty");
-  const baseDir = path7.resolve(getPathOrDefault(args.path).replace(/^~/, process.env.HOME || "~"));
-  let target = path7.resolve(name.replace(/^~/, process.env.HOME || "~"));
-  if (!path7.isAbsolute(name))
-    target = path7.join(baseDir, name.trim());
-  const existed = fs10.existsSync(target);
-  fs10.mkdirSync(target, { recursive: true });
+  const baseDir = path8.resolve(getPathOrDefault(args.path).replace(/^~/, process.env.HOME || "~"));
+  let target = path8.resolve(name.replace(/^~/, process.env.HOME || "~"));
+  if (!path8.isAbsolute(name))
+    target = path8.join(baseDir, name.trim());
+  const existed = fs11.existsSync(target);
+  fs11.mkdirSync(target, { recursive: true });
   let full = target;
-  if (!full.endsWith(path7.sep))
-    full += path7.sep;
+  if (!full.endsWith(path8.sep))
+    full += path8.sep;
   return { path: full, created: !existed, exists: true };
 });
 FUNCTION_REGISTRY.set("getOSAwareDefaultPath", FUNCTION_REGISTRY.get("get_os_aware_default_path"));
@@ -52300,7 +52340,7 @@ register("execute_shell_command", async (args, client) => {
   if (!canStream) {
     const { exec } = await import("child_process");
     const result = await new Promise((resolve) => {
-      exec(cmd, { cwd: cwd || os8.tmpdir(), encoding: "utf-8", timeout: timeout * 1000, maxBuffer: 10485760, env: { ...buildEnvWithTools(), ...getConnectionEnv(), TODOFORAI_TODO_ID: todoId, TODOFORAI_MESSAGE_ID: messageId, TODOFORAI_BLOCK_ID: blockId, TODOFORAI_AGENT_SETTINGS_ID: agentSettingsId } }, (_err, stdout, stderr) => {
+      exec(cmd, { cwd: cwd || os9.tmpdir(), encoding: "utf-8", timeout: timeout * 1000, maxBuffer: 10485760, env: { ...buildEnvWithTools(), ...getConnectionEnv(), TODOFORAI_TODO_ID: todoId, TODOFORAI_MESSAGE_ID: messageId, TODOFORAI_BLOCK_ID: blockId, TODOFORAI_AGENT_SETTINGS_ID: agentSettingsId } }, (_err, stdout, stderr) => {
         resolve((stdout || "") + (stderr || ""));
       });
     });
@@ -52365,17 +52405,17 @@ var LIST_DIR_MAX_ENTRIES = 1e4;
 register("list_dir", async (args) => {
   const { path: p10, rootPath = "", fallbackRootPaths = [] } = args;
   const fullPath = resolveFilePath(p10, rootPath, fallbackRootPaths);
-  const st2 = fs10.statSync(fullPath);
+  const st2 = fs11.statSync(fullPath);
   if (!st2.isDirectory())
     throw new Error(`Not a directory: ${fullPath}`);
-  const dirents = fs10.readdirSync(fullPath, { withFileTypes: true });
+  const dirents = fs11.readdirSync(fullPath, { withFileTypes: true });
   if (dirents.length > LIST_DIR_MAX_ENTRIES) {
     throw new Error(`Directory too large: ${dirents.length} entries (max ${LIST_DIR_MAX_ENTRIES})`);
   }
   const entries = dirents.map((d) => {
     let size = 0, mtime = 0, mode = 0, is_dir = d.isDirectory();
     try {
-      const s = fs10.lstatSync(path7.join(fullPath, d.name));
+      const s = fs11.lstatSync(path8.join(fullPath, d.name));
       size = Number(s.size);
       mtime = s.mtimeMs / 1000;
       mode = s.mode & 511;
@@ -52388,23 +52428,123 @@ register("list_dir", async (args) => {
 register("create_file", async (args) => {
   const { path: p10, content, rootPath = "", fallbackRootPaths = [] } = args;
   const fullPath = resolveFilePath(p10, rootPath, fallbackRootPaths);
-  const dir = path7.dirname(fullPath);
+  const dir = path8.dirname(fullPath);
   if (dir)
-    fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(fullPath, content, "utf-8");
+    fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(fullPath, content, "utf-8");
   return { path: fullPath, bytes: Buffer.byteLength(content, "utf-8") };
 });
 register("read_file_base64", async (args) => {
   const { path: p10, rootPath = "", fallbackRootPaths = [] } = args;
   const fullPath = resolveFilePath(p10, rootPath, fallbackRootPaths);
-  if (!fs10.existsSync(fullPath))
+  if (!fs11.existsSync(fullPath))
     throw new Error(`File not found: ${fullPath}`);
-  const stat = fs10.statSync(fullPath);
+  const stat = fs11.statSync(fullPath);
   if (stat.size > 50000000)
     throw new Error(`File too large: ${stat.size.toLocaleString()} bytes (max 50MB)`);
-  const data = fs10.readFileSync(fullPath);
+  const data = fs11.readFileSync(fullPath);
   return { path: fullPath, base64: data.toString("base64"), bytes: data.length };
 });
+register("search_files", async (args) => {
+  const { pattern, path: p10 = ".", cwd = args.root_path ?? "", head = 100, max_count = 5, glob: globPattern = "", ignore_case = true } = args;
+  const { execSync: execWhich } = await import("child_process");
+  const whichCmd = process.platform === "win32" ? "where" : "which";
+  const which = (bin) => {
+    try {
+      return execWhich(`${whichCmd} ${bin}`, { encoding: "utf-8" }).trim().split(`
+`)[0].trim();
+    } catch {
+      return null;
+    }
+  };
+  let rgPath = which("rg");
+  if (!rgPath) {
+    await ensureTool("rg");
+    rgPath = which("rg");
+  }
+  let searchPath = p10.replace(/^~/, process.env.HOME || "~");
+  if (!path8.isAbsolute(searchPath) && cwd)
+    searchPath = path8.join(cwd, searchPath);
+  searchPath = path8.resolve(searchPath);
+  if (!fs11.existsSync(searchPath))
+    throw new Error(`Search path does not exist: ${searchPath}`);
+  let cmd;
+  if (rgPath) {
+    cmd = [rgPath, "--no-heading", "--line-number", "--color=never"];
+    if (ignore_case)
+      cmd.push("--ignore-case");
+    if (max_count > 0)
+      cmd.push(`--max-count=${max_count}`);
+    if (globPattern)
+      cmd.push("--glob", globPattern);
+    cmd.push(pattern, searchPath);
+  } else {
+    console.warn("[search_files] ripgrep (rg) not found, falling back to grep");
+    const grepPath = which("grep") || "grep";
+    cmd = [grepPath, "-rn", "--color=never"];
+    if (ignore_case)
+      cmd.push("-i");
+    if (max_count > 0)
+      cmd.push(`--max-count=${max_count}`);
+    if (globPattern) {
+      cmd.push(`--include=${globPattern}`);
+    }
+    cmd.push(pattern, searchPath);
+  }
+  const { spawn: spawnChild } = await import("child_process");
+  const { stdout, stderr, code } = await new Promise((resolve) => {
+    const child = spawnChild(cmd[0], cmd.slice(1));
+    let out = "", err2 = "";
+    child.stdout?.on("data", (d) => {
+      out += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      err2 += d.toString();
+    });
+    child.on("close", (exitCode) => resolve({ stdout: out, stderr: err2, code: exitCode ?? 1 }));
+  });
+  if (code === 0) {
+    let output = stdout;
+    const lines = output.split(`
+`).filter((l) => l.trim());
+    if (lines.length > head) {
+      output = lines.slice(0, head).join(`
+`) + `
+... (${lines.length - head} more matches truncated)`;
+    }
+    if ((cwd || searchPath) && output) {
+      const searchBase = searchPath && fs11.existsSync(searchPath) && fs11.statSync(searchPath).isDirectory() ? searchPath : path8.dirname(searchPath);
+      const bases = Array.from(new Set([cwd, searchBase].filter(Boolean)));
+      const lines2 = output.split(`
+`).map((line) => {
+        if (line.includes(":")) {
+          const colonIdx = line.indexOf(":");
+          let filePart = line.slice(0, colonIdx);
+          const rest = line.slice(colonIdx);
+          try {
+            const candidates = [filePart, ...bases.map((b) => path8.relative(b, filePart))].filter((p11) => (p11.match(/\.\.\//g) || []).length <= 2);
+            filePart = candidates.reduce((a, b) => a.length <= b.length ? a : b, filePart);
+          } catch {}
+          let fullLine = filePart + rest;
+          if (fullLine.length > 300) {
+            fullLine = fullLine.slice(0, 300) + "...";
+          }
+          return fullLine;
+        }
+        return line;
+      });
+      output = lines2.join(`
+`);
+    }
+    if (output.length > 1e5)
+      output = output.slice(0, 1e5) + `
+... (output truncated)`;
+    return { result: output };
+  }
+  if (code === 1)
+    return { result: "No matches found." };
+  throw new Error(`search error (exit ${code}): ${stderr}`);
+});
 register("download_attachment", async (args, client) => {
   if (!client)
     throw new Error("Client instance required");
@@ -52419,13 +52559,13 @@ register("download_attachment", async (args, client) => {
     throw new Error(`Backend responded with ${res.status}`);
   const base = getPathOrDefault(rootPath);
   let target = p10.replace(/^~/, process.env.HOME || "~");
-  if (!path7.isAbsolute(target))
-    target = path7.join(base, target);
-  target = path7.resolve(target);
-  fs10.mkdirSync(path7.dirname(target), { recursive: true });
+  if (!path8.isAbsolute(target))
+    target = path8.join(base, target);
+  target = path8.resolve(target);
+  fs11.mkdirSync(path8.dirname(target), { recursive: true });
   try {
     const data = Buffer.from(await res.arrayBuffer());
-    fs10.writeFileSync(target, data);
+    fs11.writeFileSync(target, data);
     return { path: target, bytes: data.length };
   } catch (e) {
     throw new Error(`Download failed: ${e.message}`);
@@ -52453,13 +52593,13 @@ register("register_attachment", async (args, client) => {
   const { filePath, userId = "test-user", isPublic = false, agentSettingsId = "", todoId = "", rootPath = "" } = args;
   const base = getPathOrDefault(rootPath);
   let target = filePath.replace(/^~/, process.env.HOME || "~");
-  if (!path7.isAbsolute(target))
-    target = path7.join(base, target);
-  target = path7.resolve(target);
-  if (!fs10.existsSync(target))
+  if (!path8.isAbsolute(target))
+    target = path8.join(base, target);
+  target = path8.resolve(target);
+  if (!fs11.existsSync(target))
     throw new Error(`File not found: ${target}`);
   const form = new FormData;
-  form.append("file", new Blob([fs10.readFileSync(target)]), path7.basename(target));
+  form.append("file", new Blob([fs11.readFileSync(target)]), path8.basename(target));
   if (userId)
     form.append("userId", userId);
   if (agentSettingsId)
@@ -52503,9 +52643,9 @@ async function handleBlockSave(payload, send) {
   const { blockId, todoId, filepath, rootPath, fallbackRootPaths = [], content, requestId } = payload;
   try {
     const resolved = resolveFilePath(filepath, rootPath, fallbackRootPaths);
-    const ext = path8.extname(resolved).toLowerCase();
+    const ext = path9.extname(resolved).toLowerCase();
     if (ext === ".docx" || ext === ".xlsx") {
-      if (!fs11.existsSync(resolved)) {
+      if (!fs12.existsSync(resolved)) {
         throw new Error(`Cannot create new ${ext} file from XML — file must already exist: ${filepath}`);
       }
       if (ext === ".docx")
@@ -52513,10 +52653,10 @@ async function handleBlockSave(payload, send) {
       else
         saveXlsxContent(resolved, content);
     } else {
-      const dir = path8.dirname(resolved);
+      const dir = path9.dirname(resolved);
       if (dir)
-        fs11.mkdirSync(dir, { recursive: true });
-      fs11.writeFileSync(resolved, content, "utf-8");
+        fs12.mkdirSync(dir, { recursive: true });
+      fs12.writeFileSync(resolved, content, "utf-8");
     }
     await send(msg.blockSaveResult(blockId, todoId, "SUCCESS", requestId));
   } catch (e) {
@@ -52527,22 +52667,22 @@ async function handleGetFolders(payload, send) {
   const { requestId, edgeId } = payload;
   const rawPath = getPathOrDefault(payload.path);
   try {
-    const expandedPath = path8.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
+    const expandedPath = path9.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
     let targetPath;
-    if (fs11.existsSync(expandedPath) && fs11.statSync(expandedPath).isDirectory()) {
+    if (fs12.existsSync(expandedPath) && fs12.statSync(expandedPath).isDirectory()) {
       targetPath = expandedPath;
     } else {
-      targetPath = path8.dirname(expandedPath);
+      targetPath = path9.dirname(expandedPath);
     }
-    if (!fs11.existsSync(targetPath) || !fs11.statSync(targetPath).isDirectory()) {
+    if (!fs12.existsSync(targetPath) || !fs12.statSync(targetPath).isDirectory()) {
       throw new Error(`No existing ancestor for path: ${rawPath}`);
     }
     const folders = [];
     const files = [];
-    for (const item of fs11.readdirSync(targetPath)) {
-      const full = path8.join(targetPath, item);
+    for (const item of fs12.readdirSync(targetPath)) {
+      const full = path9.join(targetPath, item);
       try {
-        if (fs11.statSync(full).isDirectory())
+        if (fs12.statSync(full).isDirectory())
           folders.push(full);
         else
           files.push(full);
@@ -52576,10 +52716,10 @@ async function handleDeletePath(payload, send) {
 async function handleWriteFile(payload, send, pendingBinaries) {
   const { requestId, edgeId, path: dirPath, fileName, binaryId, dataBase64 } = payload;
   try {
-    const filePath = path8.join(dirPath, fileName);
-    const dir = path8.dirname(filePath);
+    const filePath = path9.join(dirPath, fileName);
+    const dir = path9.dirname(filePath);
     if (dir)
-      fs11.mkdirSync(dir, { recursive: true });
+      fs12.mkdirSync(dir, { recursive: true });
     let buffer;
     if (binaryId && pendingBinaries?.has(binaryId)) {
       buffer = pendingBinaries.get(binaryId);
@@ -52600,8 +52740,8 @@ async function handleCd(payload, send, edgeConfig, onConfigChange) {
   const { requestId, edgeId } = payload;
   const rawPath = getPathOrDefault(payload.path);
   try {
-    const resolved = path8.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
-    if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isDirectory()) {
+    const resolved = path9.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
+    if (!fs12.existsSync(resolved) || !fs12.statSync(resolved).isDirectory()) {
       throw new Error(`Path does not exist or is not a directory: ${rawPath}`);
     }
     const normalized = resolved.replace(/\/+$/, "");
@@ -52656,12 +52796,12 @@ async function handleFunctionCall(payload, send, client) {
 
 // src/edge.ts
 function generateFingerprint() {
-  const os9 = __require("os");
-  const fs12 = __require("fs");
+  const os10 = __require("os");
+  const fs13 = __require("fs");
   const identifiers = {};
   if (process.platform === "linux") {
     try {
-      const mid = fs12.readFileSync("/etc/machine-id", "utf-8").trim();
+      const mid = fs13.readFileSync("/etc/machine-id", "utf-8").trim();
       if (mid)
         identifiers.machine_id = mid;
     } catch {}
@@ -52676,8 +52816,8 @@ function generateFingerprint() {
   }
   if (Object.keys(identifiers).length === 0) {
     identifiers.platform = process.platform;
-    identifiers.machine = os9.machine?.() || os9.arch();
-    identifiers.node = os9.hostname();
+    identifiers.machine = os10.machine?.() || os10.arch();
+    identifiers.node = os10.hostname();
   }
   const keys = Object.keys(identifiers).sort();
   const json = "{" + keys.map((k) => JSON.stringify(k) + ": " + JSON.stringify(identifiers[k])).join(", ") + "}";
@@ -52863,8 +53003,8 @@ class TODOforAIEdge {
     if (edgeId && edgeId !== this.edgeId)
       return;
     if (payload.workspacepaths) {
-      const path9 = __require("path");
-      payload.workspacepaths = payload.workspacepaths.filter((p10) => !FORBIDDEN_PATHS2.has(path9.normalize(p10).replace(/\/+$/, "")));
+      const path10 = __require("path");
+      payload.workspacepaths = payload.workspacepaths.filter((p10) => !FORBIDDEN_PATHS2.has(path10.normalize(p10).replace(/\/+$/, "")));
     }
     Object.assign(this.edgeConfig, payload);
     if (this.addWorkspacePath) {
@@ -53146,18 +53286,18 @@ class ServerError extends Error {
 }
 
 // node_modules/@todoforai/update-notifier/src/index.ts
-import fs12 from "node:fs";
-import path9 from "node:path";
-import os9 from "node:os";
+import fs13 from "node:fs";
+import path10 from "node:path";
+import os10 from "node:os";
 function isLinkedInstall() {
   try {
-    return !fs12.realpathSync(process.argv[1] || "").includes(`${path9.sep}node_modules${path9.sep}`);
+    return !fs13.realpathSync(process.argv[1] || "").includes(`${path10.sep}node_modules${path10.sep}`);
   } catch {
     return false;
   }
 }
 var TTL_MS = 24 * 60 * 60 * 1000;
-var CACHE_DIR = path9.join(os9.homedir(), ".config", "todoforai");
+var CACHE_DIR = path10.join(os10.homedir(), ".config", "todoforai");
 function cmpVer(a, b) {
   const pa2 = a.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
   const pb2 = b.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
@@ -53171,10 +53311,10 @@ function cmpVer(a, b) {
 function checkForUpdates(pkg) {
   if (!process.stderr.isTTY || process.env.CI || process.env.NO_UPDATE_NOTIFIER || isLinkedInstall())
     return;
-  const cacheFile = path9.join(CACHE_DIR, `notifier-${encodeURIComponent(pkg.name)}.json`);
+  const cacheFile = path10.join(CACHE_DIR, `notifier-${encodeURIComponent(pkg.name)}.json`);
   let cache = {};
   try {
-    cache = JSON.parse(fs12.readFileSync(cacheFile, "utf8"));
+    cache = JSON.parse(fs13.readFileSync(cacheFile, "utf8"));
   } catch {}
   if (cache.latest && cmpVer(cache.latest, pkg.version) > 0) {
     process.stderr.write(`
@@ -53185,42 +53325,42 @@ function checkForUpdates(pkg) {
   }
   if (Date.now() - (cache.ts ?? 0) > TTL_MS) {
     try {
-      fs12.mkdirSync(CACHE_DIR, { recursive: true });
-      fs12.writeFileSync(cacheFile, JSON.stringify({ ...cache, ts: Date.now() }));
+      fs13.mkdirSync(CACHE_DIR, { recursive: true });
+      fs13.writeFileSync(cacheFile, JSON.stringify({ ...cache, ts: Date.now() }));
     } catch {}
     fetch(`https://registry.npmjs.org/${pkg.name}/latest`, { signal: AbortSignal.timeout(3000) }).then((r) => r.ok ? r.json() : null).then((j) => {
       if (!j?.version)
         return;
-      fs12.writeFileSync(cacheFile, JSON.stringify({ ts: Date.now(), latest: j.version }));
+      fs13.writeFileSync(cacheFile, JSON.stringify({ ts: Date.now(), latest: j.version }));
     }).catch(() => {});
   }
 }
 
 // src/index.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
-import fs13 from "fs";
-import path10 from "path";
-import os10 from "os";
+import fs14 from "fs";
+import path11 from "path";
+import os11 from "os";
 import crypto3 from "crypto";
 function readOwnPackage() {
   try {
-    const pkgPath = path10.resolve(fileURLToPath2(import.meta.url), "../../package.json");
-    return JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path11.resolve(fileURLToPath2(import.meta.url), "../../package.json");
+    return JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function lockPath(apiUrl, userId) {
-  const dir = path10.join(os10.homedir(), ".todoforai");
-  fs13.mkdirSync(dir, { recursive: true });
+  const dir = path11.join(os11.homedir(), ".todoforai");
+  fs14.mkdirSync(dir, { recursive: true });
   const hash = crypto3.createHash("sha256").update(`${apiUrl}
 ${userId}`).digest("hex").slice(0, 12);
-  return path10.join(dir, `edge-${hash}.lock`);
+  return path11.join(dir, `edge-${hash}.lock`);
 }
 function isEdgeProcess(pid) {
   try {
     process.kill(pid, 0);
-    const cmdline = fs13.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+    const cmdline = fs14.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
     return cmdline.includes("index.ts") || cmdline.includes("todoforai-edge");
   } catch {
     return false;
@@ -53228,7 +53368,7 @@ function isEdgeProcess(pid) {
 }
 function killExistingEdge(lp2) {
   try {
-    const pid = parseInt(fs13.readFileSync(lp2, "utf-8").trim(), 10);
+    const pid = parseInt(fs14.readFileSync(lp2, "utf-8").trim(), 10);
     if (!isNaN(pid) && isEdgeProcess(pid)) {
       console.log(`\x1B[33mKilling existing edge process (pid ${pid})...\x1B[0m`);
       process.kill(pid, "SIGTERM");
@@ -53251,7 +53391,7 @@ function killExistingEdge(lp2) {
 }
 function acquireLock(lp2, kill = false) {
   try {
-    const pid = parseInt(fs13.readFileSync(lp2, "utf-8").trim(), 10);
+    const pid = parseInt(fs14.readFileSync(lp2, "utf-8").trim(), 10);
     if (!isNaN(pid) && isEdgeProcess(pid)) {
       if (kill) {
         killExistingEdge(lp2);
@@ -53259,13 +53399,13 @@ function acquireLock(lp2, kill = false) {
         return false;
     }
   } catch {}
-  fs13.writeFileSync(lp2, String(process.pid));
+  fs14.writeFileSync(lp2, String(process.pid));
   return true;
 }
 function releaseLock(lp2) {
   try {
-    if (fs13.readFileSync(lp2, "utf-8").trim() === String(process.pid))
-      fs13.unlinkSync(lp2);
+    if (fs14.readFileSync(lp2, "utf-8").trim() === String(process.pid))
+      fs14.unlinkSync(lp2);
   } catch {}
 }
 var MIN_BUN_VERSION = "1.3.14";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@todoforai/edge",
-  "version": "0.13.13",
+  "version": "0.13.15",
   "type": "module",
   "bin": {
     "todoforai-edge": "dist/index.js"