engine7 7.1.17 → 7.1.19

package/dist/main.mjs

@@ -2383,9 +2383,9 @@ function isAutoMemPath(absolutePath, workspace) {
   return normalizedPath.startsWith(getAutoMemPath(workspace));
 }
 async function ensureMemoryDirExists(memoryDir) {
-  const fs54 = await import("node:fs");
+  const fs55 = await import("node:fs");
   try {
-    await fs54.promises.mkdir(memoryDir, { recursive: true });
+    await fs55.promises.mkdir(memoryDir, { recursive: true });
   } catch (e) {
     const code = e?.code;
     if (code !== "EEXIST") {
@@ -4758,7 +4758,7 @@ async function acquireLock(inboxPath) {
   for (let i = 0; i < LOCK_RETRIES; i++) {
     if (await isLockStale(lockPath2)) {
       try {
-        await import("node:fs/promises").then((fs54) => fs54.rm(lockPath2, { force: true }));
+        await import("node:fs/promises").then((fs55) => fs55.rm(lockPath2, { force: true }));
       } catch {
       }
     }
@@ -4766,7 +4766,7 @@ async function acquireLock(inboxPath) {
       await writeFile2(lockPath2, `${process.pid}-${Date.now()}`, { encoding: "utf-8", flag: "wx" });
       return async () => {
         try {
-          await import("node:fs/promises").then((fs54) => fs54.rm(lockPath2, { force: true }));
+          await import("node:fs/promises").then((fs55) => fs55.rm(lockPath2, { force: true }));
         } catch {
         }
       };
@@ -5865,11 +5865,11 @@ async function readLastConsolidatedAt(memoryDir) {
   }
 }
 async function tryAcquireConsolidationLock(memoryDir) {
-  const path55 = lockPath(memoryDir);
+  const path56 = lockPath(memoryDir);
   let mtimeMs;
   let holderPid;
   try {
-    const [s2, raw] = await Promise.all([stat3(path55), readFile5(path55, "utf8")]);
+    const [s2, raw] = await Promise.all([stat3(path56), readFile5(path56, "utf8")]);
     mtimeMs = s2.mtimeMs;
     const parsed = parseInt(raw.trim(), 10);
     holderPid = Number.isFinite(parsed) ? parsed : void 0;
@@ -5882,10 +5882,10 @@ async function tryAcquireConsolidationLock(memoryDir) {
     }
   }
   await mkdir3(memoryDir, { recursive: true });
-  await writeFile4(path55, String(process.pid));
+  await writeFile4(path56, String(process.pid));
   let verify2;
   try {
-    verify2 = await readFile5(path55, "utf8");
+    verify2 = await readFile5(path56, "utf8");
   } catch {
     return null;
   }
@@ -5893,15 +5893,15 @@ async function tryAcquireConsolidationLock(memoryDir) {
   return mtimeMs ?? 0;
 }
 async function rollbackConsolidationLock(memoryDir, priorMtime) {
-  const path55 = lockPath(memoryDir);
+  const path56 = lockPath(memoryDir);
   try {
     if (priorMtime === 0) {
-      await unlink(path55);
+      await unlink(path56);
       return;
     }
-    await writeFile4(path55, "");
+    await writeFile4(path56, "");
     const t = priorMtime / 1e3;
-    await utimes(path55, t, t);
+    await utimes(path56, t, t);
   } catch (e) {
     console.log(`[autoDream] rollback failed: ${e.message} \u2014 next trigger delayed to minHours`);
   }
@@ -6233,30 +6233,30 @@ __export(TodoWriteTool_exports, {
   initTodoStore: () => initTodoStore,
   loadTodos: () => loadTodos
 });
-import fs30 from "node:fs";
-import path30 from "node:path";
+import fs31 from "node:fs";
+import path31 from "node:path";
 function initTodoStore(stateDir) {
-  todosDir = path30.join(stateDir, "todos");
-  if (!fs30.existsSync(todosDir)) {
-    fs30.mkdirSync(todosDir, { recursive: true });
+  todosDir = path31.join(stateDir, "todos");
+  if (!fs31.existsSync(todosDir)) {
+    fs31.mkdirSync(todosDir, { recursive: true });
   }
 }
 function todoFilePath(sessionId) {
-  return path30.join(todosDir, `${sessionId}.json`);
+  return path31.join(todosDir, `${sessionId}.json`);
 }
 function loadTodos(sessionId) {
   if (!todosDir) return [];
   try {
     const filePath = todoFilePath(sessionId);
-    if (!fs30.existsSync(filePath)) return [];
-    return JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+    if (!fs31.existsSync(filePath)) return [];
+    return JSON.parse(fs31.readFileSync(filePath, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveTodos(sessionId, todos) {
   if (!todosDir) return;
-  fs30.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
+  fs31.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
 }
 var todosDir;
 var init_TodoWriteTool = __esm({
@@ -6337,28 +6337,28 @@ __export(tasks_exports, {
   unassignTeammateTasks: () => unassignTeammateTasks,
   updateTask: () => updateTask
 });
-import * as fs32 from "node:fs";
-import * as path32 from "node:path";
+import * as fs33 from "node:fs";
+import * as path33 from "node:path";
 function sanitizePathComponent2(input) {
   return input.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
 function getTasksDir2(stateDir, listId) {
-  return path32.join(stateDir, "tasks", sanitizePathComponent2(listId));
+  return path33.join(stateDir, "tasks", sanitizePathComponent2(listId));
 }
 function getTaskPath(stateDir, listId, taskId) {
-  return path32.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
+  return path33.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
 }
 function ensureTasksDir2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
-  fs32.mkdirSync(dir, { recursive: true });
+  fs33.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function getHighWaterMarkPath(stateDir, listId) {
-  return path32.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
+  return path33.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
 }
 function readHighWaterMark(stateDir, listId) {
   try {
-    const content = fs32.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
+    const content = fs33.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
     const value = parseInt(content, 10);
     return isNaN(value) ? 0 : value;
   } catch {
@@ -6366,13 +6366,13 @@ function readHighWaterMark(stateDir, listId) {
   }
 }
 function writeHighWaterMark(stateDir, listId, value) {
-  fs32.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
+  fs33.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
 }
 function findHighestTaskIdFromFiles(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs32.readdirSync(dir);
+    files = fs33.readdirSync(dir);
   } catch {
     return 0;
   }
@@ -6398,14 +6398,14 @@ function createTask(stateDir, listId, taskData) {
     const id = String(highestId + 1);
     const task = { id, ...taskData };
     const filePath = getTaskPath(stateDir, listId, id);
-    fs32.writeFileSync(filePath, JSON.stringify(task, null, 2));
+    fs33.writeFileSync(filePath, JSON.stringify(task, null, 2));
     return id;
   });
 }
 function getTask2(stateDir, listId, taskId) {
   const filePath = getTaskPath(stateDir, listId, taskId);
   try {
-    const content = fs32.readFileSync(filePath, "utf-8");
+    const content = fs33.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -6415,7 +6415,7 @@ function listTasks2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs32.readdirSync(dir);
+    files = fs33.readdirSync(dir);
   } catch {
     return [];
   }
@@ -6427,7 +6427,7 @@ function updateTask(stateDir, listId, taskId, updates) {
   if (!existing) return null;
   const updated = { ...existing, ...updates, id: taskId };
   const filePath = getTaskPath(stateDir, listId, taskId);
-  fs32.writeFileSync(filePath, JSON.stringify(updated, null, 2));
+  fs33.writeFileSync(filePath, JSON.stringify(updated, null, 2));
   return updated;
 }
 function deleteTask(stateDir, listId, taskId) {
@@ -6441,7 +6441,7 @@ function deleteTask(stateDir, listId, taskId) {
     }
   }
   try {
-    fs32.unlinkSync(filePath);
+    fs33.unlinkSync(filePath);
   } catch {
     return false;
   }
@@ -6559,15 +6559,15 @@ var read_exports = {};
 __export(read_exports, {
   readFileState: () => readFileState
 });
-import * as fs33 from "node:fs";
-import * as path33 from "node:path";
+import * as fs34 from "node:fs";
+import * as path34 from "node:path";
 function isBlockedDevicePath(filePath) {
   if (BLOCKED_DEVICE_PATHS.has(filePath)) return true;
   if (filePath.startsWith("/proc/") && (filePath.endsWith("/fd/0") || filePath.endsWith("/fd/1") || filePath.endsWith("/fd/2"))) return true;
   return false;
 }
 function checkReadLoop(filePath, offset, limit) {
-  const stat8 = fs33.statSync(filePath);
+  const stat8 = fs34.statSync(filePath);
   const mtimeMs = stat8.mtimeMs;
   const prev = readHistory.get(filePath);
   if (prev && prev.offset === offset && prev.limit === limit && prev.mtimeMs === mtimeMs) {
@@ -6581,19 +6581,19 @@ function checkReadLoop(filePath, offset, limit) {
   return null;
 }
 function readFileContent(filePath) {
-  const fd = fs33.openSync(filePath, "r");
+  const fd = fs34.openSync(filePath, "r");
   const bom = Buffer.alloc(2);
-  fs33.readSync(fd, bom, 0, 2, 0);
-  fs33.closeSync(fd);
+  fs34.readSync(fd, bom, 0, 2, 0);
+  fs34.closeSync(fd);
   let encoding = "utf8";
   if (bom[0] === 255 && bom[1] === 254) {
     encoding = "utf16le";
   }
-  const stat8 = fs33.statSync(filePath);
+  const stat8 = fs34.statSync(filePath);
   if (stat8.size > MAX_FILE_SIZE) {
     throw new Error(`\u6587\u4EF6\u592A\u5927 (${(stat8.size / 1024).toFixed(1)}KB)\uFF0C\u8D85\u8FC7 ${MAX_FILE_SIZE / 1024}KB \u9650\u5236\u3002\u8BF7\u4F7F\u7528 offset + limit \u5206\u6BB5\u8BFB\u53D6\u3002`);
   }
-  const raw = fs33.readFileSync(filePath, encoding);
+  const raw = fs34.readFileSync(filePath, encoding);
   const content = raw.toString().replaceAll("\r\n", "\n");
   return { content, encoding };
 }
@@ -6735,11 +6735,11 @@ Usage:
         } catch (e) {
           return { content: e.message, isError: true };
         }
-        if (!fs33.existsSync(filePath)) {
+        if (!fs34.existsSync(filePath)) {
           return { content: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, isError: true };
         }
-        const stat8 = fs33.statSync(filePath);
-        const baseName = path33.basename(filePath).toUpperCase();
+        const stat8 = fs34.statSync(filePath);
+        const baseName = path34.basename(filePath).toUpperCase();
         if (BLOCKED_BASENAMES.has(baseName)) {
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6: ${filePath}`, isError: true };
         }
@@ -6747,11 +6747,11 @@ Usage:
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4F1A\u963B\u585E\u6216\u4EA7\u751F\u65E0\u9650\u8F93\u51FA: ${filePath}`, isError: true };
         }
         if (stat8.isDirectory()) {
-          const entries = fs33.readdirSync(filePath);
+          const entries = fs34.readdirSync(filePath);
           const items = entries.map((e) => {
-            const full = path33.join(filePath, e);
+            const full = path34.join(filePath, e);
             try {
-              const s2 = fs33.statSync(full);
+              const s2 = fs34.statSync(full);
               return s2.isDirectory() ? `${e}/` : e;
             } catch {
               return e;
@@ -6760,7 +6760,7 @@ Usage:
           return { content: `\u76EE\u5F55 (${entries.length} \u9879):
 ${items.join("\n")}` };
         }
-        const ext = path33.extname(filePath).toLowerCase();
+        const ext = path34.extname(filePath).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext)) {
           return { content: `\u4E8C\u8FDB\u5236\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6 (${ext}): ${filePath}`, isError: true };
         }
@@ -6808,22 +6808,22 @@ ${result}` : result };
 
 // src/tools/write.ts
 var write_exports = {};
-import * as fs34 from "node:fs";
-import * as path34 from "node:path";
+import * as fs35 from "node:fs";
+import * as path35 from "node:path";
 function isBlockedPath(filePath) {
   return BLOCKED_PATTERNS.some((p2) => p2.test(filePath));
 }
 function atomicWrite(filePath, content) {
   const tmpPath = filePath + ".tmp." + Date.now() + ".write";
-  fs34.writeFileSync(tmpPath, content, "utf-8");
+  fs35.writeFileSync(tmpPath, content, "utf-8");
   try {
-    fs34.renameSync(tmpPath, filePath);
+    fs35.renameSync(tmpPath, filePath);
   } catch (e) {
     try {
-      fs34.unlinkSync(tmpPath);
+      fs35.unlinkSync(tmpPath);
     } catch {
     }
-    fs34.writeFileSync(filePath, content, "utf-8");
+    fs35.writeFileSync(filePath, content, "utf-8");
   }
 }
 function simpleDiff(oldContent, newContent) {
@@ -6917,15 +6917,15 @@ Usage:
         }
         const rawContent = args2.content;
         const content = rawContent.replaceAll("\r\n", "\n");
-        if (fs34.existsSync(filePath) && fs34.statSync(filePath).isDirectory()) {
+        if (fs35.existsSync(filePath) && fs35.statSync(filePath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
         }
         let oldContent = null;
         let isCreate = true;
-        if (fs34.existsSync(filePath)) {
+        if (fs35.existsSync(filePath)) {
           isCreate = false;
           try {
-            oldContent = fs34.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            oldContent = fs35.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
           } catch {
             isCreate = true;
           }
@@ -6941,10 +6941,10 @@ Usage:
               isError: true
             };
           }
-          const currentStat = fs34.statSync(filePath);
+          const currentStat = fs35.statSync(filePath);
           const lastWriteTime = Math.floor(currentStat.mtimeMs);
           if (lastWriteTime > readState.timestamp) {
-            const currentContent = fs34.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            const currentContent = fs35.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
             if (currentContent !== oldContent) {
               return {
                 content: `\u6587\u4EF6\u5728\u8BFB\u53D6\u540E\u88AB\u4FEE\u6539\u3002\u8BF7\u5148\u91CD\u65B0\u8BFB\u53D6\u6587\u4EF6\u518D\u5199\u5165: ${filePath}`,
@@ -6953,9 +6953,9 @@ Usage:
             }
           }
         }
-        const dir = path34.dirname(filePath);
+        const dir = path35.dirname(filePath);
         try {
-          fs34.mkdirSync(dir, { recursive: true });
+          fs35.mkdirSync(dir, { recursive: true });
         } catch (e) {
           return { content: `\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${dir} \u2014 ${e.message}`, isError: true };
         }
@@ -6964,11 +6964,11 @@ Usage:
         } catch (e) {
           return { content: `\u5199\u5165\u5931\u8D25: ${e.message}`, isError: true };
         }
-        readFileState.set(filePath, { timestamp: fs34.statSync(filePath).mtimeMs });
+        readFileState.set(filePath, { timestamp: fs35.statSync(filePath).mtimeMs });
         const action = isCreate ? "\u521B\u5EFA" : "\u66F4\u65B0";
         const lines = content.split("\n").length;
         const chars = content.length;
-        const stat8 = fs34.statSync(filePath);
+        const stat8 = fs35.statSync(filePath);
         let diff = "";
         if (!isCreate && oldContent !== null) {
           diff = `
@@ -6988,8 +6988,8 @@ ${simpleDiff(oldContent, content)}`;
 
 // src/tools/edit.ts
 var edit_exports = {};
-import * as fs35 from "node:fs";
-import * as path35 from "node:path";
+import * as fs36 from "node:fs";
+import * as path36 from "node:path";
 function normalizeQuotes(str) {
   return str.replaceAll(LEFT_SINGLE_CURLY, "'").replaceAll(RIGHT_SINGLE_CURLY, "'").replaceAll(LEFT_DOUBLE_CURLY, '"').replaceAll(RIGHT_DOUBLE_CURLY, '"');
 }
@@ -7142,7 +7142,7 @@ Usage:
         }
         let fileContent = null;
         try {
-          const stat8 = fs35.statSync(filePath);
+          const stat8 = fs36.statSync(filePath);
           if (stat8.isDirectory()) {
             return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
           }
@@ -7152,21 +7152,21 @@ Usage:
         } catch (e) {
           if (e.code === "ENOENT") {
             if (oldString === "") {
-              const dir = path35.dirname(filePath);
-              fs35.mkdirSync(dir, { recursive: true });
-              fs35.writeFileSync(filePath, newString, "utf-8");
-              readFileState.set(filePath, { timestamp: fs35.statSync(filePath).mtimeMs });
+              const dir = path36.dirname(filePath);
+              fs36.mkdirSync(dir, { recursive: true });
+              fs36.writeFileSync(filePath, newString, "utf-8");
+              readFileState.set(filePath, { timestamp: fs36.statSync(filePath).mtimeMs });
               return { content: `\u521B\u5EFA\u6587\u4EF6: ${filePath} (${newString.split("\n").length} \u884C)` };
             }
             return { content: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, isError: true };
           }
           throw e;
         }
-        const rawContent = fs35.readFileSync(filePath, "utf-8");
+        const rawContent = fs36.readFileSync(filePath, "utf-8");
         fileContent = rawContent.replaceAll("\r\n", "\n");
         if (oldString === "" && fileContent.trim() === "") {
-          fs35.writeFileSync(filePath, newString, "utf-8");
-          readFileState.set(filePath, { timestamp: fs35.statSync(filePath).mtimeMs });
+          fs36.writeFileSync(filePath, newString, "utf-8");
+          readFileState.set(filePath, { timestamp: fs36.statSync(filePath).mtimeMs });
           return { content: `\u5199\u5165\u7A7A\u6587\u4EF6: ${filePath} (${newString.split("\n").length} \u884C)` };
         }
         const readState = readFileState.get(filePath);
@@ -7176,11 +7176,11 @@ Usage:
             isError: true
           };
         }
-        const currentStat = fs35.statSync(filePath);
+        const currentStat = fs36.statSync(filePath);
         const lastWriteTime = Math.floor(currentStat.mtimeMs);
         if (lastWriteTime > readState.timestamp) {
           if (fileContent !== rawContent.replaceAll("\r\n", "\n")) {
-            if (fileContent !== fs35.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n")) {
+            if (fileContent !== fs36.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n")) {
               return {
                 content: `\u6587\u4EF6\u5728\u8BFB\u53D6\u540E\u88AB\u4FEE\u6539\u3002\u8BF7\u5148\u91CD\u65B0\u8BFB\u53D6\u6587\u4EF6\u518D\u7F16\u8F91: ${filePath}`,
                 isError: true
@@ -7212,8 +7212,8 @@ ${preview}
         const actualNewString = preserveQuoteStyle(oldString, actualOldString, newString);
         const diffView = generateEditDiff(fileContent, actualOldString, actualNewString);
         const newContent = applyEditToFile(fileContent, actualOldString, actualNewString, replaceAll);
-        fs35.writeFileSync(filePath, newContent, "utf-8");
-        readFileState.set(filePath, { timestamp: fs35.statSync(filePath).mtimeMs });
+        fs36.writeFileSync(filePath, newContent, "utf-8");
+        readFileState.set(filePath, { timestamp: fs36.statSync(filePath).mtimeMs });
         const strategy = actualOldString === oldString ? "\u7CBE\u786E\u5339\u914D" : "\u5F15\u53F7\u89C4\u8303\u5316\u5339\u914D";
         const count = replaceAll ? matchCount : 1;
         const diff = `${oldString.length}\u2192${newString.length}\u5B57\u7B26`;
@@ -7231,8 +7231,8 @@ ${diffView}`
 
 // src/tools/glob.ts
 var glob_exports = {};
-import * as fs36 from "node:fs";
-import * as path36 from "node:path";
+import * as fs37 from "node:fs";
+import * as path37 from "node:path";
 function globMatch(pattern, filename) {
   const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   try {
@@ -7252,18 +7252,18 @@ function findFiles(dir, pattern, limit, baseDir) {
     }
     let entries;
     try {
-      entries = fs36.readdirSync(currentDir, { withFileTypes: true });
+      entries = fs37.readdirSync(currentDir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (truncated) return;
-      const fullPath = path36.join(currentDir, entry.name);
+      const fullPath = path37.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (VCS_DIRS.has(entry.name)) continue;
         walk(fullPath);
       } else if (entry.isFile()) {
-        const relativePath = path36.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = path37.relative(baseDir, fullPath).replace(/\\/g, "/");
         const patternsToTry = [pattern];
         if (pattern.startsWith("**/")) {
           patternsToTry.push(pattern.slice(3));
@@ -7273,7 +7273,7 @@ function findFiles(dir, pattern, limit, baseDir) {
         );
         if (matched) {
           try {
-            const stat8 = fs36.statSync(fullPath);
+            const stat8 = fs37.statSync(fullPath);
             results.push({ path: fullPath, mtimeMs: stat8.mtimeMs });
           } catch {
           }
@@ -7290,7 +7290,7 @@ function findFiles(dir, pattern, limit, baseDir) {
   };
 }
 function toRelativePath(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path36.sep)) {
+  if (absolutePath.startsWith(cwd + path37.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   return absolutePath;
@@ -7323,10 +7323,10 @@ var init_glob = __esm({
         const searchPath = args2.path ? resolvePath(args2.path, ctx.workspace) : ctx.workspace;
         const pattern = args2.pattern;
         const limit = args2.limit || DEFAULT_LIMIT;
-        if (!fs36.existsSync(searchPath)) {
+        if (!fs37.existsSync(searchPath)) {
           return { content: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${searchPath}`, isError: true };
         }
-        if (!fs36.statSync(searchPath).isDirectory()) {
+        if (!fs37.statSync(searchPath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${searchPath}`, isError: true };
         }
         const start = Date.now();
@@ -7351,7 +7351,7 @@ ${filenames.join("\n")}${truncatedNote}`
 // src/tools/grep.ts
 var grep_exports = {};
 import { execFile as execFile2 } from "node:child_process";
-import * as path37 from "node:path";
+import * as path38 from "node:path";
 function ripGrep(args2, searchPath, signal) {
   return new Promise((resolve12) => {
     const fullArgs = [...args2, searchPath];
@@ -7383,7 +7383,7 @@ function applyHeadLimit(items, limit, offset = 0) {
   };
 }
 function toRelativePath2(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path37.sep)) {
+  if (absolutePath.startsWith(cwd + path38.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   if (absolutePath.startsWith(cwd)) {
@@ -10051,8 +10051,8 @@ var init_web_fetch = __esm({
 });
 
 // src/cron/tasks.ts
-import fs37 from "node:fs";
-import path38 from "node:path";
+import fs38 from "node:fs";
+import path39 from "node:path";
 import crypto5 from "node:crypto";
 function getStorageDir() {
   return storageDir;
@@ -10060,14 +10060,14 @@ function getStorageDir() {
 async function withFileLock(lockPath2, fn) {
   for (let attempt = 0; attempt < LOCK_RETRY_COUNT; attempt++) {
     try {
-      fs37.mkdirSync(lockPath2, { recursive: false });
+      fs38.mkdirSync(lockPath2, { recursive: false });
       break;
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stat8 = fs37.statSync(lockPath2);
+        const stat8 = fs38.statSync(lockPath2);
         if (Date.now() - stat8.mtimeMs > LOCK_STALE_THRESHOLD_MS) {
-          fs37.rmSync(lockPath2, { recursive: true, force: true });
+          fs38.rmSync(lockPath2, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -10083,22 +10083,22 @@ async function withFileLock(lockPath2, fn) {
     return fn();
   } finally {
     try {
-      fs37.rmSync(lockPath2, { recursive: true, force: true });
+      fs38.rmSync(lockPath2, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function atomicWriteJSON(filePath, data) {
   const tmpPath = filePath + ".tmp";
-  fs37.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-  fs37.renameSync(tmpPath, filePath);
+  fs38.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  fs38.renameSync(tmpPath, filePath);
 }
 function readTasksFromDisk() {
-  if (!tasksFilePath || !fs37.existsSync(tasksFilePath)) {
+  if (!tasksFilePath || !fs38.existsSync(tasksFilePath)) {
     return [];
   }
   try {
-    const raw = fs37.readFileSync(tasksFilePath, "utf-8");
+    const raw = fs38.readFileSync(tasksFilePath, "utf-8");
     const store = JSON.parse(raw);
     return store.tasks ?? [];
   } catch (err) {
@@ -10107,7 +10107,7 @@ function readTasksFromDisk() {
   }
 }
 async function writeTasksToDisk(tasks2) {
-  const lockPath2 = path38.join(storageDir, "tasks.json.lock");
+  const lockPath2 = path39.join(storageDir, "tasks.json.lock");
   await withFileLock(lockPath2, () => {
     const store = {
       version: 1,
@@ -10119,9 +10119,9 @@ async function writeTasksToDisk(tasks2) {
 }
 function initTaskStore(dir) {
   storageDir = dir;
-  tasksFilePath = path38.join(dir, "tasks.json");
-  if (!fs37.existsSync(dir)) {
-    fs37.mkdirSync(dir, { recursive: true });
+  tasksFilePath = path39.join(dir, "tasks.json");
+  if (!fs38.existsSync(dir)) {
+    fs38.mkdirSync(dir, { recursive: true });
   }
   const tasks2 = readTasksFromDisk();
   console.log(`[cron] Task store initialized: ${dir} (${tasks2.length} tasks loaded)`);
@@ -11032,12 +11032,12 @@ async function executeAndDeliver(task, now, deps) {
     if (promptText.startsWith("@")) {
       let filePath = promptText.slice(1).trim();
       try {
-        const fs54 = await import("fs");
-        const path55 = await import("path");
-        if (!path55.isAbsolute(filePath)) {
-          filePath = path55.join(deps.sessions["config"].stateDir, filePath);
+        const fs55 = await import("fs");
+        const path56 = await import("path");
+        if (!path56.isAbsolute(filePath)) {
+          filePath = path56.join(deps.sessions["config"].stateDir, filePath);
         }
-        promptText = fs54.readFileSync(filePath, "utf-8");
+        promptText = fs55.readFileSync(filePath, "utf-8");
         console.log(`[cron] Loaded prompt from ${filePath} (${promptText.length} chars)`);
       } catch (err) {
         throw new Error(`Prompt file not found: ${filePath}: ${err.message}`);
@@ -11064,16 +11064,16 @@ async function executeAndDeliver(task, now, deps) {
     let finalResult = result;
     if (task.postProcess) {
       try {
-        const path55 = await import("path");
-        const fs54 = await import("fs");
+        const path56 = await import("path");
+        const fs55 = await import("fs");
         let scriptPath = task.postProcess;
-        if (!path55.isAbsolute(scriptPath)) {
-          scriptPath = path55.join(deps.sessions["config"].stateDir, scriptPath);
+        if (!path56.isAbsolute(scriptPath)) {
+          scriptPath = path56.join(deps.sessions["config"].stateDir, scriptPath);
         }
-        const resultsDirTmp = path55.join(getStorageDir(), "results");
-        fs54.mkdirSync(resultsDirTmp, { recursive: true });
-        const inputFile = path55.join(resultsDirTmp, `${task.id}.input.txt`);
-        fs54.writeFileSync(inputFile, result, "utf-8");
+        const resultsDirTmp = path56.join(getStorageDir(), "results");
+        fs55.mkdirSync(resultsDirTmp, { recursive: true });
+        const inputFile = path56.join(resultsDirTmp, `${task.id}.input.txt`);
+        fs55.writeFileSync(inputFile, result, "utf-8");
         const { execFile: execFile3 } = await import("child_process");
         await new Promise((resolve12) => {
           execFile3("python", [scriptPath, "main", "--file", inputFile], {
@@ -11100,12 +11100,12 @@ async function executeAndDeliver(task, now, deps) {
       }
     }
     try {
-      const fs54 = await import("fs");
-      const path55 = await import("path");
-      const resultsDir = path55.join(getStorageDir(), "results");
-      fs54.mkdirSync(resultsDir, { recursive: true });
-      const resultFile = path55.join(resultsDir, `${task.id}.json`);
-      fs54.writeFileSync(resultFile, JSON.stringify({
+      const fs55 = await import("fs");
+      const path56 = await import("path");
+      const resultsDir = path56.join(getStorageDir(), "results");
+      fs55.mkdirSync(resultsDir, { recursive: true });
+      const resultFile = path56.join(resultsDir, `${task.id}.json`);
+      fs55.writeFileSync(resultFile, JSON.stringify({
         taskId: task.id,
         description: task.description,
         executedAt: now.toISOString(),
@@ -11352,30 +11352,30 @@ function registerCronTools() {
       }
     },
     handler: async (args2) => {
-      const fs54 = await import("fs");
-      const path55 = await import("path");
-      const resultsDir = path55.join(getStorageDir(), "results");
-      if (!fs54.existsSync(resultsDir)) {
+      const fs55 = await import("fs");
+      const path56 = await import("path");
+      const resultsDir = path56.join(getStorageDir(), "results");
+      if (!fs55.existsSync(resultsDir)) {
         return { content: "\u6682\u65E0cron\u6267\u884C\u7ED3\u679C" };
       }
       if (args2.task_id) {
-        const file = path55.join(resultsDir, `${args2.task_id}.json`);
-        if (!fs54.existsSync(file)) {
+        const file = path56.join(resultsDir, `${args2.task_id}.json`);
+        if (!fs55.existsSync(file)) {
           return { content: `\u4EFB\u52A1 ${args2.task_id} \u6682\u65E0\u6267\u884C\u7ED3\u679C`, isError: true };
         }
-        const data = JSON.parse(fs54.readFileSync(file, "utf-8"));
+        const data = JSON.parse(fs55.readFileSync(file, "utf-8"));
         return { content: `## ${data.description}
 \u6267\u884C\u65F6\u95F4: ${data.executedAt}
 \u7B2C${data.runCount}\u6B21\u6267\u884C
 
 ${data.result}` };
       }
-      const files = fs54.readdirSync(resultsDir).filter((f2) => f2.endsWith(".json"));
+      const files = fs55.readdirSync(resultsDir).filter((f2) => f2.endsWith(".json"));
       if (files.length === 0) {
         return { content: "\u6682\u65E0cron\u6267\u884C\u7ED3\u679C" };
       }
       const results = files.map((f2) => {
-        const data = JSON.parse(fs54.readFileSync(path55.join(resultsDir, f2), "utf-8"));
+        const data = JSON.parse(fs55.readFileSync(path56.join(resultsDir, f2), "utf-8"));
         return `### ${data.description} (${data.taskId.slice(0, 8)})
 \u6267\u884C: ${data.executedAt} | \u7B2C${data.runCount}\u6B21
 ${data.result.slice(0, 500)}${data.result.length > 500 ? "..." : ""}`;
@@ -11491,12 +11491,12 @@ var init_wx_query = __esm({
       handler: async (args2, _context) => {
         const { findShell: findShell2 } = await Promise.resolve().then(() => (init_BashTool(), BashTool_exports));
         const shell = findShell2();
-        const { spawn: spawn7 } = await import("node:child_process");
+        const { spawn: spawn8 } = await import("node:child_process");
         const cmd = args2.command.trim();
         const timeout = args2.timeout || 12e4;
         const fullCmd = `${PYTHON} "${SCRIPT}" ${cmd.replace(/^python3\s+.*wx_query\.py\s*/, "")}`;
         return new Promise((resolve12) => {
-          const child = spawn7(shell.shell, [...shell.args, fullCmd], {
+          const child = spawn8(shell.shell, [...shell.args, fullCmd], {
             timeout,
             env: { ...process.env }
           });
@@ -11757,8 +11757,8 @@ __export(license_exports, {
   resetLicenseCache: () => resetLicenseCache
 });
 import * as crypto6 from "node:crypto";
-import * as fs38 from "node:fs";
-import * as path39 from "node:path";
+import * as fs39 from "node:fs";
+import * as path40 from "node:path";
 function loadLicense(stateDir, devMode) {
   if (_licenseChecked) return _cachedLicense;
   _licenseChecked = true;
@@ -11771,13 +11771,13 @@ function loadLicense(stateDir, devMode) {
     _cachedLicense = allActive;
     return allActive;
   }
-  const licensePath = path39.join(stateDir, "license.json");
-  if (!fs38.existsSync(licensePath)) {
+  const licensePath = path40.join(stateDir, "license.json");
+  if (!fs39.existsSync(licensePath)) {
     console.log("[license] No license.json found, running basic engine only");
     return null;
   }
   try {
-    const raw = fs38.readFileSync(licensePath, "utf-8");
+    const raw = fs39.readFileSync(licensePath, "utf-8");
     const license = JSON.parse(raw);
     const { signature, ...payload } = license;
     if (!signature) {
@@ -11827,12 +11827,12 @@ function isFeatureLicensed(featureId) {
   return f2?.active === true;
 }
 function getLicenseStatus(stateDir) {
-  const licensePath = path39.join(stateDir, "license.json");
-  if (!fs38.existsSync(licensePath)) {
+  const licensePath = path40.join(stateDir, "license.json");
+  if (!fs39.existsSync(licensePath)) {
     return { licensed: false, features: {} };
   }
   try {
-    const raw = fs38.readFileSync(licensePath, "utf-8");
+    const raw = fs39.readFileSync(licensePath, "utf-8");
     const license = JSON.parse(raw);
     const active = loadLicense(stateDir);
     return {
@@ -12126,37 +12126,37 @@ var init_memory_host_events = __esm({
 });
 
 // src/memory/shims/security-runtime.ts
-import path40 from "node:path";
-import fs39 from "node:fs";
+import path41 from "node:path";
+import fs40 from "node:fs";
 function privateFileStore(rootDir) {
   return {
     read: (relPath) => {
-      const full = path40.join(rootDir, relPath);
+      const full = path41.join(rootDir, relPath);
       try {
-        return fs39.readFileSync(full, "utf-8");
+        return fs40.readFileSync(full, "utf-8");
       } catch {
         return null;
       }
     },
     write: (relPath, content) => {
-      const full = path40.join(rootDir, relPath);
-      fs39.mkdirSync(path40.dirname(full), { recursive: true });
-      fs39.writeFileSync(full, content, "utf-8");
+      const full = path41.join(rootDir, relPath);
+      fs40.mkdirSync(path41.dirname(full), { recursive: true });
+      fs40.writeFileSync(full, content, "utf-8");
     },
     readJsonIfExists: (relPath) => {
-      const full = path40.join(rootDir, relPath);
+      const full = path41.join(rootDir, relPath);
       try {
-        const raw = fs39.readFileSync(full, "utf-8");
+        const raw = fs40.readFileSync(full, "utf-8");
         return JSON.parse(raw);
       } catch {
         return null;
       }
     },
     writeJson: (relPath, data, opts) => {
-      const full = path40.join(rootDir, relPath);
-      fs39.mkdirSync(path40.dirname(full), { recursive: true });
+      const full = path41.join(rootDir, relPath);
+      fs40.mkdirSync(path41.dirname(full), { recursive: true });
       const content = JSON.stringify(data, null, 2) + (opts?.trailingNewline ? "\n" : "");
-      fs39.writeFileSync(full, content, "utf-8");
+      fs40.writeFileSync(full, content, "utf-8");
     }
   };
 }
@@ -12210,8 +12210,8 @@ var init_memory_budget = __esm({
 
 // src/memory/tools/short-term-promotion.ts
 import { createHash as createHash2 } from "node:crypto";
-import fs40 from "node:fs/promises";
-import path41 from "node:path";
+import fs41 from "node:fs/promises";
+import path42 from "node:path";
 function clampScore(value) {
   if (!Number.isFinite(value)) {
     return 0;
@@ -12429,10 +12429,10 @@ function normalizeStore(raw, nowIso2) {
   };
 }
 function resolveLockPath(workspaceDir) {
-  return path41.join(workspaceDir, SHORT_TERM_LOCK_RELATIVE_PATH);
+  return path42.join(workspaceDir, SHORT_TERM_LOCK_RELATIVE_PATH);
 }
 function resolveShortTermArtifactsDir(workspaceDir) {
-  return path41.dirname(resolveLockPath(workspaceDir));
+  return path42.dirname(resolveLockPath(workspaceDir));
 }
 async function ensureShortTermArtifactsDir(workspaceDir) {
   const artifactsDir = resolveShortTermArtifactsDir(workspaceDir);
@@ -12441,7 +12441,7 @@ async function ensureShortTermArtifactsDir(workspaceDir) {
     await existing;
     return;
   }
-  const ensuring = fs40.mkdir(artifactsDir, { recursive: true }).then(() => void 0).catch((err) => {
+  const ensuring = fs41.mkdir(artifactsDir, { recursive: true }).then(() => void 0).catch((err) => {
     ensuredShortTermDirs.delete(artifactsDir);
     throw err;
   });
@@ -12472,7 +12472,7 @@ function isProcessLikelyAlive(pid) {
   }
 }
 async function canStealStaleLock(lockPath2) {
-  const ownerPid = await fs40.readFile(lockPath2, "utf-8").then((raw) => parseLockOwnerPid(raw)).catch(() => null);
+  const ownerPid = await fs41.readFile(lockPath2, "utf-8").then((raw) => parseLockOwnerPid(raw)).catch(() => null);
   if (ownerPid === null) {
     return true;
   }
@@ -12508,23 +12508,23 @@ async function withShortTermLock(workspaceDir, task) {
     const startedAt = Date.now();
     while (true) {
       try {
-        const lockHandle = await fs40.open(lockPath2, "wx");
+        const lockHandle = await fs41.open(lockPath2, "wx");
         await lockHandle.writeFile(`${process.pid}:${Date.now()}
 `, "utf-8").catch(() => void 0);
         try {
           return await task();
         } finally {
           await lockHandle.close().catch(() => void 0);
-          await fs40.unlink(lockPath2).catch(() => void 0);
+          await fs41.unlink(lockPath2).catch(() => void 0);
         }
       } catch (err) {
         if (err?.code !== "EEXIST") {
           throw err;
         }
-        const ageMs = await fs40.stat(lockPath2).then((stats2) => Date.now() - stats2.mtimeMs).catch(() => 0);
+        const ageMs = await fs41.stat(lockPath2).then((stats2) => Date.now() - stats2.mtimeMs).catch(() => 0);
         if (ageMs > SHORT_TERM_LOCK_STALE_MS) {
           if (await canStealStaleLock(lockPath2)) {
-            await fs40.unlink(lockPath2).catch(() => void 0);
+            await fs41.unlink(lockPath2).catch(() => void 0);
             continue;
           }
         }
@@ -12675,9 +12675,9 @@ var init_short_term_promotion = __esm({
     DAY_MS = 24 * 60 * 60 * 1e3;
     MAX_QUERY_HASHES = 32;
     MAX_RECALL_DAYS = 16;
-    SHORT_TERM_STORE_RELATIVE_PATH = path41.join("memory", ".dreams", "short-term-recall.json");
-    SHORT_TERM_PHASE_SIGNAL_RELATIVE_PATH = path41.join("memory", ".dreams", "phase-signals.json");
-    SHORT_TERM_LOCK_RELATIVE_PATH = path41.join("memory", ".dreams", "short-term-promotion.lock");
+    SHORT_TERM_STORE_RELATIVE_PATH = path42.join("memory", ".dreams", "short-term-recall.json");
+    SHORT_TERM_PHASE_SIGNAL_RELATIVE_PATH = path42.join("memory", ".dreams", "phase-signals.json");
+    SHORT_TERM_LOCK_RELATIVE_PATH = path42.join("memory", ".dreams", "short-term-promotion.lock");
     SHORT_TERM_LOCK_WAIT_TIMEOUT_MS = 1e4;
     SHORT_TERM_LOCK_STALE_MS = 6e4;
     SHORT_TERM_LOCK_RETRY_DELAY_MS = 40;
@@ -20089,9 +20089,9 @@ var init_string_utils = __esm({
 });
 
 // src/memory/host/config-utils.ts
-import fs41 from "node:fs";
+import fs42 from "node:fs";
 import os4 from "node:os";
-import path42 from "node:path";
+import path43 from "node:path";
 function normalizeAgentId(value) {
   const trimmed = (value ?? "").trim();
   if (!trimmed) {
@@ -20116,7 +20116,7 @@ function resolveRawOsHomeDir(env, homedir2) {
 function resolveRequiredHomeDir(env = process.env, homedir2 = os4.homedir) {
   const explicitHome = normalizeHomeValue(env.OPENCLAW_HOME);
   const rawHome = explicitHome ? explicitHome.replace(/^~(?=$|[\\/])/, resolveRawOsHomeDir(env, homedir2) ?? "") : resolveRawOsHomeDir(env, homedir2);
-  return rawHome ? path42.resolve(rawHome) : path42.resolve(process.cwd());
+  return rawHome ? path43.resolve(rawHome) : path43.resolve(process.cwd());
 }
 function resolveUserPath2(input, env = process.env, homedir2 = os4.homedir) {
   const trimmed = input.trim();
@@ -20124,12 +20124,12 @@ function resolveUserPath2(input, env = process.env, homedir2 = os4.homedir) {
     return trimmed;
   }
   if (trimmed.startsWith("~")) {
-    return path42.resolve(trimmed.replace(/^~(?=$|[\\/])/, resolveRequiredHomeDir(env, homedir2)));
+    return path43.resolve(trimmed.replace(/^~(?=$|[\\/])/, resolveRequiredHomeDir(env, homedir2)));
   }
-  return path42.resolve(trimmed);
+  return path43.resolve(trimmed);
 }
 function legacyStateDirs(homedir2) {
-  return LEGACY_STATE_DIRNAMES.map((dir) => path42.join(homedir2(), dir));
+  return LEGACY_STATE_DIRNAMES.map((dir) => path43.join(homedir2(), dir));
 }
 function resolveStateDir2(env = process.env, homedir2 = os4.homedir) {
   const override = env.OPENCLAW_STATE_DIR?.trim();
@@ -20137,13 +20137,13 @@ function resolveStateDir2(env = process.env, homedir2 = os4.homedir) {
     return resolveUserPath2(override, env, homedir2);
   }
   const effectiveHome = () => resolveRequiredHomeDir(env, homedir2);
-  const nextDir = path42.join(effectiveHome(), NEW_STATE_DIRNAME);
-  if (env.OPENCLAW_TEST_FAST === "1" || fs41.existsSync(nextDir)) {
+  const nextDir = path43.join(effectiveHome(), NEW_STATE_DIRNAME);
+  if (env.OPENCLAW_TEST_FAST === "1" || fs42.existsSync(nextDir)) {
     return nextDir;
   }
   const existingLegacy = legacyStateDirs(effectiveHome).find((dir) => {
     try {
-      return fs41.existsSync(dir);
+      return fs42.existsSync(dir);
     } catch {
       return false;
     }
@@ -20154,9 +20154,9 @@ function resolveDefaultAgentWorkspaceDir(env = process.env) {
   const home = resolveRequiredHomeDir(env, os4.homedir);
   const profile = env.OPENCLAW_PROFILE?.trim();
   if (profile && normalizeLowercaseStringOrEmpty2(profile) !== "default") {
-    return path42.join(home, ".openclaw", `workspace-${profile}`);
+    return path43.join(home, ".openclaw", `workspace-${profile}`);
   }
-  return path42.join(home, ".openclaw", "workspace");
+  return path43.join(home, ".openclaw", "workspace");
 }
 function listAgentEntries(cfg) {
   return Array.isArray(cfg.agents?.list) ? cfg.agents.list.filter((entry) => Boolean(entry)) : [];
@@ -20189,9 +20189,9 @@ function resolveAgentWorkspaceDir2(cfg, agentId, env = process.env) {
     );
   }
   if (fallback) {
-    return stripNullBytes(path42.join(resolveUserPath2(fallback, env), id));
+    return stripNullBytes(path43.join(resolveUserPath2(fallback, env), id));
   }
-  return stripNullBytes(path42.join(resolveStateDir2(env), `workspace-${id}`));
+  return stripNullBytes(path43.join(resolveStateDir2(env), `workspace-${id}`));
 }
 function resolveAgentContextLimits2(cfg, agentId) {
   const defaults = cfg?.agents?.defaults?.contextLimits;
@@ -20277,12 +20277,12 @@ var init_config4 = __esm({
 });
 
 // src/memory/shims/fs-safe/root.ts
-import path43 from "node:path";
+import path44 from "node:path";
 function root(...segments) {
-  const basePath = path43.resolve(...segments);
+  const basePath = path44.resolve(...segments);
   return {
     resolve(relPath) {
-      return Promise.resolve(path43.resolve(basePath, relPath));
+      return Promise.resolve(path44.resolve(basePath, relPath));
     }
   };
 }
@@ -20293,10 +20293,10 @@ var init_root = __esm({
 });
 
 // src/memory/shims/fs-safe/path.ts
-import path44 from "node:path";
+import path45 from "node:path";
 function isPathInside(childPath, parentPath) {
-  const relative4 = path44.relative(parentPath, childPath);
-  return !relative4.startsWith("..") && !path44.isAbsolute(relative4);
+  const relative4 = path45.relative(parentPath, childPath);
+  return !relative4.startsWith("..") && !path45.isAbsolute(relative4);
 }
 function isPathInsideWithRealpath(childPath, parentPath) {
   try {
@@ -20312,12 +20312,12 @@ var init_path2 = __esm({
 });
 
 // src/memory/shims/fs-safe/advanced.ts
-import fs42 from "node:fs";
+import fs43 from "node:fs";
 function readRegularFile(filePathOrOptions) {
   const filePath = typeof filePathOrOptions === "string" ? filePathOrOptions : filePathOrOptions.filePath;
   const maxBytes = typeof filePathOrOptions === "string" ? void 0 : filePathOrOptions.maxBytes;
   try {
-    const buf = fs42.readFileSync(filePath);
+    const buf = fs43.readFileSync(filePath);
     if (maxBytes && buf.length > maxBytes) {
       return { buffer: buf.subarray(0, maxBytes) };
     }
@@ -20328,7 +20328,7 @@ function readRegularFile(filePathOrOptions) {
 }
 function statRegularFile(filePath) {
   try {
-    const stat8 = fs42.statSync(filePath);
+    const stat8 = fs43.statSync(filePath);
     if (!stat8.isFile()) return { missing: true };
     return { missing: false, stat: { size: stat8.size, mtimeMs: stat8.mtimeMs } };
   } catch {
@@ -20344,22 +20344,22 @@ var init_advanced = __esm({
 });
 
 // src/memory/shims/fs-safe/walk.ts
-import fs43 from "node:fs";
-import path45 from "node:path";
+import fs44 from "node:fs";
+import path46 from "node:path";
 async function walkDirectory(dir, options) {
   const entries = [];
   async function walk(d) {
-    if (!fs43.existsSync(d)) return;
+    if (!fs44.existsSync(d)) return;
     let dirents;
     try {
-      dirents = fs43.readdirSync(d, { withFileTypes: true });
+      dirents = fs44.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const dirent of dirents) {
       const kind = dirent.isDirectory() ? "directory" : "file";
       const entry = {
-        path: path45.join(d, dirent.name),
+        path: path46.join(d, dirent.name),
         name: dirent.name,
         kind
       };
@@ -20516,8 +20516,8 @@ var init_hash2 = __esm({
 // src/memory/host/internal.ts
 import crypto8 from "node:crypto";
 import fsSync from "node:fs";
-import fs44 from "node:fs/promises";
-import path46 from "node:path";
+import fs45 from "node:fs/promises";
+import path47 from "node:path";
 function ensureDir(dir) {
   try {
     fsSync.mkdirSync(dir, { recursive: true });
@@ -20535,7 +20535,7 @@ function normalizeExtraMemoryPaths(_baseDir, extraPaths) {
   }
   const stateDir = process.env.ENGINE_STATE_DIR || process.cwd();
   const resolved = extraPaths.map((value) => value.trim()).filter(Boolean).map(
-    (value) => path46.isAbsolute(value) ? path46.resolve(value) : path46.resolve(stateDir, value)
+    (value) => path47.isAbsolute(value) ? path47.resolve(value) : path47.resolve(stateDir, value)
   );
   return Array.from(new Set(resolved));
 }
@@ -20571,7 +20571,7 @@ async function collectMemoryFilesFromDir(dir, files, multimodal, shouldSkipPath)
 }
 async function listMemoryFiles(workspaceDir, extraPaths, multimodal) {
   const result = [];
-  const memoryDir = path46.join(workspaceDir, "memory");
+  const memoryDir = path47.join(workspaceDir, "memory");
   const shouldSkipWorkspaceMemoryPath = (absPath) => shouldSkipRootMemoryAuxiliaryPath({ workspaceDir, absPath });
   const addMarkdownFile = async (absPath) => {
     try {
@@ -20591,7 +20591,7 @@ async function listMemoryFiles(workspaceDir, extraPaths, multimodal) {
     await addMarkdownFile(memoryFile);
   }
   try {
-    const dirStat = await fs44.lstat(memoryDir);
+    const dirStat = await fs45.lstat(memoryDir);
     if (!dirStat.isSymbolicLink() && dirStat.isDirectory()) {
       await collectMemoryFilesFromDir(memoryDir, result, multimodal, shouldSkipWorkspaceMemoryPath);
     }
@@ -20604,7 +20604,7 @@ async function listMemoryFiles(workspaceDir, extraPaths, multimodal) {
         continue;
       }
       try {
-        const stat8 = await fs44.lstat(inputPath);
+        const stat8 = await fs45.lstat(inputPath);
         if (stat8.isSymbolicLink()) {
           continue;
         }
@@ -20632,7 +20632,7 @@ async function listMemoryFiles(workspaceDir, extraPaths, multimodal) {
   for (const entry of result) {
     let key = entry;
     try {
-      key = await fs44.realpath(entry);
+      key = await fs45.realpath(entry);
     } catch {
     }
     if (seen.has(key)) {
@@ -20649,7 +20649,7 @@ async function buildFileEntry(absPath, workspaceDir, multimodal) {
     return null;
   }
   const stat8 = regularFile.stat;
-  const normalizedPath = path46.relative(workspaceDir, absPath).replace(/\\/g, "/");
+  const normalizedPath = path47.relative(workspaceDir, absPath).replace(/\\/g, "/");
   const multimodalSettings = multimodal ?? DISABLED_MULTIMODAL_SETTINGS;
   const modality = classifyMemoryMultimodalPath(absPath, multimodalSettings);
   if (modality) {
@@ -21012,8 +21012,8 @@ __export(read_file_exports, {
   readAgentMemoryFile: () => readAgentMemoryFile,
   readMemoryFile: () => readMemoryFile
 });
-import fs45 from "node:fs/promises";
-import path47 from "node:path";
+import fs46 from "node:fs/promises";
+import path48 from "node:path";
 async function isAllowedAdditionalDirectoryPath(additionalPath, absPath) {
   if (!isPathInside(additionalPath, absPath)) {
     return false;
@@ -21025,7 +21025,7 @@ async function isAllowedAdditionalDirectoryPath(additionalPath, absPath) {
   }
   if (!isPathInsideWithRealpath(additionalPath, absPath)) {
     try {
-      await fs45.lstat(absPath);
+      await fs46.lstat(absPath);
     } catch (err) {
       return isFileMissingError(err);
     }
@@ -21038,22 +21038,22 @@ async function readMemoryFile(params) {
   if (!rawPath) {
     throw new Error("path required");
   }
-  const absPath = path47.isAbsolute(rawPath) ? path47.resolve(rawPath) : path47.resolve(params.workspaceDir, rawPath);
-  const relPath = path47.relative(params.workspaceDir, absPath).replace(/\\/g, "/");
-  const inWorkspace = relPath.length > 0 && !relPath.startsWith("..") && !path47.isAbsolute(relPath);
+  const absPath = path48.isAbsolute(rawPath) ? path48.resolve(rawPath) : path48.resolve(params.workspaceDir, rawPath);
+  const relPath = path48.relative(params.workspaceDir, absPath).replace(/\\/g, "/");
+  const inWorkspace = relPath.length > 0 && !relPath.startsWith("..") && !path48.isAbsolute(relPath);
   const allowedWorkspace = inWorkspace && isMemoryPath(relPath);
   let allowedAdditional = false;
   if (!allowedWorkspace && (params.extraPaths?.length ?? 0) > 0) {
     const additionalPaths = normalizeExtraMemoryPaths(params.workspaceDir, params.extraPaths);
     for (const additionalPath of additionalPaths) {
       try {
-        const stat8 = await fs45.lstat(additionalPath);
+        const stat8 = await fs46.lstat(additionalPath);
         if (stat8.isSymbolicLink()) {
           continue;
         }
         if (stat8.isDirectory()) {
           if (await isAllowedAdditionalDirectoryPath(additionalPath, absPath)) {
-            const candidateStat = await fs45.lstat(absPath).catch(() => null);
+            const candidateStat = await fs46.lstat(absPath).catch(() => null);
             if (candidateStat?.isSymbolicLink()) {
               continue;
             }
@@ -21523,8 +21523,8 @@ var init_memory_core_host_runtime_files = __esm({
 });
 
 // src/memory/shims/memory-core-host-engine-qmd.ts
-import * as path48 from "path";
-import * as fs46 from "fs/promises";
+import * as path49 from "path";
+import * as fs47 from "fs/promises";
 import { createHash as createHash3 } from "crypto";
 function extractKeywords(query) {
   return [...new Set(
@@ -21536,8 +21536,8 @@ async function checkQmdBinaryAvailability() {
 }
 async function buildSessionEntry(filePath) {
   try {
-    const stat8 = await fs46.stat(filePath);
-    const raw = await fs46.readFile(filePath, "utf-8");
+    const stat8 = await fs47.stat(filePath);
+    const raw = await fs47.readFile(filePath, "utf-8");
     const contentParts = [];
     if (filePath.endsWith(".json")) {
       try {
@@ -21612,13 +21612,13 @@ function isUsageCountedSessionTranscriptFileName(_name) {
 async function listSessionFilesForAgent(params) {
   try {
     const sessionsDir = resolveSessionTranscriptsDirForAgent({ agentId: params.agentId ?? "main" });
-    const entries = await fs46.readdir(sessionsDir);
-    const sessionFiles = entries.filter((name) => name.includes(".jsonl") || name.startsWith("session_") && name.endsWith(".json")).map((name) => path48.join(sessionsDir, name));
+    const entries = await fs47.readdir(sessionsDir);
+    const sessionFiles = entries.filter((name) => name.includes(".jsonl") || name.startsWith("session_") && name.endsWith(".json")).map((name) => path49.join(sessionsDir, name));
     console.log(`[memory-sync] listSessionFilesForAgent: found ${sessionFiles.length} files in ${sessionsDir}`);
-    const archiveDir = path48.join(sessionsDir, "archive");
+    const archiveDir = path49.join(sessionsDir, "archive");
     try {
-      const archiveEntries = await fs46.readdir(archiveDir);
-      const archiveFiles = archiveEntries.filter((name) => name.endsWith(".jsonl") || name.endsWith(".json")).map((name) => path48.join(archiveDir, name));
+      const archiveEntries = await fs47.readdir(archiveDir);
+      const archiveFiles = archiveEntries.filter((name) => name.endsWith(".jsonl") || name.endsWith(".json")).map((name) => path49.join(archiveDir, name));
       if (archiveFiles.length > 0) {
         console.log(`[memory-sync] listSessionFilesForAgent: found ${archiveFiles.length} files in ${archiveDir}`);
         sessionFiles.push(...archiveFiles);
@@ -21627,10 +21627,10 @@ async function listSessionFilesForAgent(params) {
     }
     const legacyDir = params.legacySessionsDir;
     if (legacyDir) {
-      const absLegacyDir = path48.isAbsolute(legacyDir) ? legacyDir : path48.join(resolveStateDir(), legacyDir);
+      const absLegacyDir = path49.isAbsolute(legacyDir) ? legacyDir : path49.join(resolveStateDir(), legacyDir);
       try {
-        const legacyEntries = await fs46.readdir(absLegacyDir);
-        const legacyFiles = legacyEntries.filter((name) => name.endsWith(".jsonl") || name.startsWith("session_") && name.endsWith(".json")).map((name) => path48.join(absLegacyDir, name));
+        const legacyEntries = await fs47.readdir(absLegacyDir);
+        const legacyFiles = legacyEntries.filter((name) => name.endsWith(".jsonl") || name.startsWith("session_") && name.endsWith(".json")).map((name) => path49.join(absLegacyDir, name));
         if (legacyFiles.length > 0) {
           console.log(`[memory-sync] listSessionFilesForAgent: found ${legacyFiles.length} files in ${absLegacyDir}`);
           sessionFiles.push(...legacyFiles);
@@ -22072,8 +22072,8 @@ var init_mmr = __esm({
 });
 
 // src/memory/tools/memory/temporal-decay.ts
-import fs47 from "node:fs/promises";
-import path49 from "node:path";
+import fs48 from "node:fs/promises";
+import path50 from "node:path";
 function toDecayLambda(halfLifeDays) {
   if (!Number.isFinite(halfLifeDays) || halfLifeDays <= 0) {
     return 0;
@@ -22131,9 +22131,9 @@ async function extractTimestamp(params) {
   if (!params.workspaceDir) {
     return null;
   }
-  const absolutePath = path49.isAbsolute(params.filePath) ? params.filePath : path49.resolve(params.workspaceDir, params.filePath);
+  const absolutePath = path50.isAbsolute(params.filePath) ? params.filePath : path50.resolve(params.workspaceDir, params.filePath);
   try {
-    const stat8 = await fs47.stat(absolutePath);
+    const stat8 = await fs48.stat(absolutePath);
     if (!Number.isFinite(stat8.mtimeMs)) {
       return null;
     }
@@ -22396,9 +22396,9 @@ var init_manager_cache = __esm({
 });
 
 // src/memory/tools/memory/manager-db.ts
-import path50 from "node:path";
+import path51 from "node:path";
 function openMemoryDatabaseAtPath(dbPath, allowExtension) {
-  const dir = path50.dirname(dbPath);
+  const dir = path51.dirname(dbPath);
   ensureDir(dir);
   const { DatabaseSync: DatabaseSync2 } = requireNodeSqlite();
   const db = new DatabaseSync2(dbPath, { allowExtension });
@@ -22703,7 +22703,7 @@ var init_readdirp = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? lstat : stat5;
         if (wantBigintFsStats) {
-          this._stat = (path55) => statMethod(path55, { bigint: true });
+          this._stat = (path56) => statMethod(path56, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -22728,8 +22728,8 @@ var init_readdirp = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path55, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path55));
+              const { path: path56, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path56));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -22769,20 +22769,20 @@ var init_readdirp = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path55, depth) {
+      async _exploreDir(path56, depth) {
         let files;
         try {
-          files = await readdir3(path55, this._rdOptions);
+          files = await readdir3(path56, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path55 };
+        return { files, depth, path: path56 };
       }
-      async _formatEntry(dirent, path55) {
+      async _formatEntry(dirent, path56) {
         let entry;
         const basename9 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = presolve(pjoin(path55, basename9));
+          const fullPath = presolve(pjoin(path56, basename9));
           entry = { path: prelative(this._root, fullPath), fullPath, basename: basename9 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -22843,16 +22843,16 @@ import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
 import { realpath as fsrealpath, lstat as lstat2, open, stat as stat6 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp from "node:path";
-function createFsWatchInstance(path55, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path56, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path55);
-    emitRaw(rawEvent, evPath, { watchedPath: path55 });
-    if (evPath && path55 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path55, evPath), KEY_LISTENERS, sp.join(path55, evPath));
+    listener(path56);
+    emitRaw(rawEvent, evPath, { watchedPath: path56 });
+    if (evPath && path56 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path56, evPath), KEY_LISTENERS, sp.join(path56, evPath));
     }
   };
   try {
-    return fs_watch(path55, {
+    return fs_watch(path56, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -23196,12 +23196,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path55, fullPath, options, handlers) => {
+    setFsWatchListener = (path56, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path55, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path56, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -23212,7 +23212,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path55,
+          path56,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -23227,7 +23227,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error.code === "EPERM") {
             try {
-              const fd = await open(path55, "r");
+              const fd = await open(path56, "r");
               await fd.close();
               broadcastErr(error);
             } catch (err) {
@@ -23258,7 +23258,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path55, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path56, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -23280,7 +23280,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path55, curr));
+              foreach(cont.listeners, (listener2) => listener2(path56, curr));
             }
           })
         };
@@ -23310,13 +23310,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path55, listener) {
+      _watchWithNodeFs(path56, listener) {
         const opts = this.fsw.options;
-        const directory = sp.dirname(path55);
-        const basename9 = sp.basename(path55);
+        const directory = sp.dirname(path56);
+        const basename9 = sp.basename(path56);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename9);
-        const absolutePath = sp.resolve(path55);
+        const absolutePath = sp.resolve(path56);
         const options = {
           persistent: opts.persistent
         };
@@ -23326,12 +23326,12 @@ var init_handler = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path55, absolutePath, options, {
+          closer = setFsWatchFileListener(path56, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path55, absolutePath, options, {
+          closer = setFsWatchListener(path56, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -23353,7 +23353,7 @@ var init_handler = __esm({
         let prevStats = stats2;
         if (parent.has(basename9))
           return;
-        const listener = async (path55, newStats) => {
+        const listener = async (path56, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -23367,11 +23367,11 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path55);
+                this.fsw._closeFile(path56);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path55, closer2);
+                  this.fsw._addPathCloser(path56, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -23403,7 +23403,7 @@ var init_handler = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path55, item) {
+      async _handleSymlink(entry, directory, path56, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -23413,7 +23413,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await fsrealpath(path55);
+            linkPath = await fsrealpath(path56);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -23423,12 +23423,12 @@ var init_handler = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path55, entry.stats);
+              this.fsw._emit(EV.CHANGE, path56, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path55, entry.stats);
+            this.fsw._emit(EV.ADD, path56, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -23458,9 +23458,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path55 = sp.join(directory, item);
+          let path56 = sp.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path55, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path56, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -23469,8 +23469,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path55 = sp.join(dir, sp.relative(dir, path55));
-            this._addToNodeFs(path55, initialAdd, wh, depth + 1);
+            path56 = sp.join(dir, sp.relative(dir, path56));
+            this._addToNodeFs(path56, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve12, reject) => {
@@ -23539,13 +23539,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path55, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path56, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path55) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path56) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path55);
+        const wh = this.fsw._getWatchHelpers(path56);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -23561,8 +23561,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats2.isDirectory()) {
-            const absPath = sp.resolve(path55);
-            const targetPath = follow ? await fsrealpath(path55) : path55;
+            const absPath = sp.resolve(path56);
+            const targetPath = follow ? await fsrealpath(path56) : path56;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats2, initialAdd, depth, target, wh, targetPath);
@@ -23572,29 +23572,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats2.isSymbolicLink()) {
-            const targetPath = follow ? await fsrealpath(path55) : path55;
+            const targetPath = follow ? await fsrealpath(path56) : path56;
             if (this.fsw.closed)
               return;
             const parent = sp.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats2);
-            closer = await this._handleDir(parent, stats2, initialAdd, depth, path55, wh, targetPath);
+            closer = await this._handleDir(parent, stats2, initialAdd, depth, path56, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sp.resolve(path55), targetPath);
+              this.fsw._symlinkPaths.set(sp.resolve(path56), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats2, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path55, closer);
+            this.fsw._addPathCloser(path56, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path55;
+            return path56;
           }
         }
       }
@@ -23633,24 +23633,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path55) {
-  if (typeof path55 !== "string")
+function normalizePath2(path56) {
+  if (typeof path56 !== "string")
     throw new Error("string expected");
-  path55 = sp2.normalize(path55);
-  path55 = path55.replace(/\\/g, "/");
+  path56 = sp2.normalize(path56);
+  path56 = path56.replace(/\\/g, "/");
   let prepend = false;
-  if (path55.startsWith("//"))
+  if (path56.startsWith("//"))
     prepend = true;
-  path55 = path55.replace(DOUBLE_SLASH_RE, "/");
+  path56 = path56.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path55 = "/" + path55;
-  return path55;
+    path56 = "/" + path56;
+  return path56;
 }
 function matchPatterns(patterns, testString, stats2) {
-  const path55 = normalizePath2(testString);
+  const path56 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path55, stats2)) {
+    if (pattern(path56, stats2)) {
       return true;
     }
   }
@@ -23708,19 +23708,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path55) => toUnix(sp2.normalize(toUnix(path55)));
-    normalizeIgnored = (cwd = "") => (path55) => {
-      if (typeof path55 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path55) ? path55 : sp2.join(cwd, path55));
+    normalizePathToUnix = (path56) => toUnix(sp2.normalize(toUnix(path56)));
+    normalizeIgnored = (cwd = "") => (path56) => {
+      if (typeof path56 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path56) ? path56 : sp2.join(cwd, path56));
       } else {
-        return path55;
+        return path56;
       }
     };
-    getAbsolutePath = (path55, cwd) => {
-      if (sp2.isAbsolute(path55)) {
-        return path55;
+    getAbsolutePath = (path56, cwd) => {
+      if (sp2.isAbsolute(path56)) {
+        return path56;
       }
-      return sp2.join(cwd, path55);
+      return sp2.join(cwd, path56);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -23785,10 +23785,10 @@ var init_chokidar = __esm({
       dirParts;
       followSymlinks;
       statMethod;
-      constructor(path55, follow, fsw) {
+      constructor(path56, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path55;
-        this.path = path55 = path55.replace(REPLACER_RE, "");
+        const watchPath = path56;
+        this.path = path56 = path56.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sp2.resolve(watchPath);
         this.dirParts = [];
@@ -23928,20 +23928,20 @@ var init_chokidar = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path55) => {
-            const absPath = getAbsolutePath(path55, cwd);
+          paths = paths.map((path56) => {
+            const absPath = getAbsolutePath(path56, cwd);
             return absPath;
           });
         }
-        paths.forEach((path55) => {
-          this._removeIgnoredPath(path55);
+        paths.forEach((path56) => {
+          this._removeIgnoredPath(path56);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path55) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path55, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path56) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path56, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -23963,17 +23963,17 @@ var init_chokidar = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path55) => {
-          if (!sp2.isAbsolute(path55) && !this._closers.has(path55)) {
+        paths.forEach((path56) => {
+          if (!sp2.isAbsolute(path56) && !this._closers.has(path56)) {
             if (cwd)
-              path55 = sp2.join(cwd, path55);
-            path55 = sp2.resolve(path55);
+              path56 = sp2.join(cwd, path56);
+            path56 = sp2.resolve(path56);
           }
-          this._closePath(path55);
-          this._addIgnoredPath(path55);
-          if (this._watched.has(path55)) {
+          this._closePath(path56);
+          this._addIgnoredPath(path56);
+          if (this._watched.has(path56)) {
             this._addIgnoredPath({
-              path: path55,
+              path: path56,
               recursive: true
             });
           }
@@ -24037,38 +24037,38 @@ var init_chokidar = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path55, stats2) {
+      async _emit(event, path56, stats2) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path55 = sp2.normalize(path55);
+          path56 = sp2.normalize(path56);
         if (opts.cwd)
-          path55 = sp2.relative(opts.cwd, path55);
-        const args2 = [path55];
+          path56 = sp2.relative(opts.cwd, path56);
+        const args2 = [path56];
         if (stats2 != null)
           args2.push(stats2);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path55))) {
+        if (awf && (pw = this._pendingWrites.get(path56))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path55, [event, ...args2]);
+            this._pendingUnlinks.set(path56, [event, ...args2]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path56) => {
+              this._pendingUnlinks.forEach((entry, path57) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path56);
+                this._pendingUnlinks.delete(path57);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path55)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path56)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path55);
+            this._pendingUnlinks.delete(path56);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -24086,16 +24086,16 @@ var init_chokidar = __esm({
               this.emitWithAll(event, args2);
             }
           };
-          this._awaitWriteFinish(path55, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path56, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path55, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path56, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats2 === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sp2.join(opts.cwd, path55) : path55;
+          const fullPath = opts.cwd ? sp2.join(opts.cwd, path56) : path56;
           let stats3;
           try {
             stats3 = await stat7(fullPath);
@@ -24126,23 +24126,23 @@ var init_chokidar = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path55, timeout) {
+      _throttle(actionType, path56, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path55);
+        const actionPath = action.get(path56);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path55);
+          const item = action.get(path56);
           const count = item ? item.count : 0;
-          action.delete(path55);
+          action.delete(path56);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -24150,7 +24150,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path55, thr);
+        action.set(path56, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -24164,44 +24164,44 @@ var init_chokidar = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path55, threshold, event, awfEmit) {
+      _awaitWriteFinish(path56, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path55;
-        if (this.options.cwd && !sp2.isAbsolute(path55)) {
-          fullPath = sp2.join(this.options.cwd, path55);
+        let fullPath = path56;
+        if (this.options.cwd && !sp2.isAbsolute(path56)) {
+          fullPath = sp2.join(this.options.cwd, path56);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           statcb(fullPath, (err, curStat) => {
-            if (err || !writes.has(path55)) {
+            if (err || !writes.has(path56)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path55).lastChange = now2;
+              writes.get(path56).lastChange = now2;
             }
-            const pw = writes.get(path55);
+            const pw = writes.get(path56);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path55);
+              writes.delete(path56);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path55)) {
-          writes.set(path55, {
+        if (!writes.has(path56)) {
+          writes.set(path56, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path55);
+              writes.delete(path56);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -24212,8 +24212,8 @@ var init_chokidar = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path55, stats2) {
-        if (this.options.atomic && DOT_RE.test(path55))
+      _isIgnored(path56, stats2) {
+        if (this.options.atomic && DOT_RE.test(path56))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -24223,17 +24223,17 @@ var init_chokidar = __esm({
           const list2 = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list2, void 0);
         }
-        return this._userIgnored(path55, stats2);
+        return this._userIgnored(path56, stats2);
       }
-      _isntIgnored(path55, stat8) {
-        return !this._isIgnored(path55, stat8);
+      _isntIgnored(path56, stat8) {
+        return !this._isIgnored(path56, stat8);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path55) {
-        return new WatchHelper(path55, this.options.followSymlinks, this);
+      _getWatchHelpers(path56) {
+        return new WatchHelper(path56, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -24265,63 +24265,63 @@ var init_chokidar = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path55 = sp2.join(directory, item);
-        const fullPath = sp2.resolve(path55);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path55) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path55, 100))
+        const path56 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path56);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path56) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path56, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path55);
+        const wp = this._getWatchedDir(path56);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path55, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path56, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path55;
+        let relPath = path56;
         if (this.options.cwd)
-          relPath = sp2.relative(this.options.cwd, path55);
+          relPath = sp2.relative(this.options.cwd, path56);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path55);
+        this._watched.delete(path56);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path55))
-          this._emit(eventName, path55);
-        this._closePath(path55);
+        if (wasTracked && !this._isIgnored(path56))
+          this._emit(eventName, path56);
+        this._closePath(path56);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path55) {
-        this._closeFile(path55);
-        const dir = sp2.dirname(path55);
-        this._getWatchedDir(dir).remove(sp2.basename(path55));
+      _closePath(path56) {
+        this._closeFile(path56);
+        const dir = sp2.dirname(path56);
+        this._getWatchedDir(dir).remove(sp2.basename(path56));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path55) {
-        const closers = this._closers.get(path55);
+      _closeFile(path56) {
+        const closers = this._closers.get(path56);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path55);
+        this._closers.delete(path56);
       }
-      _addPathCloser(path55, closer) {
+      _addPathCloser(path56, closer) {
         if (!closer)
           return;
-        let list2 = this._closers.get(path55);
+        let list2 = this._closers.get(path56);
         if (!list2) {
           list2 = [];
-          this._closers.set(path55, list2);
+          this._closers.set(path56, list2);
         }
         list2.push(closer);
       }
@@ -24349,7 +24349,7 @@ var init_chokidar = __esm({
 
 // src/memory/tools/memory/manager-atomic-reindex.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import fs48 from "node:fs/promises";
+import fs49 from "node:fs/promises";
 import { setTimeout as sleep6 } from "node:timers/promises";
 function isTransientFileError(err) {
   return transientFileErrorCodes.has(err.code ?? "");
@@ -24389,10 +24389,10 @@ async function moveMemoryIndexFiles(sourceBase, targetBase, options = {}) {
     await renameWithRetry(source, target, resolvedOptions);
   }
 }
-async function rmWithRetry(path55, options) {
+async function rmWithRetry(path56, options) {
   for (let attempt = 1; attempt <= options.maxRemoveAttempts; attempt++) {
     try {
-      await options.fileOps.rm(path55, { force: true });
+      await options.fileOps.rm(path56, { force: true });
       return;
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -24449,8 +24449,8 @@ var init_manager_atomic_reindex = __esm({
   "src/memory/tools/memory/manager-atomic-reindex.ts"() {
     "use strict";
     defaultFileOps = {
-      rename: fs48.rename,
-      rm: fs48.rm,
+      rename: fs49.rename,
+      rm: fs49.rm,
       wait: sleep6
     };
     transientFileErrorCodes = /* @__PURE__ */ new Set(["EBUSY", "EPERM", "EACCES"]);
@@ -24732,8 +24732,8 @@ var init_watch_settle = __esm({
 // src/memory/tools/memory/manager-sync-ops.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
 import fsSync3 from "node:fs";
-import fs49 from "node:fs/promises";
-import path51 from "node:path";
+import fs50 from "node:fs/promises";
+import path52 from "node:path";
 function isSyncDisabled(cfg) {
   try {
     const searchCfg = cfg?.agents?.defaults?.memorySearch;
@@ -24752,8 +24752,8 @@ function resolveMemoryWatchFactory() {
   return chokidar_default.watch.bind(chokidar_default);
 }
 function shouldIgnoreMemoryWatchPath(watchPath, stats2, multimodalSettings) {
-  const normalized = path51.normalize(watchPath);
-  const parts = normalized.split(path51.sep).map((segment) => normalizeLowercaseStringOrEmpty(segment));
+  const normalized = path52.normalize(watchPath);
+  const parts = normalized.split(path52.sep).map((segment) => normalizeLowercaseStringOrEmpty(segment));
   if (parts.some((segment) => IGNORED_MEMORY_WATCH_DIR_NAMES.has(segment))) {
     return true;
   }
@@ -24763,7 +24763,7 @@ function shouldIgnoreMemoryWatchPath(watchPath, stats2, multimodalSettings) {
   if (!stats2) {
     return false;
   }
-  const extension = normalizeLowercaseStringOrEmpty(path51.extname(normalized));
+  const extension = normalizeLowercaseStringOrEmpty(path52.extname(normalized));
   if (extension.length === 0 || extension === ".md") {
     return false;
   }
@@ -25028,8 +25028,8 @@ var init_manager_sync_ops = __esm({
           return;
         }
         const watchPaths = /* @__PURE__ */ new Set([
-          path51.join(this.workspaceDir, "MEMORY.md"),
-          path51.join(this.workspaceDir, "memory")
+          path52.join(this.workspaceDir, "MEMORY.md"),
+          path52.join(this.workspaceDir, "memory")
         ]);
         const additionalPaths = normalizeExtraMemoryPaths(this.workspaceDir, this.settings.extraPaths);
         for (const entry of additionalPaths) {
@@ -25120,7 +25120,7 @@ var init_manager_sync_ops = __esm({
         const fileStates = (await runWithConcurrency(
           files.map((file) => async () => {
             try {
-              const stat8 = await fs49.stat(file);
+              const stat8 = await fs50.stat(file);
               if (!stat8.isFile()) {
                 return null;
               }
@@ -25179,7 +25179,7 @@ var init_manager_sync_ops = __esm({
         this.sessionPendingFiles.clear();
         let shouldSync = false;
         for (const sessionFile of pending2) {
-          const baseName = path51.basename(sessionFile);
+          const baseName = path52.basename(sessionFile);
           if (isSessionArchiveArtifactName(baseName) && isUsageCountedSessionTranscriptFileName(baseName)) {
             this.sessionsDirtyFiles.add(sessionFile);
             this.sessionsDirty = true;
@@ -25216,7 +25216,7 @@ var init_manager_sync_ops = __esm({
         }
         let stat8;
         try {
-          stat8 = await fs49.stat(sessionFile);
+          stat8 = await fs50.stat(sessionFile);
         } catch {
           return null;
         }
@@ -25264,7 +25264,7 @@ var init_manager_sync_ops = __esm({
         }
         let handle;
         try {
-          handle = await fs49.open(absPath, "r");
+          handle = await fs50.open(absPath, "r");
         } catch (err) {
           if (isFileMissingError(err)) {
             return 0;
@@ -25307,9 +25307,9 @@ var init_manager_sync_ops = __esm({
           return false;
         }
         const sessionsDir = resolveSessionTranscriptsDirForAgent({ agentId: this.agentId });
-        const resolvedFile = path51.resolve(sessionFile);
-        const resolvedDir = path51.resolve(sessionsDir);
-        return resolvedFile.startsWith(`${resolvedDir}${path51.sep}`);
+        const resolvedFile = path52.resolve(sessionFile);
+        const resolvedDir = path52.resolve(sessionsDir);
+        return resolvedFile.startsWith(`${resolvedDir}${path52.sep}`);
       }
       normalizeTargetSessionFiles(sessionFiles) {
         if (!sessionFiles || sessionFiles.length === 0) {
@@ -25321,7 +25321,7 @@ var init_manager_sync_ops = __esm({
           if (!trimmed) {
             continue;
           }
-          const resolved = path51.resolve(trimmed);
+          const resolved = path52.resolve(trimmed);
           if (this.isSessionFileForAgent(resolved)) {
             normalized.add(resolved);
           }
@@ -25968,7 +25968,7 @@ var init_manager_vector_write = __esm({
 });
 
 // src/memory/tools/memory/manager-embedding-ops.ts
-import fs50 from "node:fs/promises";
+import fs51 from "node:fs/promises";
 function resolveEmbeddingTimeoutMs(params) {
   if (params.kind === "query") {
     const runtimeTimeoutMs2 = params.providerRuntime?.inlineQueryTimeoutMs;
@@ -26509,7 +26509,7 @@ var init_manager_embedding_ops = __esm({
           if ("kind" in entry && entry.kind === "multimodal") {
             return;
           }
-          const content = options.content ?? await fs50.readFile(entry.absPath, "utf-8");
+          const content = options.content ?? await fs51.readFile(entry.absPath, "utf-8");
           const chunks2 = filterNonEmptyMemoryChunks(chunkMarkdown(content, this.settings.chunking));
           if (options.source === "sessions" && "lineMap" in entry) {
             remapChunkLines(chunks2, entry.lineMap);
@@ -26538,7 +26538,7 @@ var init_manager_embedding_ops = __esm({
           structuredInputBytes = multimodalChunk.structuredInputBytes;
           chunks = [multimodalChunk.chunk];
         } else {
-          const content = options.content ?? await fs50.readFile(entry.absPath, "utf-8");
+          const content = options.content ?? await fs51.readFile(entry.absPath, "utf-8");
           const baseChunks = filterNonEmptyMemoryChunks(chunkMarkdown(content, this.settings.chunking));
           chunks = this.provider ? enforceEmbeddingMaxInputTokens(this.provider, baseChunks, EMBEDDING_BATCH_MAX_TOKENS) : baseChunks;
           if (options.source === "sessions" && "lineMap" in entry) {
@@ -27821,7 +27821,7 @@ var init_qmd_manager = __esm({
 });
 
 // src/memory/tools/memory/search-manager.ts
-import fs51 from "node:fs/promises";
+import fs52 from "node:fs/promises";
 function createMemorySearchManagerCacheStore() {
   return {
     qmdManagerCache: /* @__PURE__ */ new Map(),
@@ -27889,7 +27889,7 @@ async function getMemorySearchManager(params) {
     const identityKey = buildQmdManagerIdentityKey(normalizedAgentId, qmdResolved, runtimeConfig);
     const createPrimaryQmdManager = async (mode) => {
       try {
-        await fs51.mkdir(workspaceDir, { recursive: true });
+        await fs52.mkdir(workspaceDir, { recursive: true });
       } catch (err) {
         const message = formatErrorMessage(err);
         log5.warn(
@@ -28752,8 +28752,8 @@ var manager_exports = {};
 __export(manager_exports, {
   McpManager: () => McpManager
 });
-import * as fs52 from "node:fs";
-import * as path52 from "node:path";
+import * as fs53 from "node:fs";
+import * as path53 from "node:path";
 import { Client as Client3 } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -28786,12 +28786,12 @@ function convertInputSchema(inputSchema) {
 }
 function persistBinary(base64Data, mimeType, persistId) {
   const ext = mimeType?.split("/")[1] || "bin";
-  const dir = path52.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
-  fs52.mkdirSync(dir, { recursive: true });
-  const filepath = path52.join(dir, `${persistId}.${ext}`);
+  const dir = path53.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
+  fs53.mkdirSync(dir, { recursive: true });
+  const filepath = path53.join(dir, `${persistId}.${ext}`);
   try {
     const buf = Buffer.from(base64Data, "base64");
-    fs52.writeFileSync(filepath, buf);
+    fs53.writeFileSync(filepath, buf);
     return { filepath, size: buf.length };
   } catch (err) {
     return { error: err.message };
@@ -29125,7 +29125,7 @@ __export(resources_exports, {
   registerMcpResourceTools: () => registerMcpResourceTools,
   unregisterMcpResourceTools: () => unregisterMcpResourceTools
 });
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 function registerMcpResourceTools(manager) {
   mcpManagerRef = manager;
   registry.register(listResourcesTool);
@@ -29143,7 +29143,7 @@ var init_resources = __esm({
     "use strict";
     init_registry();
     MAX_RESULT_CHARS2 = 1e5;
-    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path53.join(process.env.ENGINE_STATE_DIR || ".engine", "media", "inbound");
+    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path54.join(process.env.ENGINE_STATE_DIR || ".engine", "media", "inbound");
     MCP_LIST_RESOURCES_TOOL = "mcp__list_resources";
     MCP_READ_RESOURCE_TOOL = "mcp__read_resource";
     mcpManagerRef = null;
@@ -29312,10 +29312,10 @@ function ensureLoaded(workspace, configIds) {
       if (!state.blockedUserIds.includes(id)) state.blockedUserIds.push(id);
     }
   }
-  const path55 = join39(workspace, ".reply-blocklist.json");
+  const path56 = join39(workspace, ".reply-blocklist.json");
   try {
-    if (existsSync24(path55)) {
-      const raw = readFileSync26(path55, "utf-8");
+    if (existsSync24(path56)) {
+      const raw = readFileSync26(path56, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.blockedUserIds) {
         for (const id of parsed.blockedUserIds) {
@@ -29331,9 +29331,9 @@ function ensureLoaded(workspace, configIds) {
   loaded = true;
 }
 function save(workspace) {
-  const path55 = join39(workspace, ".reply-blocklist.json");
+  const path56 = join39(workspace, ".reply-blocklist.json");
   try {
-    writeFileSync15(path55, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync15(path56, JSON.stringify(state, null, 2), "utf-8");
   } catch (err) {
     console.warn(`[reply-blocklist] Failed to save: ${err.message}`);
   }
@@ -29933,8 +29933,8 @@ var init_cognifold_intent_watcher = __esm({
 init_loader();
 
 // src/engine-startup.ts
-import * as path54 from "node:path";
-import * as fs53 from "node:fs";
+import * as path55 from "node:path";
+import * as fs54 from "node:fs";
 import { fileURLToPath } from "node:url";
 
 // src/pid-lock.ts
@@ -31276,13 +31276,13 @@ var DiscordAdapter = class _DiscordAdapter {
   }
   /** 发送媒体附件（图片/文件/音频）— discord.js channel.send({ files }) */
   async sendFile(target, message, attachment) {
-    const fs54 = await import("node:fs");
-    const path55 = await import("node:path");
-    if (!fs54.existsSync(attachment.path)) {
+    const fs55 = await import("node:fs");
+    const path56 = await import("node:path");
+    if (!fs55.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path55.basename(attachment.path);
-    const fileBuffer = fs54.readFileSync(attachment.path);
+    const filename = attachment.filename || path56.basename(attachment.path);
+    const fileBuffer = fs55.readFileSync(attachment.path);
     const filePayload = {
       attachment: fileBuffer,
       name: filename
@@ -31722,13 +31722,13 @@ var FeishuAdapter = class _FeishuAdapter {
   }
   /** 发送媒体附件（图片/文件） */
   async sendFile(target, message, attachment) {
-    const fs54 = await import("node:fs");
-    const path55 = await import("node:path");
-    if (!fs54.existsSync(attachment.path)) {
+    const fs55 = await import("node:fs");
+    const path56 = await import("node:path");
+    if (!fs55.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path55.basename(attachment.path);
-    const fileBuffer = fs54.readFileSync(attachment.path);
+    const filename = attachment.filename || path56.basename(attachment.path);
+    const fileBuffer = fs55.readFileSync(attachment.path);
     const receiveIdType = target.startsWith("ou_") ? "open_id" : "chat_id";
     const mimeType = attachment.mimeType || "application/octet-stream";
     if (mimeType.startsWith("image/")) {
@@ -35718,18 +35718,18 @@ function truncate(s2, maxLen) {
 }
 var externalChanRulesCache = null;
 function loadExternalChanRules(workspace) {
-  const path55 = join20(workspace, "prompts", "external-chan-rules.md");
-  if (externalChanRulesCache && externalChanRulesCache.path === path55) return externalChanRulesCache;
+  const path56 = join20(workspace, "prompts", "external-chan-rules.md");
+  if (externalChanRulesCache && externalChanRulesCache.path === path56) return externalChanRulesCache;
   let content = "";
-  if (existsSync12(path55)) {
+  if (existsSync12(path56)) {
     try {
-      content = readFileSync15(path55, "utf-8").trim();
+      content = readFileSync15(path56, "utf-8").trim();
     } catch (e) {
       console.warn(`[external-chan-rules] Failed to load: ${e}`);
     }
   }
-  externalChanRulesCache = { path: path55, content };
-  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path55}`);
+  externalChanRulesCache = { path: path56, content };
+  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path56}`);
   return externalChanRulesCache;
 }
 function getExternalChanRulesBlock(inboundMeta, workspace) {
@@ -40509,11 +40509,11 @@ var CogniFoldClient = class {
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.timeoutMs = timeoutMs;
   }
-  async req(path55, options = {}) {
+  async req(path56, options = {}) {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
     try {
-      const resp = await fetch(`${this.baseUrl}${path55}`, {
+      const resp = await fetch(`${this.baseUrl}${path56}`, {
         ...options,
         signal: ctrl.signal,
         headers: {
@@ -40603,8 +40603,8 @@ var CogniFoldClient = class {
     });
   }
   /** 兼容老版命名 */
-  async recl(path55, options = {}) {
-    return this.req(path55, options);
+  async recl(path56, options = {}) {
+    return this.req(path56, options);
   }
 };
 
@@ -40992,25 +40992,375 @@ var CogniFoldPlugin = class {
   }
 };
 
+// src/memory/everos/plugin.ts
+init_BashTool();
+import { spawn as spawn6 } from "node:child_process";
+import net3 from "node:net";
+import path24 from "node:path";
+import fs24 from "node:fs";
+
+// src/memory/everos/config.ts
+var DEFAULTS4 = {
+  everosUrl: "http://127.0.0.1:8100",
+  agenticUrl: "http://127.0.0.1:8101",
+  agenticPort: 8101,
+  autoStart: true,
+  defaultMode: "hybrid_agentic"
+};
+function parseEverosConfig(raw) {
+  if (!raw) {
+    return {
+      enabled: false,
+      ...DEFAULTS4,
+      userId: "xiaomei",
+      llm: { model: "glm-5.2", apiKey: "", baseUrl: "https://open.bigmodel.cn/api/coding/paas/v4" },
+      rerank: { model: "Qwen/Qwen3-Reranker-4B", apiKey: "", baseUrl: "https://api.deepinfra.com/v1/inference" },
+      lancedbPath: "",
+      sqlitePath: ""
+    };
+  }
+  return {
+    enabled: raw.enabled === true,
+    everosUrl: raw.everosUrl ?? DEFAULTS4.everosUrl,
+    agenticUrl: raw.agenticUrl ?? DEFAULTS4.agenticUrl,
+    agenticPort: raw.agenticPort ?? DEFAULTS4.agenticPort,
+    userId: raw.userId ?? "xiaomei",
+    autoStart: raw.autoStart !== false,
+    defaultMode: raw.defaultMode ?? DEFAULTS4.defaultMode,
+    llm: raw.llm ?? { model: "glm-5.2", apiKey: "", baseUrl: "https://open.bigmodel.cn/api/coding/paas/v4" },
+    rerank: raw.rerank ?? { model: "Qwen/Qwen3-Reranker-4B", apiKey: "", baseUrl: "https://api.deepinfra.com/v1/inference" },
+    lancedbPath: raw.lancedbPath ?? "",
+    sqlitePath: raw.sqlitePath ?? ""
+  };
+}
+
+// src/memory/everos/client.ts
+var EverosSearchClient = class {
+  agenticUrl;
+  everosUrl;
+  timeoutMs;
+  constructor(agenticUrl, everosUrl, timeoutMs = 12e4) {
+    this.agenticUrl = agenticUrl.replace(/\/$/, "");
+    this.everosUrl = (everosUrl || "http://127.0.0.1:8100").replace(/\/$/, "");
+    this.timeoutMs = timeoutMs;
+  }
+  /** Health check for agentic server */
+  async health() {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 5e3);
+    try {
+      const resp = await fetch(`${this.agenticUrl}/health`, { signal: ctrl.signal });
+      if (!resp.ok) throw new Error(`health ${resp.status}`);
+      return await resp.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Health check for EverOS itself */
+  async healthEveros() {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 5e3);
+    try {
+      const resp = await fetch(`${this.everosUrl}/health`, { signal: ctrl.signal });
+      if (!resp.ok) throw new Error(`everos health ${resp.status}`);
+      return await resp.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Search — 3-mode unified endpoint */
+  async search(params) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const resp = await fetch(`${this.agenticUrl}/api/v1/search`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query: params.query,
+          user_id: params.userId || "xiaomei",
+          mode: params.mode || "hybrid_agentic",
+          top_k: params.topK ?? 5,
+          strategy: params.strategy || "multi_query"
+        }),
+        signal: ctrl.signal
+      });
+      if (!resp.ok) {
+        const text = await resp.text();
+        throw new Error(`EverOS search ${resp.status}: ${text.slice(0, 200)}`);
+      }
+      return await resp.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Quick hybrid-only search (fast path) */
+  async searchFast(query, userId, topK = 5) {
+    return this.search({ query, userId, mode: "hybrid", topK });
+  }
+  /** Full agentic search (deep path) */
+  async searchDeep(query, userId, topK = 5) {
+    return this.search({ query, userId, mode: "agentic", topK });
+  }
+};
+
+// src/memory/everos/plugin.ts
+var EverosPlugin = class {
+  name = "everos";
+  config;
+  client;
+  agenticProcess = null;
+  healthTimer = null;
+  weStartedAgentic = false;
+  // 我们拉起的才管
+  constructor(rawConfig) {
+    this.config = parseEverosConfig(rawConfig);
+    this.client = new EverosSearchClient(this.config.agenticUrl, this.config.everosUrl);
+  }
+  static shouldEnable(config2) {
+    return config2?.everos?.enabled === true;
+  }
+  async start(ctx) {
+    if (!this.config.enabled) return;
+    try {
+      await this.client.healthEveros();
+      console.log(`[everos] EverOS already running at ${this.config.everosUrl}`);
+    } catch {
+      if (this.config.autoStart) {
+        console.log(`[everos] EverOS not running, starting...`);
+        await this.startEveros();
+      } else {
+        console.warn(`[everos] EverOS not running and autoStart=false`);
+      }
+    }
+    const agenticPort = this.config.agenticPort;
+    const agenticAlive = await this.isPortAlive(agenticPort);
+    if (agenticAlive) {
+      console.log(`[everos] Agentic server already running on port ${agenticPort}`);
+    } else if (this.config.autoStart) {
+      console.log(`[everos] Starting agentic server on port ${agenticPort}...`);
+      this.weStartedAgentic = true;
+      this.agenticProcess = this.startAgenticServer();
+      await this.waitForReady(`${this.config.agenticUrl}/health`, 3e4);
+    }
+    ;
+    globalThis.__everosSearchClient = this.client;
+    this.startHealthCheck();
+  }
+  async stop() {
+    if (this.healthTimer) {
+      clearInterval(this.healthTimer);
+      this.healthTimer = null;
+    }
+    if (this.weStartedAgentic && this.agenticProcess) {
+      console.log(`[everos] Stopping agentic server (PID ${this.agenticProcess.pid})`);
+      this.agenticProcess.removeAllListeners();
+      this.agenticProcess.kill("SIGTERM");
+      this.agenticProcess = null;
+    } else {
+      console.log(`[everos] Stop \u2014 agentic server was not started by us, leaving it running`);
+    }
+  }
+  getStatus() {
+    return {
+      everosRunning: true,
+      // simplified
+      agenticRunning: this.agenticProcess !== null,
+      agenticPid: this.agenticProcess?.pid ?? null
+    };
+  }
+  getClient() {
+    return this.client;
+  }
+  // === 私有 ===
+  startHealthCheck() {
+    this.healthTimer = setInterval(async () => {
+      try {
+        await this.client.health();
+      } catch {
+        if (this.weStartedAgentic && !this.agenticProcess) {
+          console.log(`[everos] Agentic server down, attempting restart...`);
+          try {
+            this.agenticProcess = this.startAgenticServer();
+            await this.waitForReady(`${this.config.agenticUrl}/health`, 3e4);
+            console.log(`[everos] Agentic server restarted`);
+          } catch (err) {
+            console.error(`[everos] Restart failed: ${err.message}`);
+          }
+        }
+      }
+    }, 3e5);
+  }
+  async startEveros() {
+    const pythonDir = path24.dirname(this.config.lancedbPath);
+    const configPath2 = path24.join(pythonDir, "config.toml");
+    await this.ensureFcntlCompat();
+    const venvPython = this.findVenvPython();
+    const args2 = ["server", "start"];
+    const cmd = `${venvPython} ${args2.join(" ")}`;
+    console.log(`[everos] Starting EverOS: ${cmd}`);
+    if (process.platform === "win32") {
+      const { shell, args: shellArgs } = findShell();
+      spawn6(shell, [...shellArgs, cmd], {
+        cwd: pythonDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, PYTHONUNBUFFERED: "1" }
+      });
+    } else {
+      spawn6(venvPython, args2, {
+        cwd: pythonDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, PYTHONUNBUFFERED: "1" }
+      });
+    }
+    await this.waitForReady(`${this.config.everosUrl}/health`, 3e4);
+  }
+  startAgenticServer() {
+    const pythonDir = this.getPythonDir();
+    const port = String(this.config.agenticPort);
+    const venvPython = this.findVenvPython();
+    const args2 = ["agentic_server.py", "--port", port];
+    const cmd = `${venvPython} ${args2.join(" ")}`;
+    console.log(`[everos] Starting agentic server: ${cmd}`);
+    console.log(`[everos] Python dir: ${pythonDir}`);
+    const childEnv = {
+      ...process.env,
+      PYTHONUNBUFFERED: "1",
+      EVEROS_URL: this.config.everosUrl,
+      LLM_MODEL: this.config.llm.model,
+      LLM_API_KEY: this.config.llm.apiKey,
+      LLM_BASE_URL: this.config.llm.baseUrl,
+      RERANK_API_KEY: this.config.rerank.apiKey,
+      RERANK_URL: `${this.config.rerank.baseUrl}/${this.config.rerank.model}`,
+      LANCEDB_PATH: this.config.lancedbPath,
+      SQLITE_PATH: this.config.sqlitePath,
+      EVEROS_USER_ID: this.config.userId
+    };
+    let child;
+    if (process.platform === "win32") {
+      const { shell, args: shellArgs } = findShell();
+      child = spawn6(shell, [...shellArgs, cmd], {
+        cwd: pythonDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: childEnv
+      });
+    } else {
+      child = spawn6(venvPython, args2, {
+        cwd: pythonDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: childEnv
+      });
+    }
+    child.on("error", (err) => {
+      console.error(`[everos] spawn error: ${err.message}`);
+    });
+    child.stdout?.on("data", (data) => {
+      const lines = data.toString().trim().split("\n");
+      for (const line of lines) console.log(`[everos:py] ${line}`);
+    });
+    child.stderr?.on("data", (data) => {
+      const lines = data.toString().trim().split("\n");
+      for (const line of lines) console.error(`[everos:py] ${line}`);
+    });
+    child.on("exit", (code, signal) => {
+      console.log(`[everos] Agentic server exited (code=${code}, signal=${signal})`);
+      this.agenticProcess = null;
+    });
+    return child;
+  }
+  findVenvPython() {
+    const stateDir = process.env.OPENCLAW_STATE_DIR || path24.join(process.env.HOME || process.env.USERPROFILE || ".", ".openclaw");
+    if (process.platform === "win32") {
+      return path24.join(stateDir, "everos-venv", "Scripts", "python.exe");
+    }
+    return path24.join(stateDir, "everos-venv", "bin", "python");
+  }
+  getPythonDir() {
+    const dir = import.meta.dirname;
+    const candidates = [
+      path24.join(dir, "python"),
+      path24.resolve(dir, "..", "src", "memory", "everos", "python"),
+      path24.resolve(dir, "..", "..", "..", "src", "memory", "everos", "python")
+    ];
+    for (const candidate of candidates) {
+      if (fs24.existsSync(path24.join(candidate, "agentic_server.py"))) {
+        return candidate;
+      }
+    }
+    return candidates[0];
+  }
+  async ensureFcntlCompat() {
+    if (process.platform !== "win32") return;
+    const venvPython = this.findVenvPython();
+    const venvDir = path24.dirname(path24.dirname(venvPython));
+    const sitePackages = path24.join(venvDir, "Lib", "site-packages");
+    const target = path24.join(sitePackages, "fcntl.py");
+    if (fs24.existsSync(target)) return;
+    const source = path24.join(this.getPythonDir(), "fcntl_compat.py");
+    if (fs24.existsSync(source)) {
+      try {
+        fs24.copyFileSync(source, target);
+        console.log(`[everos] Installed fcntl compat shim to ${target}`);
+      } catch (err) {
+        console.warn(`[everos] Failed to install fcntl shim: ${err.message}`);
+      }
+    }
+  }
+  async waitForReady(url, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const resp = await fetch(url);
+        if (resp.ok) {
+          console.log(`[everos] Service ready at ${url} (${Date.now() - start}ms)`);
+          return;
+        }
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error(`EverOS service not ready after ${timeoutMs}ms at ${url}`);
+  }
+  async isPortAlive(port) {
+    return new Promise((resolve12) => {
+      const socket = new net3.Socket();
+      socket.setTimeout(2e3);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve12(true);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolve12(false);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        resolve12(false);
+      });
+      socket.connect(port, "127.0.0.1");
+    });
+  }
+};
+
 // src/engine-startup.ts
 init_task_manager();
 
 // src/skills/scanner.ts
-import * as path24 from "node:path";
-import * as fs24 from "node:fs";
+import * as path25 from "node:path";
+import * as fs25 from "node:fs";
 function scanSkills(skillsDir) {
-  if (!fs24.existsSync(skillsDir)) {
+  if (!fs25.existsSync(skillsDir)) {
     console.log(`[skills] Directory not found: ${skillsDir}`);
     return [];
   }
-  const entries = fs24.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs25.readdirSync(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillMdPath = path24.join(skillsDir, entry.name, "SKILL.md");
-    if (!fs24.existsSync(skillMdPath)) continue;
+    const skillMdPath = path25.join(skillsDir, entry.name, "SKILL.md");
+    if (!fs25.existsSync(skillMdPath)) continue;
     try {
-      const content = fs24.readFileSync(skillMdPath, "utf-8");
+      const content = fs25.readFileSync(skillMdPath, "utf-8");
       const frontmatter = parseFrontmatter2(content);
       if (!frontmatter.name) {
         console.warn(`[skills] Skipping ${entry.name}/SKILL.md: missing 'name' in frontmatter`);
@@ -41074,8 +41424,8 @@ function parseFrontmatter2(content) {
 
 // src/tools/SkillTool/SkillTool.ts
 init_registry();
-import * as fs25 from "node:fs";
-import * as path25 from "node:path";
+import * as fs26 from "node:fs";
+import * as path26 from "node:path";
 
 // src/tools/SkillTool/constants.ts
 var SKILL_TOOL_NAME2 = "Skill";
@@ -41152,12 +41502,12 @@ Important:
 `;
 }
 function loadSkillContent(skillName) {
-  const skillMdPath = path25.join(skillsDirPath, skillName, "SKILL.md");
-  if (!fs25.existsSync(skillMdPath)) return null;
-  const content = fs25.readFileSync(skillMdPath, "utf-8");
+  const skillMdPath = path26.join(skillsDirPath, skillName, "SKILL.md");
+  if (!fs26.existsSync(skillMdPath)) return null;
+  const content = fs26.readFileSync(skillMdPath, "utf-8");
   const bodyMatch = content.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)/);
   const body = bodyMatch ? bodyMatch[1] : content;
-  const skillDir = path25.dirname(skillMdPath);
+  const skillDir = path26.dirname(skillMdPath);
   const normalizedDir = process.platform === "win32" ? skillDir.replace(/\\/g, "/") : skillDir;
   let finalContent = `Base directory for this skill: ${normalizedDir}
 
@@ -41431,12 +41781,12 @@ Examples:
 // src/tools/msg-husband.ts
 init_registry();
 init_live();
-import fs26 from "node:fs";
-import path26 from "node:path";
+import fs27 from "node:fs";
+import path27 from "node:path";
 function getHusbandFeishuId(workspace) {
-  const contactsPath = path26.join(workspace, "prompts", "contacts.md");
+  const contactsPath = path27.join(workspace, "prompts", "contacts.md");
   try {
-    const text = fs26.readFileSync(contactsPath, "utf-8");
+    const text = fs27.readFileSync(contactsPath, "utf-8");
     const m2 = text.match(/\|\s*翀哥\s*\|\s*(ou_[a-f0-9]+)\s*\|/);
     return m2 ? m2[1] : null;
   } catch {
@@ -41578,8 +41928,8 @@ Examples:
     if (!to && !resolvedChannelId) {
       return { content: "to \u548C channel_id \u4E0D\u80FD\u540C\u65F6\u4E3A\u7A7A\uFF0C\u4E14\u6CA1\u6709\u53EF\u7528\u7684\u6765\u6E90\u9891\u9053", isError: true };
     }
-    const fs54 = await import("node:fs");
-    if (!fs54.existsSync(filePath)) {
+    const fs55 = await import("node:fs");
+    if (!fs55.existsSync(filePath)) {
       return { content: `\u53D1\u9001\u5931\u8D25: \u6587\u4EF6\u4E0D\u5B58\u5728 ${filePath}`, isError: true };
     }
     const toIds = to ? to.split(",").map((s2) => s2.trim()).filter(Boolean) : [];
@@ -41607,7 +41957,7 @@ Examples:
       md: "text/markdown"
     };
     const mimeType = mimeTypeMap[ext] || "application/octet-stream";
-    const stat8 = fs54.statSync(filePath);
+    const stat8 = fs55.statSync(filePath);
     const sizeMB = stat8.size / 1024 / 1024;
     if (sizeMB > 25) {
       return { content: `\u53D1\u9001\u5931\u8D25: \u6587\u4EF6 ${sizeMB.toFixed(1)}MB \u8D85\u8FC7 Discord 25MB \u9650\u5236`, isError: true };
@@ -41636,8 +41986,8 @@ Examples:
 // src/tools/my-eyes.ts
 init_live();
 init_registry();
-import * as fs27 from "node:fs";
-import * as path27 from "node:path";
+import * as fs28 from "node:fs";
+import * as path28 from "node:path";
 var MIME_MAP = {
   ".jpg": "jpeg",
   ".jpeg": "jpeg",
@@ -41647,9 +41997,9 @@ var MIME_MAP = {
   ".bmp": "bmp"
 };
 function resolveLatestImage(specifiedPath, mediaDir) {
-  if (specifiedPath && fs27.existsSync(specifiedPath)) return specifiedPath;
-  if (!fs27.existsSync(mediaDir)) return null;
-  const files = fs27.readdirSync(mediaDir).filter((f2) => /\.(jpg|jpeg|png|webp|gif|bmp)$/i.test(f2)).map((f2) => ({ name: f2, p: path27.join(mediaDir, f2), mtime: fs27.statSync(path27.join(mediaDir, f2)).mtimeMs })).sort((a, b2) => b2.mtime - a.mtime);
+  if (specifiedPath && fs28.existsSync(specifiedPath)) return specifiedPath;
+  if (!fs28.existsSync(mediaDir)) return null;
+  const files = fs28.readdirSync(mediaDir).filter((f2) => /\.(jpg|jpeg|png|webp|gif|bmp)$/i.test(f2)).map((f2) => ({ name: f2, p: path28.join(mediaDir, f2), mtime: fs28.statSync(path28.join(mediaDir, f2)).mtimeMs })).sort((a, b2) => b2.mtime - a.mtime);
   return files[0]?.p || null;
 }
 registry.register({
@@ -41673,15 +42023,15 @@ registry.register({
     if (!provider?.streamChat) {
       return { content: "Error: provider \u4E0D\u53EF\u7528\u3002", isError: true };
     }
-    const mediaDir = path27.join(ctx.stateDir, "media", "inbound");
+    const mediaDir = path28.join(ctx.stateDir, "media", "inbound");
     const imagePath = resolveLatestImage(args2.image_path, mediaDir);
     if (!imagePath) {
       return { content: "Error: no image found. Provide image_path or ensure media/inbound has images.", isError: true };
     }
     const rawPrompt = args2.prompt?.trim() || "\u63CF\u8FF0\u8FD9\u5F20\u56FE\u7247\u7684\u5185\u5BB9";
-    const ext = path27.extname(imagePath).toLowerCase();
+    const ext = path28.extname(imagePath).toLowerCase();
     const mime = MIME_MAP[ext] || "jpeg";
-    const imgB64 = fs27.readFileSync(imagePath).toString("base64");
+    const imgB64 = fs28.readFileSync(imagePath).toString("base64");
     const userMsg = {
       role: "user",
       content: [
@@ -41718,14 +42068,14 @@ init_live();
 init_registry();
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import * as fs28 from "node:fs";
-import * as path28 from "node:path";
+import * as fs29 from "node:fs";
+import * as path29 from "node:path";
 import * as os3 from "node:os";
 var execFileAsync = promisify(execFile);
-var VOICE_DIR = path28.join(os3.tmpdir(), "engine-voice");
+var VOICE_DIR = path29.join(os3.tmpdir(), "engine-voice");
 async function ttsCosyvoice(text, apiKey, model, voice, workspaceId) {
-  fs28.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path28.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs29.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path29.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const script = `
 import sys, json, wave, time, threading
 import dashscope
@@ -41779,7 +42129,7 @@ print(f"OK: {len(pcm)} bytes")
 `;
   const configJson = JSON.stringify({ apiKey, model, voice, workspaceId });
   await execFileAsync("python3", ["-c", script, configJson, text, output], { timeout: 3e4 });
-  if (!fs28.existsSync(output) || fs28.statSync(output).size < 100) {
+  if (!fs29.existsSync(output) || fs29.statSync(output).size < 100) {
     throw new Error("CosyVoice produced empty output");
   }
   return output;
@@ -41789,8 +42139,8 @@ var GPTSOVITS_REF_WAV = "/home/chong/voice/ref/shanshan_ref_v2.wav";
 var GPTSOVITS_REF_TEXT = "\u6625\u7720\u4E0D\u89C9\u6653\uFF0C\u5904\u5904\u95FB\u557C\u9E1F\uFF0C\u591C\u6765\u98CE\u96E8\u58F0\uFF0C\u82B1\u843D\u77E5\u591A\u5C11";
 var GPTSOVITS_REF_LANG = "zh";
 async function ttsGptsovits(text) {
-  fs28.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path28.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs29.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path29.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const params = new URLSearchParams({
     text,
     text_language: "zh",
@@ -41801,13 +42151,13 @@ async function ttsGptsovits(text) {
   const res = await fetch(`${GPTSOVITS_API}/?${params}`);
   if (!res.ok) throw new Error(`GPT-SoVITS API ${res.status}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs28.writeFileSync(output, buf);
+  fs29.writeFileSync(output, buf);
   return output;
 }
 var EDGE_VOICE = "zh-CN-XiaoxiaoNeural";
 async function ttsEdge(text) {
-  fs28.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path28.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
+  fs29.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path29.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
   const script = `
 import asyncio, edge_tts, sys
 async def main():
@@ -41833,7 +42183,7 @@ async function compressWav(wavPath) {
       "+faststart",
       m4aPath
     ], { timeout: 3e4 });
-    fs28.unlinkSync(wavPath);
+    fs29.unlinkSync(wavPath);
     return m4aPath;
   } catch {
     return wavPath;
@@ -41900,10 +42250,10 @@ registry.register({
     } catch (e) {
       return { content: `TTS failed: ${e.message}`, isError: true };
     }
-    const ext = path28.extname(audioPath).toLowerCase();
+    const ext = path29.extname(audioPath).toLowerCase();
     const mimeMap = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4", ".ogg": "audio/ogg" };
     const mimeType = mimeMap[ext] || "audio/mpeg";
-    const sizeKB = fs28.statSync(audioPath).size / 1024;
+    const sizeKB = fs29.statSync(audioPath).size / 1024;
     const resolvedChannel = args2.channel || ctx.channel || "feishu";
     const target = ctx.channelTarget || ctx.from;
     try {
@@ -41913,7 +42263,7 @@ registry.register({
         filename: `voice_${Date.now()}${ext}`
       });
       try {
-        fs28.unlinkSync(audioPath);
+        fs29.unlinkSync(audioPath);
       } catch {
       }
       return { content: `Voice sent! (${actualEngine}, ${sizeKB.toFixed(0)}KB, ${resolvedChannel})` };
@@ -41930,8 +42280,8 @@ registry.register({
 // src/tools/my-selfie.ts
 init_live();
 init_registry();
-import * as fs29 from "node:fs";
-import * as path29 from "node:path";
+import * as fs30 from "node:fs";
+import * as path30 from "node:path";
 var FAL_KEY = "3b848fc6-bee5-46e5-8db7-ae81ac16dc28:2f1f15cf394db2d32c9bb9a4f23f3bee";
 var FAL_ENDPOINT = "https://fal.run/xai/grok-imagine-image/edit";
 var DEFAULT_RESOLUTION = "1k";
@@ -42047,11 +42397,11 @@ registry.register({
     const REFERENCES = getReferences(ctx);
     const refName = args2.reference || "default";
     const refEntry = REFERENCES.find((r) => r.name === refName) || REFERENCES[0];
-    const refPath = path29.join(ctx.workspace, refEntry.p);
-    if (!fs29.existsSync(refPath)) {
+    const refPath = path30.join(ctx.workspace, refEntry.p);
+    if (!fs30.existsSync(refPath)) {
       return { content: `Error: reference image not found at ${refPath}`, isError: true };
     }
-    const refB64 = fs29.readFileSync(refPath).toString("base64");
+    const refB64 = fs30.readFileSync(refPath).toString("base64");
     const resolution = args2.resolution || DEFAULT_RESOLUTION;
     let imageBuffer;
     try {
@@ -42066,11 +42416,11 @@ registry.register({
     } catch (err) {
       return { content: `Selfie generation failed: ${err.message}`, isError: true };
     }
-    const imagesDir = path29.join(ctx.workspace, "images");
-    if (!fs29.existsSync(imagesDir)) fs29.mkdirSync(imagesDir, { recursive: true });
+    const imagesDir = path30.join(ctx.workspace, "images");
+    if (!fs30.existsSync(imagesDir)) fs30.mkdirSync(imagesDir, { recursive: true });
     const filename = `selfie_${Date.now()}.jpg`;
-    const outputPath = path29.join(imagesDir, filename);
-    fs29.writeFileSync(outputPath, imageBuffer);
+    const outputPath = path30.join(imagesDir, filename);
+    fs30.writeFileSync(outputPath, imageBuffer);
     const mgr = ctx.channelManager;
     if (mgr) {
       const resolvedChannel = ctx.channel || "feishu";
@@ -42081,11 +42431,11 @@ registry.register({
           mimeType: "image/jpeg"
         });
       } catch (err) {
-        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path29.resolve(outputPath)}`, isError: false };
+        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path30.resolve(outputPath)}`, isError: false };
       }
       return { content: `Selfie sent! Mode: ${mode}, Provider: ${getProvider(ctx)}, Ref: ${refEntry.name}` };
     }
-    return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path29.resolve(outputPath)}` };
+    return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path30.resolve(outputPath)}` };
   },
   isConcurrencySafe: () => false,
   interruptBehavior: () => "block",
@@ -42225,9 +42575,9 @@ registry.register({
 // src/tools/service.ts
 init_registry();
 init_live();
-import { exec as exec3, spawn as spawn6 } from "node:child_process";
+import { exec as exec4, spawn as spawn7 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-var execAsync = promisify2(exec3);
+var execAsync = promisify2(exec4);
 function getServices() {
   return liveConfig.get("services") || {};
 }
@@ -42244,7 +42594,7 @@ function spawnDetached(cmd) {
   const shell = isWin ? "cmd.exe" : "/bin/sh";
   const logFile = `D:/xiaoke/logs/service-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "")}.log`;
   const wrappedCmd = isWin ? `/c "${cmd.replace(/"/g, '\\"')} > "${logFile}" 2>&1"` : `-c "${cmd} > '${logFile}' 2>&1"`;
-  const child = spawn6(shell, isWin ? [wrappedCmd] : ["-c", `${cmd} > '${logFile}' 2>&1`], {
+  const child = spawn7(shell, isWin ? [wrappedCmd] : ["-c", `${cmd} > '${logFile}' 2>&1`], {
     detached: true,
     stdio: "ignore",
     windowsHide: true,
@@ -42551,16 +42901,16 @@ var EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
 init_planModeState();
 
 // src/utils/plans.ts
-import * as fs31 from "node:fs";
-import * as path31 from "node:path";
+import * as fs32 from "node:fs";
+import * as path32 from "node:path";
 import * as crypto4 from "node:crypto";
 var MAX_SLUG_RETRIES = 10;
 function generateSlug() {
   return crypto4.randomBytes(4).toString("hex");
 }
 function getPlansDirectory(stateDir) {
-  const plansDir = path31.join(stateDir, "plans");
-  fs31.mkdirSync(plansDir, { recursive: true });
+  const plansDir = path32.join(stateDir, "plans");
+  fs32.mkdirSync(plansDir, { recursive: true });
   return plansDir;
 }
 var planSlugCache = /* @__PURE__ */ new Map();
@@ -42570,8 +42920,8 @@ function getPlanSlug(sessionId, stateDir) {
     const plansDir = getPlansDirectory(stateDir);
     for (let i = 0; i < MAX_SLUG_RETRIES; i++) {
       slug = generateSlug();
-      const filePath = path31.join(plansDir, `${slug}.md`);
-      if (!fs31.existsSync(filePath)) {
+      const filePath = path32.join(plansDir, `${slug}.md`);
+      if (!fs32.existsSync(filePath)) {
         break;
       }
     }
@@ -42582,21 +42932,21 @@ function getPlanSlug(sessionId, stateDir) {
 function getPlanFilePath(sessionId, stateDir, agentId) {
   const slug = getPlanSlug(sessionId, stateDir);
   if (!agentId) {
-    return path31.join(getPlansDirectory(stateDir), `${slug}.md`);
+    return path32.join(getPlansDirectory(stateDir), `${slug}.md`);
   }
-  return path31.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
+  return path32.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
 }
 function getPlan(sessionId, stateDir, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
   try {
-    return fs31.readFileSync(filePath, "utf-8");
+    return fs32.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writePlan(sessionId, stateDir, content, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
-  fs31.writeFileSync(filePath, content, "utf-8");
+  fs32.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 
@@ -43796,11 +44146,11 @@ async function startEngine(config2, opts) {
   process.env.ENGINE_MEDIA_DIR = config2.mediaDir;
   process.env.ENGINE7_WORKSPACE = config2.workspace;
   process.env.OPENCLAW_WORKSPACE = config2.workspace;
-  fs53.mkdirSync(path54.join(config2.stateDir, "agents", "main", "memory"), { recursive: true });
-  fs53.mkdirSync(path54.join(config2.stateDir, "agents", "main", "sessions"), { recursive: true });
-  fs53.mkdirSync(path54.join(config2.stateDir, "logs"), { recursive: true });
-  fs53.mkdirSync(config2.workspace, { recursive: true });
-  fs53.mkdirSync(config2.mediaDir, { recursive: true });
+  fs54.mkdirSync(path55.join(config2.stateDir, "agents", "main", "memory"), { recursive: true });
+  fs54.mkdirSync(path55.join(config2.stateDir, "agents", "main", "sessions"), { recursive: true });
+  fs54.mkdirSync(path55.join(config2.stateDir, "logs"), { recursive: true });
+  fs54.mkdirSync(config2.workspace, { recursive: true });
+  fs54.mkdirSync(config2.mediaDir, { recursive: true });
   try {
     process.chdir(config2.workspace);
   } catch (e) {
@@ -43908,7 +44258,7 @@ async function startEngine(config2, opts) {
     const { initSessionMemory: initSessionMemory2 } = await Promise.resolve().then(() => (init_sessionMemory(), sessionMemory_exports));
     initSessionMemory2({
       workspace: config2.workspace,
-      stateDir: path54.join(config2.stateDir, "session-memory"),
+      stateDir: path55.join(config2.stateDir, "session-memory"),
       provider,
       model: config2.provider.modelId || config2.model || "deepseek-v4-flash",
       features: config2.profile.features
@@ -43938,9 +44288,9 @@ async function startEngine(config2, opts) {
   if (config2.hooks) {
     loadHooksFromConfig({ hooks: config2.hooks });
   }
-  const hooksPath = path54.join(config2.workspace, ".hooks.json");
+  const hooksPath = path55.join(config2.workspace, ".hooks.json");
   loadHooksFromFile(hooksPath);
-  const settingsHooksPath = path54.join(config2.stateDir, "settings.json");
+  const settingsHooksPath = path55.join(config2.stateDir, "settings.json");
   loadHooksFromFile(settingsHooksPath);
   console.log(`[hooks] Loaded hooks configuration`);
   registerCallbackHook("PreCompact", {
@@ -43954,18 +44304,18 @@ async function startEngine(config2, opts) {
       const bjTime = new Date(now.getTime() + (bjOffset + now.getTimezoneOffset()) * 6e4);
       const dateStr = `${bjTime.getFullYear()}-${String(bjTime.getMonth() + 1).padStart(2, "0")}-${String(bjTime.getDate()).padStart(2, "0")}`;
       const timeStr = `${String(bjTime.getHours()).padStart(2, "0")}:${String(bjTime.getMinutes()).padStart(2, "0")}`;
-      const dailyDir = path54.join(workspace, "memory", "daily");
-      const dailyPath = path54.join(dailyDir, `${dateStr}.md`);
+      const dailyDir = path55.join(workspace, "memory", "daily");
+      const dailyPath = path55.join(dailyDir, `${dateStr}.md`);
       try {
-        const fs54 = await import("node:fs");
-        if (!fs54.existsSync(dailyDir)) {
-          fs54.mkdirSync(dailyDir, { recursive: true });
+        const fs55 = await import("node:fs");
+        if (!fs55.existsSync(dailyDir)) {
+          fs55.mkdirSync(dailyDir, { recursive: true });
         }
-        const sessionsDir = path54.join(config2.stateDir, "agents", "main", "sessions");
-        const sessionFile = path54.join(sessionsDir, `${sessionId}.jsonl`);
+        const sessionsDir = path55.join(config2.stateDir, "agents", "main", "sessions");
+        const sessionFile = path55.join(sessionsDir, `${sessionId}.jsonl`);
         const recentLines = [];
-        if (fs54.existsSync(sessionFile)) {
-          const content = fs54.readFileSync(sessionFile, "utf-8");
+        if (fs55.existsSync(sessionFile)) {
+          const content = fs55.readFileSync(sessionFile, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           const userLines = lines.filter((l) => {
             try {
@@ -43995,10 +44345,10 @@ async function startEngine(config2, opts) {
         const entry = `${header}
 ${body}
 `;
-        if (fs54.existsSync(dailyPath)) {
-          fs54.appendFileSync(dailyPath, entry);
+        if (fs55.existsSync(dailyPath)) {
+          fs55.appendFileSync(dailyPath, entry);
         } else {
-          fs54.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
+          fs55.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
 ${entry}`);
         }
         console.log(`[hooks] PreCompact: saved ${recentLines.length} lines to ${dailyPath}`);
@@ -44014,16 +44364,16 @@ ${entry}`);
       const workspace = input.cwd || input.workspace || "";
       if (!workspace) return { continue: true };
       try {
-        const fs54 = await import("node:fs");
-        const bufferPath = path54.join(workspace, "memory", "working-buffer.md");
-        if (fs54.existsSync(bufferPath)) {
-          const stat8 = fs54.statSync(bufferPath);
+        const fs55 = await import("node:fs");
+        const bufferPath = path55.join(workspace, "memory", "working-buffer.md");
+        if (fs55.existsSync(bufferPath)) {
+          const stat8 = fs55.statSync(bufferPath);
           const ageMs = Date.now() - stat8.mtimeMs;
           const ageMin = Math.round(ageMs / 6e4);
           if (ageMin > 10) {
             console.warn(`[hooks] PostCompact: \u26A0\uFE0F working-buffer.md is ${ageMin}min old (last modified ${stat8.mtime.toISOString()}) \u2014 content may be stale!`);
           }
-          const content = fs54.readFileSync(bufferPath, "utf-8");
+          const content = fs55.readFileSync(bufferPath, "utf-8");
           if (content.trim()) {
             console.log(`[hooks] PostCompact: injecting working-buffer (${content.length} chars, ${ageMin}min old)`);
             return {
@@ -44068,7 +44418,7 @@ ${content}`
     return `${hr}h ${remMin}m`;
   }
   if (config2.skills?.enabled !== false) {
-    const skillsDir = config2.skills?.path ? path54.isAbsolute(config2.skills.path) ? config2.skills.path : path54.resolve(config2.workspace, config2.skills.path) : path54.resolve(config2.workspace, "skills");
+    const skillsDir = config2.skills?.path ? path55.isAbsolute(config2.skills.path) ? config2.skills.path : path55.resolve(config2.workspace, config2.skills.path) : path55.resolve(config2.workspace, "skills");
     const modelDef2 = config2.provider.models.find((m2) => m2.id === config2.model);
     const contextWindowTokens = modelDef2?.contextWindow;
     const skills = scanSkills(skillsDir);
@@ -44087,8 +44437,8 @@ ${content}`
     workspace: config2.workspace
   });
   const systemPrompt = [systemStable, systemDynamic].join("\n\n");
-  const promptDumpPath = path54.join(config2.workspace, ".system-prompt.txt");
-  fs53.writeFileSync(promptDumpPath, systemPrompt);
+  const promptDumpPath = path55.join(config2.workspace, ".system-prompt.txt");
+  fs54.writeFileSync(promptDumpPath, systemPrompt);
   console.log(`System prompt: ${systemStable.length} chars stable + ${systemDynamic.length} chars dynamic \u2192 ${promptDumpPath}`);
   const modelDef = config2.provider.models.find((m2) => m2.id === config2.model);
   const modelContextWindow = modelDef?.contextWindow;
@@ -44994,15 +45344,15 @@ ${result.changes.map((c) => `- ${c}`).join("\n")}` : `\u274C Reload failed: ${re
         config2.features[key] = next;
         if (deps.features) deps.features[key] = next;
         try {
-          const fs54 = await import("fs");
+          const fs55 = await import("fs");
           const pathMod = await import("path");
           let cfgPath = config2._configFilePath;
-          if (!cfgPath || !fs54.existsSync(cfgPath)) {
+          if (!cfgPath || !fs55.existsSync(cfgPath)) {
             const __filename = fileURLToPath(import.meta.url);
             const __dirname = pathMod.dirname(__filename);
             cfgPath = pathMod.resolve(__dirname, "../configs", pathMod.basename(cfgPath || "engine-config.json"));
           }
-          const cfg = JSON.parse(fs54.readFileSync(cfgPath, "utf-8"));
+          const cfg = JSON.parse(fs55.readFileSync(cfgPath, "utf-8"));
           let featObj = null;
           if (cfg.agents?.defaults?.features) {
             featObj = cfg.agents.defaults.features;
@@ -45012,7 +45362,7 @@ ${result.changes.map((c) => `- ${c}`).join("\n")}` : `\u274C Reload failed: ${re
           }
           if (featObj) {
             featObj[key] = next;
-            fs54.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+            fs55.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
             console.log(`[${ctx.command}] ${key} ${cur} \u2192 ${rawState} (disk persisted)`);
             await ctx.reply(`\u2705 ${key}: **${cur}** \u2192 **${rawState}**`);
           } else {
@@ -45138,11 +45488,11 @@ Auto-routing disabled \u2014 all messages use this model.
         const input = (ctx.args.model || "").trim();
         const configPath2 = config2._configFilePath;
         let writePath = configPath2;
-        if (configPath2 && !fs53.existsSync(configPath2)) {
+        if (configPath2 && !fs54.existsSync(configPath2)) {
           const __pFile = fileURLToPath(import.meta.url);
-          const __pDir = path54.dirname(__pFile);
-          const altPath = path54.join(path54.resolve(__pDir, "../configs"), path54.basename(configPath2));
-          if (fs53.existsSync(altPath)) {
+          const __pDir = path55.dirname(__pFile);
+          const altPath = path55.join(path55.resolve(__pDir, "../configs"), path55.basename(configPath2));
+          if (fs54.existsSync(altPath)) {
             console.warn(`[primary] Config not found at ${configPath2}, falling back to ${altPath}`);
             writePath = altPath;
           }
@@ -45186,14 +45536,14 @@ Use full ref like \`/primary ${candidates[0].ref}\``);
           return;
         }
         try {
-          const raw = await fs53.promises.readFile(writePath, "utf-8");
+          const raw = await fs54.promises.readFile(writePath, "utf-8");
           const cfg = JSON.parse(raw);
           if (!cfg.agents?.defaults?.model) {
             await ctx.reply(`\u26A0\uFE0F Config structure mismatch: agents.defaults.model not found`);
             return;
           }
           cfg.agents.defaults.model.primary = target;
-          await fs53.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+          await fs54.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
           console.log(`[primary] Persisted primary=${target} to ${writePath}`);
           await ctx.reply(`\u2705 Primary model set to **${target}** (${candidates[0].name})
 Written to config. **Restart required** to take effect.`);
@@ -45413,7 +45763,7 @@ Use full ref like \`/vision-model ${candidates[0].ref}\``);
             console.log(`[vision] Downloading image: ${att.filename}`);
             let rawBuffer;
             if (att.url.startsWith("file://")) {
-              rawBuffer = fs53.readFileSync(decodeURIComponent(att.url.slice(7)));
+              rawBuffer = fs54.readFileSync(decodeURIComponent(att.url.slice(7)));
             } else {
               rawBuffer = await downloadImage2(att.url);
             }
@@ -45421,8 +45771,8 @@ Use full ref like \`/vision-model ${candidates[0].ref}\``);
             const ext = detected.split("/")[1] || "png";
             const resized = await maybeResizeAndDownsampleImageBuffer2(rawBuffer, rawBuffer.length, ext);
             const imageId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const savedPath = path54.join(config2.mediaDir, `${imageId}.${ext}`);
-            fs53.writeFileSync(savedPath, resized.buffer);
+            const savedPath = path55.join(config2.mediaDir, `${imageId}.${ext}`);
+            fs54.writeFileSync(savedPath, resized.buffer);
             savedPaths.push(savedPath);
             console.log(`[vision] Saved: ${savedPath} (${resized.buffer.length}B)`);
             imageBlocks.push({
@@ -45448,8 +45798,8 @@ ${pathStr}` }];
         }
         const nonImageAttachments = inbound.attachments?.filter((a) => !a.contentType.startsWith("image/"));
         if (nonImageAttachments && nonImageAttachments.length > 0) {
-          const outDir = path54.join(config2.mediaDir, sessionId);
-          fs53.mkdirSync(outDir, { recursive: true });
+          const outDir = path55.join(config2.mediaDir, sessionId);
+          fs54.mkdirSync(outDir, { recursive: true });
           const resolved = [];
           for (const att of nonImageAttachments) {
             console.log(`[file] Downloading: ${att.filename} (${att.contentType}, ${att.size}B)`);
@@ -45457,9 +45807,9 @@ ${pathStr}` }];
               const resp = await fetch(att.url);
               if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
               const buffer = Buffer.from(await resp.arrayBuffer());
-              const safeName2 = path54.basename(att.filename).replace(/[<>:"/\\|?*\x00-\x1f]/g, "_") || "attachment";
-              const savedPath = path54.join(outDir, safeName2);
-              fs53.writeFileSync(savedPath, buffer);
+              const safeName2 = path55.basename(att.filename).replace(/[<>:"/\\|?*\x00-\x1f]/g, "_") || "attachment";
+              const savedPath = path55.join(outDir, safeName2);
+              fs54.writeFileSync(savedPath, buffer);
               resolved.push(savedPath);
               console.log(`[file] Saved: ${savedPath} (${buffer.length}B)`);
             } catch (err) {
@@ -45677,6 +46027,10 @@ ${pathStr}` }];
         console.warn("[cognifold] workspace path not found, skipping plugin registration");
       }
     }
+    if (config2.everos?.enabled) {
+      pluginManager.register(new EverosPlugin(config2.everos));
+      console.log("[everos] Plugin registered");
+    }
     globalThis.__pluginManager = pluginManager;
     if (visualEmitter && config2.visualization?.guildId) {
       const vConfig = config2.visualization;
@@ -45815,7 +46169,7 @@ ${pathStr}` }];
                 console.warn("[cognifold] watcher: config.workspace \u672A\u914D\u7F6E\uFF0C\u8DF3\u8FC7 proactive \u5199\u5165");
                 return;
               }
-              const pFile = path54.join(wsDir, ".cognifold-proactive.json");
+              const pFile = path55.join(wsDir, ".cognifold-proactive.json");
               const cognifoldBaseUrl = config2.cognifold?.baseUrl || "http://127.0.0.1:9001";
               const cognifoldSessionId = cfSessionId;
               const rawSuggestions = data.suggestions || data.actions || (data.intent_id ? [data] : []);
@@ -45863,14 +46217,14 @@ ${pathStr}` }];
                 return s2;
               }));
               try {
-                fs53.writeFileSync(pFile, JSON.stringify(enriched, null, 2));
+                fs54.writeFileSync(pFile, JSON.stringify(enriched, null, 2));
                 console.log(`[cognifold] proactive suggestions saved (${enriched.length} total)`);
               } catch (e) {
                 console.error(`[cognifold] failed to save proactive: ${e.message}`);
               }
               if (enriched.length > 0) {
-                const promptFile = path54.join(config2.workspace, "prompts", "cognifold-proactive.md");
-                const promptText = fs53.existsSync(promptFile) ? fs53.readFileSync(promptFile, "utf-8") : "[CogniFold proactive] \u6709 " + enriched.length + " \u4E2A action \u5230\u671F\u4E86";
+                const promptFile = path55.join(config2.workspace, "prompts", "cognifold-proactive.md");
+                const promptText = fs54.existsSync(promptFile) ? fs54.readFileSync(promptFile, "utf-8") : "[CogniFold proactive] \u6709 " + enriched.length + " \u4E2A action \u5230\u671F\u4E86";
                 const actionsJson = JSON.stringify(enriched, null, 2);
                 const sessionId = cfSessionId;
                 const mainSessionId = sessions.getSessionId("scope:main");
@@ -45973,12 +46327,12 @@ async function doReloadConfig(config2, deps, provider) {
   try {
     const savedConfigPath = config2._configFilePath;
     let reloadConfigPath = savedConfigPath;
-    if (!fs53.existsSync(reloadConfigPath)) {
+    if (!fs54.existsSync(reloadConfigPath)) {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path54.dirname(__filename);
-      const engineConfigsDir = path54.resolve(__dirname, "../configs");
-      const altPath = path54.join(engineConfigsDir, path54.basename(savedConfigPath));
-      if (fs53.existsSync(altPath)) {
+      const __dirname = path55.dirname(__filename);
+      const engineConfigsDir = path55.resolve(__dirname, "../configs");
+      const altPath = path55.join(engineConfigsDir, path55.basename(savedConfigPath));
+      if (fs54.existsSync(altPath)) {
         console.warn(`[reload] Config not found at ${reloadConfigPath}, falling back to ${altPath} (dev mode)`);
         reloadConfigPath = altPath;
       }
@@ -46030,7 +46384,7 @@ async function doReloadConfig(config2, deps, provider) {
   } catch (err) {
     console.error(`[reload] Failed: ${err.message}`);
     try {
-      fs53.appendFileSync(path54.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD FAILED: ${err.message}
+      fs54.appendFileSync(path55.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD FAILED: ${err.message}
 ${err.stack}
 `);
     } catch {
@@ -46041,36 +46395,36 @@ ${err.stack}
 function startConfigWatcher(config2, deps, provider) {
   const raw = config2._configFilePath;
   let configPath2 = raw;
-  if (!fs53.existsSync(configPath2)) {
-    configPath2 = path54.resolve(raw);
+  if (!fs54.existsSync(configPath2)) {
+    configPath2 = path55.resolve(raw);
   }
-  if (!fs53.existsSync(configPath2)) {
+  if (!fs54.existsSync(configPath2)) {
     const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname22 = path54.dirname(__filename2);
-    configPath2 = path54.resolve(__dirname22, "..", raw);
+    const __dirname22 = path55.dirname(__filename2);
+    configPath2 = path55.resolve(__dirname22, "..", raw);
   }
-  if (!fs53.existsSync(configPath2)) {
+  if (!fs54.existsSync(configPath2)) {
     console.warn(`[config-watch] config path invalid: ${configPath2}, watcher disabled`);
     try {
-      fs53.appendFileSync(path54.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] DISABLED: configPath=${configPath2}
+      fs54.appendFileSync(path55.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] DISABLED: configPath=${configPath2}
 `);
     } catch {
     }
     return null;
   }
   let debounceTimer = null;
-  const watcher = fs53.watch(configPath2, { persistent: true }, (eventType) => {
+  const watcher = fs54.watch(configPath2, { persistent: true }, (eventType) => {
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(async () => {
       console.log(`[config-watch] file changed (${eventType}), reloading...`);
       try {
-        fs53.appendFileSync(path54.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] CHANGE eventType=${eventType}, calling doReloadConfig
+        fs54.appendFileSync(path55.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] CHANGE eventType=${eventType}, calling doReloadConfig
 `);
       } catch {
       }
       const result = await doReloadConfig(config2, deps, provider);
       try {
-        fs53.appendFileSync(path54.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD DONE: ok=${result.ok} changes=${result.changes.join(",")}
+        fs54.appendFileSync(path55.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD DONE: ok=${result.ok} changes=${result.changes.join(",")}
 `);
       } catch {
       }
@@ -46079,14 +46433,14 @@ function startConfigWatcher(config2, deps, provider) {
   watcher.on("error", (err) => {
     console.error(`[config-watch] error: ${err.message}`);
     try {
-      fs53.appendFileSync(path54.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${err.message}
+      fs54.appendFileSync(path55.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${err.message}
 `);
     } catch {
     }
   });
   console.log(`[config-watch] watching ${configPath2}`);
   try {
-    fs53.appendFileSync(path54.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] STARTED watching=${configPath2}
+    fs54.appendFileSync(path55.join(config2.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] STARTED watching=${configPath2}
 `);
   } catch {
   }