engine7 7.1.113 → 7.1.114

package/dist/main.mjs

@@ -141,14 +141,14 @@ var init_live = __esm({
       }
       /** 把改动写回 config 文件对应段（找不到文件路径则只内存生效） */
       async persistToFile(dotPath, val) {
-        const fs59 = await import("node:fs");
+        const fs58 = await import("node:fs");
         const cfgPath = this.current?._configFilePath;
-        if (!cfgPath || !fs59.existsSync(cfgPath)) {
+        if (!cfgPath || !fs58.existsSync(cfgPath)) {
           console.warn(`[liveConfig] set: no config file path, in-memory only (${dotPath})`);
           return;
         }
         try {
-          const raw = JSON.parse(fs59.readFileSync(cfgPath, "utf-8"));
+          const raw = JSON.parse(fs58.readFileSync(cfgPath, "utf-8"));
           const keys = dotPath.split(".");
           let o = raw;
           for (let i = 0; i < keys.length - 1; i++) {
@@ -156,7 +156,7 @@ var init_live = __esm({
             o = o[keys[i]];
           }
           o[keys[keys.length - 1]] = val;
-          fs59.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+          fs58.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
           console.log(`[liveConfig] persisted ${dotPath} = ${JSON.stringify(val)} to ${cfgPath}`);
           markSelfWrite();
         } catch (e) {
@@ -3647,8 +3647,8 @@ function findShell() {
       timeout: 5e3,
       stdio: ["ignore", "pipe", "ignore"]
     });
-    const candidates = result.trim().split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-    const nonWsl = candidates.find((p) => !isWslBash(p));
+    const candidates2 = result.trim().split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+    const nonWsl = candidates2.find((p) => !isWslBash(p));
     if (nonWsl && fs6.existsSync(nonWsl)) {
       cachedShell = { shell: nonWsl, args: ["-c"] };
       return cachedShell;
@@ -4602,9 +4602,9 @@ function isAutoMemPath(absolutePath, workspace) {
   return normalizedPath.startsWith(getAutoMemPath(workspace));
 }
 async function ensureMemoryDirExists(memoryDir) {
-  const fs59 = await import("node:fs");
+  const fs58 = await import("node:fs");
   try {
-    await fs59.promises.mkdir(memoryDir, { recursive: true });
+    await fs58.promises.mkdir(memoryDir, { recursive: true });
   } catch (e) {
     const code = e?.code;
     if (code !== "EEXIST") {
@@ -8496,7 +8496,7 @@ async function acquireLock(inboxPath) {
   for (let i = 0; i < LOCK_RETRIES; i++) {
     if (await isLockStale(lockPath2)) {
       try {
-        await import("node:fs/promises").then((fs59) => fs59.rm(lockPath2, { force: true }));
+        await import("node:fs/promises").then((fs58) => fs58.rm(lockPath2, { force: true }));
       } catch {
       }
     }
@@ -8504,7 +8504,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((fs59) => fs59.rm(lockPath2, { force: true }));
+          await import("node:fs/promises").then((fs58) => fs58.rm(lockPath2, { force: true }));
         } catch {
         }
       };
@@ -14324,8 +14324,8 @@ function mapOperation(raw) {
 }
 function extractJson2(text) {
   const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-  const candidates = fenced ? [fenced[1], text] : [text];
-  for (const c of candidates) {
+  const candidates2 = fenced ? [fenced[1], text] : [text];
+  for (const c of candidates2) {
     const start = c.indexOf("{");
     const end = c.lastIndexOf("}");
     if (start === -1 || end <= start) continue;
@@ -14996,14 +14996,14 @@ async function runProactiveCycle(deps, now) {
   for (const act of persist.dueActions("9999-12-31T23:59:59Z", 1e3)) {
     if (act.status === "queued") existingTitles.add(normalizeTitle(act.title));
   }
-  const candidates = actionable.filter((s) => {
+  const candidates2 = actionable.filter((s) => {
     if (queuedIntentIds.has(s.node.id)) return false;
     if (cooldownIntentIds.has(s.node.id)) return false;
     return true;
   });
-  if (candidates.length === 0) return 0;
+  if (candidates2.length === 0) return 0;
   let enqueued = 0;
-  for (const scored of candidates) {
+  for (const scored of candidates2) {
     const intent = scored.node;
     if (intent.data.status === "resolved") continue;
     store.updateNode(intent.id, { status: "action_scheduled" });
@@ -16862,11 +16862,11 @@ async function readLastConsolidatedAt(memoryDir) {
   }
 }
 async function tryAcquireConsolidationLock(memoryDir) {
-  const path61 = lockPath(memoryDir);
+  const path60 = lockPath(memoryDir);
   let mtimeMs;
   let holderPid;
   try {
-    const [s, raw] = await Promise.all([stat3(path61), readFile5(path61, "utf8")]);
+    const [s, raw] = await Promise.all([stat3(path60), readFile5(path60, "utf8")]);
     mtimeMs = s.mtimeMs;
     const parsed = parseInt(raw.trim(), 10);
     holderPid = Number.isFinite(parsed) ? parsed : void 0;
@@ -16879,10 +16879,10 @@ async function tryAcquireConsolidationLock(memoryDir) {
     }
   }
   await mkdir3(memoryDir, { recursive: true });
-  await writeFile4(path61, String(process.pid));
+  await writeFile4(path60, String(process.pid));
   let verify2;
   try {
-    verify2 = await readFile5(path61, "utf8");
+    verify2 = await readFile5(path60, "utf8");
   } catch {
     return null;
   }
@@ -16890,15 +16890,15 @@ async function tryAcquireConsolidationLock(memoryDir) {
   return mtimeMs ?? 0;
 }
 async function rollbackConsolidationLock(memoryDir, priorMtime) {
-  const path61 = lockPath(memoryDir);
+  const path60 = lockPath(memoryDir);
   try {
     if (priorMtime === 0) {
-      await unlink(path61);
+      await unlink(path60);
       return;
     }
-    await writeFile4(path61, "");
+    await writeFile4(path60, "");
     const t = priorMtime / 1e3;
-    await utimes(path61, t, t);
+    await utimes(path60, t, t);
   } catch (e) {
     console.log(`[autoDream] rollback failed: ${e.message} \u2014 next trigger delayed to minHours`);
   }
@@ -17500,12 +17500,12 @@ async function executeAndDeliver(task, now, deps) {
     if (promptText.startsWith("@")) {
       let filePath = promptText.slice(1).trim();
       try {
-        const fs59 = await import("fs");
-        const path61 = await import("path");
-        if (!path61.isAbsolute(filePath)) {
-          filePath = path61.join(deps.sessions["config"].stateDir, filePath);
+        const fs58 = await import("fs");
+        const path60 = await import("path");
+        if (!path60.isAbsolute(filePath)) {
+          filePath = path60.join(deps.sessions["config"].stateDir, filePath);
         }
-        promptText = fs59.readFileSync(filePath, "utf-8");
+        promptText = fs58.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}`);
@@ -17543,16 +17543,16 @@ async function executeAndDeliver(task, now, deps) {
     let finalResult = result;
     if (task.postProcess) {
       try {
-        const path61 = await import("path");
-        const fs59 = await import("fs");
+        const path60 = await import("path");
+        const fs58 = await import("fs");
         let scriptPath = task.postProcess;
-        if (!path61.isAbsolute(scriptPath)) {
-          scriptPath = path61.join(deps.sessions["config"].stateDir, scriptPath);
+        if (!path60.isAbsolute(scriptPath)) {
+          scriptPath = path60.join(deps.sessions["config"].stateDir, scriptPath);
         }
-        const resultsDirTmp = path61.join(getStorageDir(), "results");
-        fs59.mkdirSync(resultsDirTmp, { recursive: true });
-        const inputFile = path61.join(resultsDirTmp, `${task.id}.input.txt`);
-        fs59.writeFileSync(inputFile, result, "utf-8");
+        const resultsDirTmp = path60.join(getStorageDir(), "results");
+        fs58.mkdirSync(resultsDirTmp, { recursive: true });
+        const inputFile = path60.join(resultsDirTmp, `${task.id}.input.txt`);
+        fs58.writeFileSync(inputFile, result, "utf-8");
         const { execFile: execFile5 } = await import("child_process");
         await new Promise((resolve12) => {
           execFile5("python", [scriptPath, "main", "--file", inputFile], {
@@ -17579,12 +17579,12 @@ async function executeAndDeliver(task, now, deps) {
       }
     }
     try {
-      const fs59 = await import("fs");
-      const path61 = await import("path");
-      const resultsDir = path61.join(getStorageDir(), "results");
-      fs59.mkdirSync(resultsDir, { recursive: true });
-      const resultFile = path61.join(resultsDir, `${task.id}.json`);
-      fs59.writeFileSync(resultFile, JSON.stringify({
+      const fs58 = await import("fs");
+      const path60 = await import("path");
+      const resultsDir = path60.join(getStorageDir(), "results");
+      fs58.mkdirSync(resultsDir, { recursive: true });
+      const resultFile = path60.join(resultsDir, `${task.id}.json`);
+      fs58.writeFileSync(resultFile, JSON.stringify({
         taskId: task.id,
         description: task.description,
         executedAt: now.toISOString(),
@@ -17914,30 +17914,30 @@ function registerCronTools() {
       }
     },
     handler: async (args2) => {
-      const fs59 = await import("fs");
-      const path61 = await import("path");
-      const resultsDir = path61.join(getStorageDir(), "results");
-      if (!fs59.existsSync(resultsDir)) {
+      const fs58 = await import("fs");
+      const path60 = await import("path");
+      const resultsDir = path60.join(getStorageDir(), "results");
+      if (!fs58.existsSync(resultsDir)) {
         return { content: "\u6682\u65E0cron\u6267\u884C\u7ED3\u679C" };
       }
       if (args2.task_id) {
-        const file2 = path61.join(resultsDir, `${args2.task_id}.json`);
-        if (!fs59.existsSync(file2)) {
+        const file2 = path60.join(resultsDir, `${args2.task_id}.json`);
+        if (!fs58.existsSync(file2)) {
           return { content: `\u4EFB\u52A1 ${args2.task_id} \u6682\u65E0\u6267\u884C\u7ED3\u679C`, isError: true };
         }
-        const data = JSON.parse(fs59.readFileSync(file2, "utf-8"));
+        const data = JSON.parse(fs58.readFileSync(file2, "utf-8"));
         return { content: `## ${data.description}
 \u6267\u884C\u65F6\u95F4: ${data.executedAt}
 \u7B2C${data.runCount}\u6B21\u6267\u884C
 
 ${data.result}` };
       }
-      const files = fs59.readdirSync(resultsDir).filter((f) => f.endsWith(".json"));
+      const files = fs58.readdirSync(resultsDir).filter((f) => f.endsWith(".json"));
       if (files.length === 0) {
         return { content: "\u6682\u65E0cron\u6267\u884C\u7ED3\u679C" };
       }
       const results = files.map((f) => {
-        const data = JSON.parse(fs59.readFileSync(path61.join(resultsDir, f), "utf-8"));
+        const data = JSON.parse(fs58.readFileSync(path60.join(resultsDir, f), "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 ? "..." : ""}`;
@@ -18461,25 +18461,43 @@ var init_tasks2 = __esm({
   }
 });
 
-// src/startup/api-status.ts
-var api_status_exports = {};
-__export(api_status_exports, {
-  buildEngineStatus: () => buildEngineStatus,
-  readEngineVersion: () => readEngineVersion
-});
-import * as fs35 from "node:fs";
-import * as path35 from "node:path";
+// src/version.ts
+import { readFileSync as readFileSync32 } from "node:fs";
+import { dirname as dirname10, join as join43 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-function readEngineVersion() {
-  const here = path35.dirname(fileURLToPath6(import.meta.url));
-  for (const p of [path35.join(here, "..", "package.json"), path35.join(here, "..", "..", "package.json")]) {
+function candidates() {
+  if (_pkgDirOverride !== null) return [join43(_pkgDirOverride, "package.json")];
+  const here = dirname10(fileURLToPath6(import.meta.url));
+  return [join43(here, "..", "package.json"), join43(here, "..", "..", "package.json")];
+}
+function readFromDisk() {
+  for (const p of candidates()) {
     try {
-      return JSON.parse(fs35.readFileSync(p, "utf8")).version || "unknown";
+      return JSON.parse(readFileSync32(p, "utf-8")).version || "unknown";
     } catch {
     }
   }
   return "unknown";
 }
+function readEngineVersion() {
+  if (_loaded === null) _loaded = readFromDisk();
+  return _loaded;
+}
+var _loaded, _pkgDirOverride;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    _loaded = null;
+    _pkgDirOverride = null;
+  }
+});
+
+// src/startup/api-status.ts
+var api_status_exports = {};
+__export(api_status_exports, {
+  buildEngineStatus: () => buildEngineStatus,
+  readEngineVersion: () => readEngineVersion
+});
 function hasUsable(v) {
   return !!v && !isUnresolvedEnvRef(v);
 }
@@ -18502,6 +18520,7 @@ var init_api_status = __esm({
   "src/startup/api-status.ts"() {
     "use strict";
     init_loader();
+    init_version();
   }
 });
 
@@ -18612,10 +18631,10 @@ function ensureLoaded(workspace, configIds) {
       if (!state.blockedUserIds.includes(id)) state.blockedUserIds.push(id);
     }
   }
-  const path61 = join44(workspace, ".reply-blocklist.json");
+  const path60 = join44(workspace, ".reply-blocklist.json");
   try {
-    if (existsSync23(path61)) {
-      const raw = readFileSync33(path61, "utf-8");
+    if (existsSync23(path60)) {
+      const raw = readFileSync33(path60, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.blockedUserIds) {
         for (const id of parsed.blockedUserIds) {
@@ -18631,9 +18650,9 @@ function ensureLoaded(workspace, configIds) {
   loaded = true;
 }
 function save(workspace) {
-  const path61 = join44(workspace, ".reply-blocklist.json");
+  const path60 = join44(workspace, ".reply-blocklist.json");
   try {
-    writeFileSync11(path61, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync11(path60, JSON.stringify(state, null, 2), "utf-8");
   } catch (err) {
     console.warn(`[reply-blocklist] Failed to save: ${err.message}`);
   }
@@ -19078,8 +19097,8 @@ __export(voice_chat_tts_daemon_exports, {
 });
 import { spawn as spawn5 } from "child_process";
 import net2 from "net";
-import path39 from "path";
-import fs39 from "fs";
+import path38 from "path";
+import fs38 from "fs";
 function _log(msg2) {
   console.log(`[tts-daemon] ${msg2}`);
 }
@@ -19124,16 +19143,16 @@ async function startTtsDaemon(warmupCfg) {
       return;
     }
     const script = (() => {
-      const distDir = path39.dirname(new URL(import.meta.url).pathname);
-      const candidates = [
-        path39.join(distDir, "..", "python", "tts_daemon.py"),
-        path39.join(process.cwd(), "engine/src/python/tts_daemon.py"),
+      const distDir = path38.dirname(new URL(import.meta.url).pathname);
+      const candidates2 = [
+        path38.join(distDir, "..", "python", "tts_daemon.py"),
+        path38.join(process.cwd(), "engine/src/python/tts_daemon.py"),
         "/Users/chongzhang/work/twinsun-hearth/engine/src/python/tts_daemon.py"
       ];
-      for (const c of candidates) {
-        if (fs39.existsSync(c)) return c;
+      for (const c of candidates2) {
+        if (fs38.existsSync(c)) return c;
       }
-      return candidates[0];
+      return candidates2[0];
     })();
     _log(`spawning ${script}`);
     const env = {
@@ -19203,15 +19222,15 @@ var read_exports = {};
 __export(read_exports, {
   readFileState: () => readFileState
 });
-import * as fs52 from "node:fs";
-import * as path51 from "node:path";
+import * as fs51 from "node:fs";
+import * as path50 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 stat4 = fs52.statSync(filePath);
+  const stat4 = fs51.statSync(filePath);
   const mtimeMs = stat4.mtimeMs;
   const prev = readHistory.get(filePath);
   if (prev && prev.offset === offset && prev.limit === limit && prev.mtimeMs === mtimeMs) {
@@ -19225,19 +19244,19 @@ function checkReadLoop(filePath, offset, limit) {
   return null;
 }
 function readFileContent(filePath) {
-  const fd = fs52.openSync(filePath, "r");
+  const fd = fs51.openSync(filePath, "r");
   const bom = Buffer.alloc(2);
-  fs52.readSync(fd, bom, 0, 2, 0);
-  fs52.closeSync(fd);
+  fs51.readSync(fd, bom, 0, 2, 0);
+  fs51.closeSync(fd);
   let encoding = "utf8";
   if (bom[0] === 255 && bom[1] === 254) {
     encoding = "utf16le";
   }
-  const stat4 = fs52.statSync(filePath);
+  const stat4 = fs51.statSync(filePath);
   if (stat4.size > MAX_FILE_SIZE) {
     throw new Error(`\u6587\u4EF6\u592A\u5927 (${(stat4.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 = fs52.readFileSync(filePath, encoding);
+  const raw = fs51.readFileSync(filePath, encoding);
   const content = raw.toString().replaceAll("\r\n", "\n");
   return { content, encoding };
 }
@@ -19379,11 +19398,11 @@ Usage:
         } catch (e) {
           return { content: e.message, isError: true };
         }
-        if (!fs52.existsSync(filePath)) {
+        if (!fs51.existsSync(filePath)) {
           return { content: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, isError: true };
         }
-        const stat4 = fs52.statSync(filePath);
-        const baseName = path51.basename(filePath).toUpperCase();
+        const stat4 = fs51.statSync(filePath);
+        const baseName = path50.basename(filePath).toUpperCase();
         if (BLOCKED_BASENAMES.has(baseName)) {
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6: ${filePath}`, isError: true };
         }
@@ -19391,11 +19410,11 @@ Usage:
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4F1A\u963B\u585E\u6216\u4EA7\u751F\u65E0\u9650\u8F93\u51FA: ${filePath}`, isError: true };
         }
         if (stat4.isDirectory()) {
-          const entries2 = fs52.readdirSync(filePath);
+          const entries2 = fs51.readdirSync(filePath);
           const items = entries2.map((e) => {
-            const full = path51.join(filePath, e);
+            const full = path50.join(filePath, e);
             try {
-              const s = fs52.statSync(full);
+              const s = fs51.statSync(full);
               return s.isDirectory() ? `${e}/` : e;
             } catch {
               return e;
@@ -19404,7 +19423,7 @@ Usage:
           return { content: `\u76EE\u5F55 (${entries2.length} \u9879):
 ${items.join("\n")}` };
         }
-        const ext = path51.extname(filePath).toLowerCase();
+        const ext = path50.extname(filePath).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext)) {
           return { content: `\u4E8C\u8FDB\u5236\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6 (${ext}): ${filePath}`, isError: true };
         }
@@ -19452,22 +19471,22 @@ ${result}` : result };
 
 // src/tools/write.ts
 var write_exports = {};
-import * as fs53 from "node:fs";
-import * as path52 from "node:path";
+import * as fs52 from "node:fs";
+import * as path51 from "node:path";
 function isBlockedPath(filePath) {
   return BLOCKED_PATTERNS.some((p) => p.test(filePath));
 }
 function atomicWrite(filePath, content) {
   const tmpPath = filePath + ".tmp." + Date.now() + ".write";
-  fs53.writeFileSync(tmpPath, content, "utf-8");
+  fs52.writeFileSync(tmpPath, content, "utf-8");
   try {
-    fs53.renameSync(tmpPath, filePath);
+    fs52.renameSync(tmpPath, filePath);
   } catch (e) {
     try {
-      fs53.unlinkSync(tmpPath);
+      fs52.unlinkSync(tmpPath);
     } catch {
     }
-    fs53.writeFileSync(filePath, content, "utf-8");
+    fs52.writeFileSync(filePath, content, "utf-8");
   }
 }
 function simpleDiff(oldContent, newContent) {
@@ -19561,15 +19580,15 @@ Usage:
         }
         const rawContent = args2.content;
         const content = rawContent.replaceAll("\r\n", "\n");
-        if (fs53.existsSync(filePath) && fs53.statSync(filePath).isDirectory()) {
+        if (fs52.existsSync(filePath) && fs52.statSync(filePath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
         }
         let oldContent = null;
         let isCreate = true;
-        if (fs53.existsSync(filePath)) {
+        if (fs52.existsSync(filePath)) {
           isCreate = false;
           try {
-            oldContent = fs53.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            oldContent = fs52.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
           } catch {
             isCreate = true;
           }
@@ -19585,10 +19604,10 @@ Usage:
               isError: true
             };
           }
-          const currentStat = fs53.statSync(filePath);
+          const currentStat = fs52.statSync(filePath);
           const lastWriteTime = Math.floor(currentStat.mtimeMs);
           if (lastWriteTime > readState.timestamp) {
-            const currentContent = fs53.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            const currentContent = fs52.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}`,
@@ -19597,9 +19616,9 @@ Usage:
             }
           }
         }
-        const dir = path52.dirname(filePath);
+        const dir = path51.dirname(filePath);
         try {
-          fs53.mkdirSync(dir, { recursive: true });
+          fs52.mkdirSync(dir, { recursive: true });
         } catch (e) {
           return { content: `\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${dir} \u2014 ${e.message}`, isError: true };
         }
@@ -19608,11 +19627,11 @@ Usage:
         } catch (e) {
           return { content: `\u5199\u5165\u5931\u8D25: ${e.message}`, isError: true };
         }
-        readFileState.set(filePath, { timestamp: fs53.statSync(filePath).mtimeMs });
+        readFileState.set(filePath, { timestamp: fs52.statSync(filePath).mtimeMs });
         const action = isCreate ? "\u521B\u5EFA" : "\u66F4\u65B0";
         const lines = content.split("\n").length;
         const chars = content.length;
-        const stat4 = fs53.statSync(filePath);
+        const stat4 = fs52.statSync(filePath);
         let diff = "";
         if (!isCreate && oldContent !== null) {
           diff = `
@@ -19632,8 +19651,8 @@ ${simpleDiff(oldContent, content)}`;
 
 // src/tools/edit.ts
 var edit_exports = {};
-import * as fs54 from "node:fs";
-import * as path53 from "node:path";
+import * as fs53 from "node:fs";
+import * as path52 from "node:path";
 function normalizeQuotes(str) {
   return str.replaceAll(LEFT_SINGLE_CURLY, "'").replaceAll(RIGHT_SINGLE_CURLY, "'").replaceAll(LEFT_DOUBLE_CURLY, '"').replaceAll(RIGHT_DOUBLE_CURLY, '"');
 }
@@ -19786,7 +19805,7 @@ Usage:
         }
         let fileContent = null;
         try {
-          const stat4 = fs54.statSync(filePath);
+          const stat4 = fs53.statSync(filePath);
           if (stat4.isDirectory()) {
             return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
           }
@@ -19796,21 +19815,21 @@ Usage:
         } catch (e) {
           if (e.code === "ENOENT") {
             if (oldString === "") {
-              const dir = path53.dirname(filePath);
-              fs54.mkdirSync(dir, { recursive: true });
-              fs54.writeFileSync(filePath, newString, "utf-8");
-              readFileState.set(filePath, { timestamp: fs54.statSync(filePath).mtimeMs });
+              const dir = path52.dirname(filePath);
+              fs53.mkdirSync(dir, { recursive: true });
+              fs53.writeFileSync(filePath, newString, "utf-8");
+              readFileState.set(filePath, { timestamp: fs53.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 = fs54.readFileSync(filePath, "utf-8");
+        const rawContent = fs53.readFileSync(filePath, "utf-8");
         fileContent = rawContent.replaceAll("\r\n", "\n");
         if (oldString === "" && fileContent.trim() === "") {
-          fs54.writeFileSync(filePath, newString, "utf-8");
-          readFileState.set(filePath, { timestamp: fs54.statSync(filePath).mtimeMs });
+          fs53.writeFileSync(filePath, newString, "utf-8");
+          readFileState.set(filePath, { timestamp: fs53.statSync(filePath).mtimeMs });
           return { content: `\u5199\u5165\u7A7A\u6587\u4EF6: ${filePath} (${newString.split("\n").length} \u884C)` };
         }
         const readState = readFileState.get(filePath);
@@ -19820,11 +19839,11 @@ Usage:
             isError: true
           };
         }
-        const currentStat = fs54.statSync(filePath);
+        const currentStat = fs53.statSync(filePath);
         const lastWriteTime = Math.floor(currentStat.mtimeMs);
         if (lastWriteTime > readState.timestamp) {
           if (fileContent !== rawContent.replaceAll("\r\n", "\n")) {
-            if (fileContent !== fs54.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n")) {
+            if (fileContent !== fs53.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
@@ -19856,8 +19875,8 @@ ${preview}
         const actualNewString = preserveQuoteStyle(oldString, actualOldString, newString);
         const diffView = generateEditDiff(fileContent, actualOldString, actualNewString);
         const newContent = applyEditToFile(fileContent, actualOldString, actualNewString, replaceAll);
-        fs54.writeFileSync(filePath, newContent, "utf-8");
-        readFileState.set(filePath, { timestamp: fs54.statSync(filePath).mtimeMs });
+        fs53.writeFileSync(filePath, newContent, "utf-8");
+        readFileState.set(filePath, { timestamp: fs53.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`;
@@ -19875,8 +19894,8 @@ ${diffView}`
 
 // src/tools/glob.ts
 var glob_exports = {};
-import * as fs55 from "node:fs";
-import * as path54 from "node:path";
+import * as fs54 from "node:fs";
+import * as path53 from "node:path";
 function globMatch(pattern, filename) {
   const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   try {
@@ -19896,18 +19915,18 @@ function findFiles(dir, pattern, limit, baseDir) {
     }
     let entries2;
     try {
-      entries2 = fs55.readdirSync(currentDir, { withFileTypes: true });
+      entries2 = fs54.readdirSync(currentDir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries2) {
       if (truncated) return;
-      const fullPath = path54.join(currentDir, entry.name);
+      const fullPath = path53.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (VCS_DIRS.has(entry.name)) continue;
         walk(fullPath);
       } else if (entry.isFile()) {
-        const relativePath = path54.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = path53.relative(baseDir, fullPath).replace(/\\/g, "/");
         const patternsToTry = [pattern];
         if (pattern.startsWith("**/")) {
           patternsToTry.push(pattern.slice(3));
@@ -19917,7 +19936,7 @@ function findFiles(dir, pattern, limit, baseDir) {
         );
         if (matched) {
           try {
-            const stat4 = fs55.statSync(fullPath);
+            const stat4 = fs54.statSync(fullPath);
             results.push({ path: fullPath, mtimeMs: stat4.mtimeMs });
           } catch {
           }
@@ -19934,7 +19953,7 @@ function findFiles(dir, pattern, limit, baseDir) {
   };
 }
 function toRelativePath(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path54.sep)) {
+  if (absolutePath.startsWith(cwd + path53.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   return absolutePath;
@@ -19967,10 +19986,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 (!fs55.existsSync(searchPath)) {
+        if (!fs54.existsSync(searchPath)) {
           return { content: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${searchPath}`, isError: true };
         }
-        if (!fs55.statSync(searchPath).isDirectory()) {
+        if (!fs54.statSync(searchPath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${searchPath}`, isError: true };
         }
         const start = Date.now();
@@ -19995,7 +20014,7 @@ ${filenames.join("\n")}${truncatedNote}`
 // src/tools/grep.ts
 var grep_exports = {};
 import { execFile as execFile4 } from "node:child_process";
-import * as path55 from "node:path";
+import * as path54 from "node:path";
 function ripGrep(args2, searchPath, signal) {
   return new Promise((resolve12) => {
     const fullArgs = [...args2, searchPath];
@@ -20027,7 +20046,7 @@ function applyHeadLimit(items, limit, offset = 0) {
   };
 }
 function toRelativePath2(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path55.sep)) {
+  if (absolutePath.startsWith(cwd + path54.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   if (absolutePath.startsWith(cwd)) {
@@ -20600,7 +20619,7 @@ var init_builtInAgents = __esm({
 });
 
 // src/tools/AgentTool/forkSubagent.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function isForkSubagentEnabled() {
   return true;
 }
@@ -20639,7 +20658,7 @@ function buildForkedMessages(directive, parentMessages) {
     type: "tool_result",
     tool_use_id: block.id,
     content: FORK_PLACEHOLDER_RESULT,
-    id: `toolr_${randomUUID8().replace(/-/g, "").slice(0, 24)}`
+    id: `toolr_${randomUUID9().replace(/-/g, "").slice(0, 24)}`
   }));
   const toolResultMessage = msg_user(
     buildChildMessage(directive),
@@ -20702,10 +20721,10 @@ var init_forkSubagent = __esm({
 });
 
 // src/tools/AgentTool/runAgent.ts
-import { randomBytes as randomBytes6 } from "node:crypto";
+import { randomBytes as randomBytes7 } from "node:crypto";
 function generateAgentId() {
   const prefix = "a";
-  const bytes = randomBytes6(8);
+  const bytes = randomBytes7(8);
   let id = prefix;
   for (let i = 0; i < 8; i++) {
     id += TASK_ID_ALPHABET2[bytes[i] % TASK_ID_ALPHABET2.length];
@@ -22764,8 +22783,8 @@ __export(manager_exports, {
   McpManager: () => McpManager,
   convertInputSchema: () => convertInputSchema
 });
-import * as fs58 from "node:fs";
-import * as path58 from "node:path";
+import * as fs57 from "node:fs";
+import * as path57 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";
@@ -22806,12 +22825,12 @@ function convertInputSchema(inputSchema) {
 }
 function persistBinary(base64Data, mimeType, persistId) {
   const ext = mimeType?.split("/")[1] || "bin";
-  const dir = path58.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
-  fs58.mkdirSync(dir, { recursive: true });
-  const filepath = path58.join(dir, `${persistId}.${ext}`);
+  const dir = path57.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
+  fs57.mkdirSync(dir, { recursive: true });
+  const filepath = path57.join(dir, `${persistId}.${ext}`);
   try {
     const buf = Buffer.from(base64Data, "base64");
-    fs58.writeFileSync(filepath, buf);
+    fs57.writeFileSync(filepath, buf);
     return { filepath, size: buf.length };
   } catch (err) {
     return { error: err.message };
@@ -23145,7 +23164,7 @@ __export(resources_exports, {
   registerMcpResourceTools: () => registerMcpResourceTools,
   unregisterMcpResourceTools: () => unregisterMcpResourceTools
 });
-import * as path59 from "node:path";
+import * as path58 from "node:path";
 function registerMcpResourceTools(manager) {
   mcpManagerRef = manager;
   registry.register(listResourcesTool);
@@ -23163,7 +23182,7 @@ var init_resources = __esm({
     "use strict";
     init_registry();
     MAX_RESULT_CHARS2 = 1e5;
-    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path59.join(process.env.ENGINE_STATE_DIR || ".engine", "media", "inbound");
+    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path58.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;
@@ -23311,7 +23330,7 @@ function loadSecretsEnvForConfig(configPath2) {
 // src/engine-startup.ts
 init_query();
 init_live();
-import * as path60 from "node:path";
+import * as path59 from "node:path";
 
 // src/startup/providers.ts
 init_provider_factory();
@@ -23840,8 +23859,8 @@ function startConfigWatcher(config2, deps, provider) {
   }
   if (!fs10.existsSync(configPath2)) {
     const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname22 = path10.dirname(__filename2);
-    configPath2 = path10.resolve(__dirname22, "..", raw);
+    const __dirname2 = path10.dirname(__filename2);
+    configPath2 = path10.resolve(__dirname2, "..", raw);
   }
   if (!fs10.existsSync(configPath2)) {
     console.warn(`[config-watch] config path invalid: ${configPath2}, watcher disabled`);
@@ -24664,7 +24683,7 @@ ${formatted}` };
   };
 }
 function createEverosGetTool() {
-  const fs59 = __require("node:fs/promises");
+  const fs58 = __require("node:fs/promises");
   return {
     name: "memory_get",
     description: "Read a memory file by path.",
@@ -24680,7 +24699,7 @@ function createEverosGetTool() {
     handler: async (args2) => {
       try {
         const filePath = args2.path;
-        const content = await fs59.readFile(filePath, "utf-8");
+        const content = await fs58.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         const fromLine = args2.from ?? 1;
         const numLines = args2.lines ?? lines.length;
@@ -25932,9 +25951,9 @@ function readDbEmbeddings(dbPath) {
     db2.close();
   }
 }
-async function llmRerank(query, candidates, topK, ollamaChatUrl, model) {
-  if (candidates.length <= topK) return candidates;
-  const manifest = candidates.map(
+async function llmRerank(query, candidates2, topK, ollamaChatUrl, model) {
+  if (candidates2.length <= topK) return candidates2;
+  const manifest = candidates2.map(
     (c, i) => `${i + 1}. ${c.filename}
    ${c.description || c.name}`
   ).join("\n");
@@ -25966,7 +25985,7 @@ Select up to ${topK} most relevant (return their 1-indexed numbers as JSON {"sel
     });
     if (!resp.ok) {
       console.warn(`[memdir] rerank: ollama chat failed: ${resp.status}`);
-      return candidates.slice(0, topK);
+      return candidates2.slice(0, topK);
     }
     const data = await resp.json();
     const text = data?.message?.content ?? "";
@@ -25975,19 +25994,19 @@ Select up to ${topK} most relevant (return their 1-indexed numbers as JSON {"sel
       try {
         const parsed = JSON.parse(jsonMatch[0]);
         if (parsed.selected && Array.isArray(parsed.selected)) {
-          const indices = parsed.selected.filter((n) => n >= 1 && n <= candidates.length).map((n) => n - 1);
-          const result = indices.map((i) => candidates[i]);
-          console.log(`[memdir] rerank: ${model} selected ${result.length}/${candidates.length} candidates (indices: ${indices.map((i) => i + 1).join(",")})`);
+          const indices = parsed.selected.filter((n) => n >= 1 && n <= candidates2.length).map((n) => n - 1);
+          const result = indices.map((i) => candidates2[i]);
+          console.log(`[memdir] rerank: ${model} selected ${result.length}/${candidates2.length} candidates (indices: ${indices.map((i) => i + 1).join(",")})`);
           return result.slice(0, topK);
         }
       } catch {
       }
     }
     console.warn(`[memdir] rerank: no valid JSON in response (${text.length} chars), falling back to vector order`);
-    return candidates.slice(0, topK);
+    return candidates2.slice(0, topK);
   } catch (e) {
     console.warn(`[memdir] rerank: error: ${e?.message ?? e}, falling back to vector order`);
-    return candidates.slice(0, topK);
+    return candidates2.slice(0, topK);
   }
 }
 async function findRelevantMemoriesVector(query, memoryDir, alreadySurfaced = /* @__PURE__ */ new Set(), options) {
@@ -26036,17 +26055,17 @@ async function findRelevantMemoriesVector(query, memoryDir, alreadySurfaced = /*
     }
   }
   scored.sort((a, b) => b.score - a.score);
-  const candidates = scored.slice(0, CANDIDATE_POOL);
+  const candidates2 = scored.slice(0, CANDIDATE_POOL);
   const vectorMs = Date.now() - t0;
   console.log(
-    `[memdir] vector recall: ${candidates.length} candidates in ${vectorMs}ms (embed=${embedMs}ms, scanned=${rows.length} files, minScore=${minScore})`
+    `[memdir] vector recall: ${candidates2.length} candidates in ${vectorMs}ms (embed=${embedMs}ms, scanned=${rows.length} files, minScore=${minScore})`
   );
-  if (candidates.length > 0) {
-    console.log(`[memdir] vector top scores: ${candidates.slice(0, 5).map((r) => `${r.filename}=${r.score.toFixed(3)}`).join(", ")}${candidates.length > 5 ? "..." : ""}`);
+  if (candidates2.length > 0) {
+    console.log(`[memdir] vector top scores: ${candidates2.slice(0, 5).map((r) => `${r.filename}=${r.score.toFixed(3)}`).join(", ")}${candidates2.length > 5 ? "..." : ""}`);
   }
-  if (candidates.length === 0) return [];
+  if (candidates2.length === 0) return [];
   const rerankT0 = Date.now();
-  const reranked = await llmRerank(query, candidates, topK, DEFAULT_OLLAMA_CHAT_URL, rerankModel);
+  const reranked = await llmRerank(query, candidates2, topK, DEFAULT_OLLAMA_CHAT_URL, rerankModel);
   const rerankMs = Date.now() - rerankT0;
   const totalMs = Date.now() - t0;
   console.log(`[memdir] recall total: ${totalMs}ms (vector=${vectorMs}ms, rerank=${rerankMs}ms)`);
@@ -26473,18 +26492,18 @@ function resetSessionStartInjection(sessionId) {
 }
 var externalChanRulesCache = null;
 function loadExternalChanRules(workspace) {
-  const path61 = join36(workspace, "prompts", "external-chan-rules.md");
-  if (externalChanRulesCache && externalChanRulesCache.path === path61) return externalChanRulesCache;
+  const path60 = join36(workspace, "prompts", "external-chan-rules.md");
+  if (externalChanRulesCache && externalChanRulesCache.path === path60) return externalChanRulesCache;
   let content = "";
-  if (existsSync20(path61)) {
+  if (existsSync20(path60)) {
     try {
-      content = readFileSync27(path61, "utf-8").trim();
+      content = readFileSync27(path60, "utf-8").trim();
     } catch (e) {
       console.warn(`[external-chan-rules] Failed to load: ${e}`);
     }
   }
-  externalChanRulesCache = { path: path61, content };
-  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path61}`);
+  externalChanRulesCache = { path: path60, content };
+  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path60}`);
   return externalChanRulesCache;
 }
 function getExternalChanRulesBlock(inboundMeta, workspace) {
@@ -27371,15 +27390,15 @@ function registerCompactHooks(config2) {
       const dailyDir = path22.join(workspace, "memory", "daily");
       const dailyPath = path22.join(dailyDir, `${dateStr}.md`);
       try {
-        const fs59 = await import("node:fs");
-        if (!fs59.existsSync(dailyDir)) {
-          fs59.mkdirSync(dailyDir, { recursive: true });
+        const fs58 = await import("node:fs");
+        if (!fs58.existsSync(dailyDir)) {
+          fs58.mkdirSync(dailyDir, { recursive: true });
         }
         const sessionsDir = path22.join(config2.stateDir, "agents", "main", "sessions");
         const sessionFile = path22.join(sessionsDir, `${sessionId}.jsonl`);
         const recentLines = [];
-        if (fs59.existsSync(sessionFile)) {
-          const content = fs59.readFileSync(sessionFile, "utf-8");
+        if (fs58.existsSync(sessionFile)) {
+          const content = fs58.readFileSync(sessionFile, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           const userLines = lines.filter((l) => {
             try {
@@ -27409,10 +27428,10 @@ function registerCompactHooks(config2) {
         const entry = `${header}
 ${body}
 `;
-        if (fs59.existsSync(dailyPath)) {
-          fs59.appendFileSync(dailyPath, entry);
+        if (fs58.existsSync(dailyPath)) {
+          fs58.appendFileSync(dailyPath, entry);
         } else {
-          fs59.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
+          fs58.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
 ${entry}`);
         }
         console.log(`[hooks] PreCompact: saved ${recentLines.length} lines to ${dailyPath}`);
@@ -27428,16 +27447,16 @@ ${entry}`);
       const workspace = input.cwd || input.workspace || "";
       if (!workspace) return { continue: true };
       try {
-        const fs59 = await import("node:fs");
+        const fs58 = await import("node:fs");
         const bufferPath = path22.join(workspace, "memory", "working-buffer.md");
-        if (fs59.existsSync(bufferPath)) {
-          const stat4 = fs59.statSync(bufferPath);
+        if (fs58.existsSync(bufferPath)) {
+          const stat4 = fs58.statSync(bufferPath);
           const ageMs = Date.now() - stat4.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 ${stat4.mtime.toISOString()}) \u2014 content may be stale!`);
           }
-          const content = fs59.readFileSync(bufferPath, "utf-8");
+          const content = fs58.readFileSync(bufferPath, "utf-8");
           if (content.trim()) {
             console.log(`[hooks] PostCompact: injecting working-buffer (${content.length} chars, ${ageMin}min old)`);
             return {
@@ -30814,6 +30833,8 @@ function startInboxPoller(ctx) {
   const INBOX_POLL_INTERVAL_MS = 2e3;
   const INBOX_IDLE_INTERVAL_MS = 3e4;
   let pollCycleCount = 0;
+  let lastStatusLine = "";
+  let warnedNoPreview = false;
   let inboxPollerTimer = null;
   let inboxPollerStandby = false;
   function runInboxPollCycle() {
@@ -30850,7 +30871,11 @@ function startInboxPoller(ctx) {
         ).join(" ");
         const isMainActive = dispatcher.isActive("main");
         const mainPending = dispatcher.pendingCount("main");
-        console.log(`[inbox-poller] #${pollCycleCount} teammates=[${statusSummary}] mainActive=${isMainActive} mainPending=${mainPending}`);
+        const statusLine = `teammates=[${statusSummary}] mainActive=${isMainActive} mainPending=${mainPending}`;
+        if (statusLine !== lastStatusLine || pollCycleCount % 15 === 0) {
+          lastStatusLine = statusLine;
+          console.log(`[inbox-poller] #${pollCycleCount} ${statusLine}`);
+        }
         const now = Date.now();
         const allTeamNames = new Set(teammates.filter((t) => t.status !== "killed").map((t) => t.identity.teamName));
         const teams = [...allTeamNames];
@@ -30928,7 +30953,6 @@ function startInboxPoller(ctx) {
 ${notifications}
 [/teammate-status]${taskSummary}`;
           const inboxTarget = "";
-          const inboxPreview = null;
           const submitted = dispatcher.submitMessage({
             text: queryContent,
             sessionId: "main",
@@ -30938,21 +30962,12 @@ ${notifications}
             priority: "next",
             // 对齐 CC: idle 时立即提交，不是 'later' 排队
             callbacks: {
-              onText: (text) => {
-                if (inboxPreview) {
-                  inboxPreview.appendText(text);
-                } else {
-                  console.warn(`[inbox-poller:onText] no preview target, Discord output dropped (${text.length} chars)`);
-                }
+              onText: (_text) => {
+                if (warnedNoPreview) return;
+                warnedNoPreview = true;
+                console.warn("[inbox-poller] teammate-status \u7684\u8F93\u51FA\u4E0D\u6295\u9012\u5230\u5916\u90E8\u9891\u9053\uFF08\u8BBE\u8BA1\u5982\u6B64\uFF09\uFF0C\u4EC5\u5904\u7406\u526F\u4F5C\u7528");
               },
-              onResult: async (content) => {
-                if (inboxPreview) {
-                  const delivered = await inboxPreview.finish(content.trim() || "(\u5904\u7406\u5B8C\u6210)");
-                  if (!delivered && inboxTarget) {
-                    channelManager.send("discord", inboxTarget, content.trim() || "(\u5904\u7406\u5B8C\u6210)").catch(() => {
-                    });
-                  }
-                }
+              onResult: async (_content) => {
               }
             },
             deps
@@ -31646,8 +31661,8 @@ var VoiceChatPlugin = class {
 // src/memory/everos/plugin.ts
 import { spawn as spawn4 } from "node:child_process";
 import net from "node:net";
-import path36 from "node:path";
-import fs36 from "node:fs";
+import path35 from "node:path";
+import fs35 from "node:fs";
 
 // src/memory/everos/config.ts
 var DEFAULTS4 = {
@@ -31881,8 +31896,8 @@ var EverosPlugin = class {
     }, 3e5);
   }
   async startEveros() {
-    const pythonDir = path36.dirname(this.config.lancedbPath);
-    const configPath2 = path36.join(pythonDir, "config.toml");
+    const pythonDir = path35.dirname(this.config.lancedbPath);
+    const configPath2 = path35.join(pythonDir, "config.toml");
     await this.ensureFcntlCompat();
     const venvPython = this.findVenvPython();
     const everosBin = venvPython.replace(/python\.exe$/, "everos.exe");
@@ -31972,19 +31987,19 @@ var EverosPlugin = class {
     return child;
   }
   findVenvPython() {
-    const stateDir = process.env.ENGINE7_STATE_DIR || path36.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    const stateDir = process.env.ENGINE7_STATE_DIR || path35.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
     if (process.platform === "win32") {
-      return path36.join(stateDir, "everos-venv", "Scripts", "python.exe");
+      return path35.join(stateDir, "everos-venv", "Scripts", "python.exe");
     }
-    return path36.join(stateDir, "everos-venv", "bin", "python");
+    return path35.join(stateDir, "everos-venv", "bin", "python");
   }
   /** 检测 venv 是否存在，不存在就自动创建 + 装 EverOS */
   async ensureVenv() {
     const venvPython = this.findVenvPython();
-    if (fs36.existsSync(venvPython)) return;
-    const stateDir = process.env.ENGINE7_STATE_DIR || path36.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
-    const venvDir = path36.join(stateDir, "everos-venv");
-    const everosSrc = path36.join(stateDir, "workspace", "research", "EverOS");
+    if (fs35.existsSync(venvPython)) return;
+    const stateDir = process.env.ENGINE7_STATE_DIR || path35.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    const venvDir = path35.join(stateDir, "everos-venv");
+    const everosSrc = path35.join(stateDir, "workspace", "research", "EverOS");
     console.log(`[everos] venv not found at ${venvDir}, auto-creating...`);
     console.log(`[everos] \u23F3 This may take a few minutes on first run...`);
     const pyCandidates = process.platform === "win32" ? ["python", "python3", "C:\\Python314\\python.exe", "C:\\Python313\\python.exe", "C:\\Python312\\python.exe"] : ["python3", "python"];
@@ -32006,9 +32021,9 @@ var EverosPlugin = class {
       console.log(`[everos] Creating venv with ${sysPython}...`);
       const { execSync: execSync3 } = await import("node:child_process");
       execSync3(`"${sysPython}" -m venv "${venvDir}"`, { stdio: "pipe", shell: true });
-      const pip = process.platform === "win32" ? path36.join(venvDir, "Scripts", "pip.exe") : path36.join(venvDir, "bin", "pip");
-      const everosReq = path36.join(this.getPythonDir(), "requirements.txt");
-      if (fs36.existsSync(everosReq)) {
+      const pip = process.platform === "win32" ? path35.join(venvDir, "Scripts", "pip.exe") : path35.join(venvDir, "bin", "pip");
+      const everosReq = path35.join(this.getPythonDir(), "requirements.txt");
+      if (fs35.existsSync(everosReq)) {
         console.log(`[everos] Installing from requirements.txt...`);
         execSync3(`"${pip}" install -r "${everosReq}" -q`, { stdio: "pipe", shell: true, timeout: 3e5 });
       } else {
@@ -32023,29 +32038,29 @@ var EverosPlugin = class {
   }
   getPythonDir() {
     const dir = import.meta.dirname;
-    const candidates = [
-      path36.join(dir, "python"),
-      path36.resolve(dir, "..", "src", "memory", "everos", "python"),
-      path36.resolve(dir, "..", "..", "..", "src", "memory", "everos", "python")
+    const candidates2 = [
+      path35.join(dir, "python"),
+      path35.resolve(dir, "..", "src", "memory", "everos", "python"),
+      path35.resolve(dir, "..", "..", "..", "src", "memory", "everos", "python")
     ];
-    for (const candidate of candidates) {
-      if (fs36.existsSync(path36.join(candidate, "agentic_server.py"))) {
+    for (const candidate of candidates2) {
+      if (fs35.existsSync(path35.join(candidate, "agentic_server.py"))) {
         return candidate;
       }
     }
-    return candidates[0];
+    return candidates2[0];
   }
   async ensureFcntlCompat() {
     if (process.platform !== "win32") return;
     const venvPython = this.findVenvPython();
-    const venvDir = path36.dirname(path36.dirname(venvPython));
-    const sitePackages = path36.join(venvDir, "Lib", "site-packages");
-    const target = path36.join(sitePackages, "fcntl.py");
-    if (fs36.existsSync(target)) return;
-    const source = path36.join(this.getPythonDir(), "fcntl_compat.py");
-    if (fs36.existsSync(source)) {
+    const venvDir = path35.dirname(path35.dirname(venvPython));
+    const sitePackages = path35.join(venvDir, "Lib", "site-packages");
+    const target = path35.join(sitePackages, "fcntl.py");
+    if (fs35.existsSync(target)) return;
+    const source = path35.join(this.getPythonDir(), "fcntl_compat.py");
+    if (fs35.existsSync(source)) {
       try {
-        fs36.copyFileSync(source, target);
+        fs35.copyFileSync(source, target);
         console.log(`[everos] Installed fcntl compat shim to ${target}`);
       } catch (err) {
         console.warn(`[everos] Failed to install fcntl shim: ${err.message}`);
@@ -32654,8 +32669,8 @@ function createVisualBoot(ctx) {
 }
 
 // src/startup/message-pipeline.ts
-import * as fs37 from "node:fs";
-import * as path37 from "node:path";
+import * as fs36 from "node:fs";
+import * as path36 from "node:path";
 
 // src/commands/registry.ts
 var commands = /* @__PURE__ */ new Map();
@@ -33546,7 +33561,7 @@ function setupMessagePipeline(ctx) {
           console.log(`[vision] Downloading image: ${att.filename}`);
           let rawBuffer;
           if (att.url.startsWith("file://")) {
-            rawBuffer = fs37.readFileSync(decodeURIComponent(att.url.slice(7)));
+            rawBuffer = fs36.readFileSync(decodeURIComponent(att.url.slice(7)));
           } else {
             rawBuffer = await downloadImage2(att.url, attachDispatcher);
           }
@@ -33554,8 +33569,8 @@ function setupMessagePipeline(ctx) {
           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 = path37.join(config2.mediaDir, `${imageId}.${ext}`);
-          fs37.writeFileSync(savedPath, resized.buffer);
+          const savedPath = path36.join(config2.mediaDir, `${imageId}.${ext}`);
+          fs36.writeFileSync(savedPath, resized.buffer);
           savedPaths.push(savedPath);
           console.log(`[vision] Saved: ${savedPath} (${resized.buffer.length}B)`);
           imageBlocks.push({
@@ -33585,8 +33600,8 @@ ${pathStr}` }];
       }
       const nonImageAttachments = inbound.attachments?.filter((a) => !a.contentType.startsWith("image/"));
       if (nonImageAttachments && nonImageAttachments.length > 0) {
-        const outDir = path37.join(config2.mediaDir, sessionId);
-        fs37.mkdirSync(outDir, { recursive: true });
+        const outDir = path36.join(config2.mediaDir, sessionId);
+        fs36.mkdirSync(outDir, { recursive: true });
         const resolved = [];
         for (const att of nonImageAttachments) {
           console.log(`[file] Downloading: ${att.filename} (${att.contentType}, ${att.size}B)`);
@@ -33594,9 +33609,9 @@ ${pathStr}` }];
             const resp = attachDispatcher ? await fetch(att.url, { dispatcher: attachDispatcher, signal: AbortSignal.timeout(3e4) }) : await fetch(att.url, { signal: AbortSignal.timeout(3e4) });
             if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
             const buffer = Buffer.from(await resp.arrayBuffer());
-            const safeName2 = path37.basename(att.filename).replace(/[<>:"/\\|?*\x00-\x1f]/g, "_") || "attachment";
-            const savedPath = path37.join(outDir, safeName2);
-            fs37.writeFileSync(savedPath, buffer);
+            const safeName2 = path36.basename(att.filename).replace(/[<>:"/\\|?*\x00-\x1f]/g, "_") || "attachment";
+            const savedPath = path36.join(outDir, safeName2);
+            fs36.writeFileSync(savedPath, buffer);
             resolved.push(savedPath);
             console.log(`[file] Saved: ${savedPath} (${buffer.length}B)`);
           } catch (err) {
@@ -33845,6 +33860,7 @@ ${pathStr}` }];
 init_live();
 
 // src/provision-free.ts
+import { randomBytes as randomBytes4, randomUUID as randomUUID6 } from "node:crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync24, mkdirSync as mkdirSync16, readFileSync as readFileSync35, writeFileSync as writeFileSync13 } from "node:fs";
 import { dirname as dirname11, join as join46 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
@@ -33853,19 +33869,68 @@ var IDENTITY_FILE = "install-identity.json";
 function readContactEmailOf(parsed) {
   return typeof parsed?.contactEmail === "string" ? parsed.contactEmail.trim() : "";
 }
-function readInstallIdentity(stateDir) {
-  try {
-    const parsed = JSON.parse(readFileSync35(join46(stateDir, IDENTITY_FILE), "utf8"));
-    if (typeof parsed?.installId !== "string" || typeof parsed?.installSecret !== "string") return null;
+function loadOrCreateInstallIdentity(stateDir) {
+  const file2 = join46(stateDir, IDENTITY_FILE);
+  if (existsSync24(file2)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync35(file2, "utf8"));
+    } catch (e) {
+      throw new Error(
+        `${IDENTITY_FILE} \u5B58\u5728\u4F46\u4E0D\u662F\u5408\u6CD5 JSON\uFF08${e.message}\uFF09\u2014\u2014\u5220\u6389\u5B83\u91CD\u8DD1\u4F1A\u9886\u4E00\u628A\u65B0\u4EE4\u724C\uFF0C\u65E7\u7684\u90A3\u628A\u53D6\u4E0D\u56DE\u6765`
+      );
+    }
+    if (typeof parsed?.installId !== "string" || typeof parsed?.installSecret !== "string") {
+      throw new Error(`${IDENTITY_FILE} \u7F3A installId / installSecret \u5B57\u6BB5`);
+    }
     const email = readContactEmailOf(parsed);
     return {
       installId: parsed.installId,
       installSecret: parsed.installSecret,
       ...email ? { contactEmail: email } : {}
     };
+  }
+  const identity = {
+    // 服务端校验 installId 长度为 8..36、只允许字母数字和连字符；uuid 正好符合
+    installId: randomUUID6(),
+    // 服务端校验 installSecret 为 32..64 位十六进制
+    installSecret: randomBytes4(32).toString("hex")
+  };
+  mkdirSync16(stateDir, { recursive: true });
+  writeFileSync13(file2, JSON.stringify(identity, null, 2) + "\n", { mode: 384 });
+  try {
+    chmodSync2(file2, 384);
   } catch {
-    return null;
   }
+  return identity;
+}
+function readInstallIdentityDetailed(stateDir) {
+  const file2 = join46(stateDir, IDENTITY_FILE);
+  if (!existsSync24(file2)) return { ok: false, reason: "missing" };
+  let text;
+  try {
+    text = readFileSync35(file2, "utf8");
+  } catch (e) {
+    return { ok: false, reason: "corrupt", detail: `\u5B58\u5728\u4F46\u8BFB\u4E0D\u4E86\uFF08${e?.message ?? e}\uFF09` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (e) {
+    return { ok: false, reason: "corrupt", detail: `\u4E0D\u662F\u5408\u6CD5 JSON\uFF08${e?.message ?? e}\uFF09` };
+  }
+  if (typeof parsed?.installId !== "string" || typeof parsed?.installSecret !== "string") {
+    return { ok: false, reason: "corrupt", detail: "\u7F3A installId / installSecret \u5B57\u6BB5" };
+  }
+  const email = readContactEmailOf(parsed);
+  return {
+    ok: true,
+    identity: {
+      installId: parsed.installId,
+      installSecret: parsed.installSecret,
+      ...email ? { contactEmail: email } : {}
+    }
+  };
 }
 
 // src/optional/reporting/state.ts
@@ -34041,13 +34106,23 @@ function startReporting(opts) {
   const log = opts.log ?? (() => {
   });
   const startedAt = nowFn3();
-  const maybeIdentity = readInstallIdentity(stateDir);
-  if (!maybeIdentity) {
-    log("[reporting] \u6CA1\u6709\u53EF\u7528\u7684\u88C5\u673A\u8EAB\u4EFD\uFF0C\u4E0A\u62A5\u5173\u95ED");
-    return { stop() {
-    }, async beatNow() {
-    } };
+  const identityRead = readInstallIdentityDetailed(stateDir);
+  let maybeIdentity = null;
+  if (identityRead.ok) {
+    maybeIdentity = identityRead.identity;
+  } else if (identityRead.reason === "missing") {
+    try {
+      maybeIdentity = loadOrCreateInstallIdentity(stateDir);
+      log("[reporting] \u672C\u673A\u6CA1\u6709\u88C5\u673A\u8EAB\u4EFD\uFF080921 \u524D\u88C5\u7684 / \u4EE4\u724C\u662F\u4ECE\u522B\u5904\u62F7\u6765\u7684\uFF09\u2014\u2014 \u5DF2\u5C31\u5730\u8865\u5EFA\uFF0C\u6B64\u540E\u5F00\u59CB\u4E0A\u62A5");
+    } catch (e) {
+      log(`[reporting] \u8865\u5EFA\u88C5\u673A\u8EAB\u4EFD\u5931\u8D25\uFF1A${e?.message ?? e} \u2014\u2014 \u4E0A\u62A5\u5173\u95ED`);
+    }
+  } else {
+    log(`[reporting] install-identity.json \u635F\u574F\uFF08${identityRead.detail}\uFF09\u2014\u2014 \u4E0A\u62A5\u5173\u95ED\u3002\u523B\u610F\u4E0D\u91CD\u5EFA\uFF1A\u91CD\u5EFA\u7B49\u4E8E\u6362\u4E00\u53F0\u673A\u5668\uFF0C\u65E7\u4EE4\u724C\u518D\u4E5F\u53D6\u4E0D\u56DE\u6765`);
   }
+  if (!maybeIdentity) return { stop() {
+  }, async beatNow() {
+  } };
   const identity = maybeIdentity;
   const bootState = readReportState(stateDir);
   restoreCounters(bootState);
@@ -34272,13 +34347,13 @@ var DiscordAdapter = class _DiscordAdapter {
   }
   /** 发送媒体附件（图片/文件/音频）— discord.js channel.send({ files }) */
   async sendFile(target, message, attachment) {
-    const fs59 = await import("node:fs");
-    const path61 = await import("node:path");
-    if (!fs59.existsSync(attachment.path)) {
+    const fs58 = await import("node:fs");
+    const path60 = await import("node:path");
+    if (!fs58.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path61.basename(attachment.path);
-    const fileBuffer = fs59.readFileSync(attachment.path);
+    const filename = attachment.filename || path60.basename(attachment.path);
+    const fileBuffer = fs58.readFileSync(attachment.path);
     const filePayload = {
       attachment: fileBuffer,
       name: filename
@@ -34727,13 +34802,13 @@ var FeishuAdapter = class _FeishuAdapter {
   }
   /** 发送媒体附件（图片/文件） */
   async sendFile(target, message, attachment) {
-    const fs59 = await import("node:fs");
-    const path61 = await import("node:path");
-    if (!fs59.existsSync(attachment.path)) {
+    const fs58 = await import("node:fs");
+    const path60 = await import("node:path");
+    if (!fs58.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path61.basename(attachment.path);
-    const fileBuffer = fs59.readFileSync(attachment.path);
+    const filename = attachment.filename || path60.basename(attachment.path);
+    const fileBuffer = fs58.readFileSync(attachment.path);
     const safeTarget = target || this.config.defaultTarget || "";
     if (!safeTarget) throw new Error("Feishu sendFile: no target (\u4E3B\u52A8\u53D1\u9001\u9700\u914D\u7F6E defaultTarget \u6216\u4F20\u5165 target)");
     const receiveIdType = safeTarget.startsWith("ou_") ? "open_id" : "chat_id";
@@ -35330,8 +35405,8 @@ var FeishuAdapter = class _FeishuAdapter {
 
 // src/channels/wechat.ts
 import * as crypto5 from "crypto";
-import * as fs38 from "fs";
-import * as path38 from "path";
+import * as fs37 from "fs";
+import * as path37 from "path";
 import * as os4 from "os";
 import { promises as dns } from "dns";
 function sleep3(ms) {
@@ -35555,7 +35630,7 @@ function guessChatType(msg2, accountId) {
   return isGroup ? { type: "group", chatId: roomId || toId || String(msg2.from_user_id || "") } : { type: "dm", chatId: String(msg2.from_user_id || "") };
 }
 function mimeFromFilename(filename) {
-  const ext = path38.extname(filename).toLowerCase();
+  const ext = path37.extname(filename).toLowerCase();
   const map = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -35622,15 +35697,15 @@ var ContextTokenStore = class {
   cache = /* @__PURE__ */ new Map();
   filePath;
   constructor(stateDir, accountId) {
-    this.filePath = path38.join(stateDir, "weixin", `${accountId}.context-tokens.json`);
+    this.filePath = path37.join(stateDir, "weixin", `${accountId}.context-tokens.json`);
   }
   k(a, p) {
     return `${a}:${p}`;
   }
   restore() {
     try {
-      if (fs38.existsSync(this.filePath)) {
-        for (const [k, v] of Object.entries(JSON.parse(fs38.readFileSync(this.filePath, "utf-8"))))
+      if (fs37.existsSync(this.filePath)) {
+        for (const [k, v] of Object.entries(JSON.parse(fs37.readFileSync(this.filePath, "utf-8"))))
           this.cache.set(k, String(v));
       }
     } catch {
@@ -35638,11 +35713,11 @@ var ContextTokenStore = class {
   }
   save() {
     try {
-      const dir = path38.dirname(this.filePath);
-      if (!fs38.existsSync(dir)) fs38.mkdirSync(dir, { recursive: true });
+      const dir = path37.dirname(this.filePath);
+      if (!fs37.existsSync(dir)) fs37.mkdirSync(dir, { recursive: true });
       const obj = {};
       this.cache.forEach((v, k) => obj[k] = v);
-      fs38.writeFileSync(this.filePath, JSON.stringify(obj));
+      fs37.writeFileSync(this.filePath, JSON.stringify(obj));
     } catch {
     }
   }
@@ -35662,18 +35737,18 @@ var ContextTokenStore = class {
 };
 function loadSyncBuf(stateDir, accountId) {
   try {
-    const fp = path38.join(stateDir, "weixin", `${accountId}.sync.json`);
-    if (fs38.existsSync(fp)) return String(JSON.parse(fs38.readFileSync(fp, "utf-8")).sync_buf || "");
+    const fp = path37.join(stateDir, "weixin", `${accountId}.sync.json`);
+    if (fs37.existsSync(fp)) return String(JSON.parse(fs37.readFileSync(fp, "utf-8")).sync_buf || "");
   } catch {
   }
   return "";
 }
 function saveSyncBuf(stateDir, accountId, buf) {
   try {
-    const fp = path38.join(stateDir, "weixin", `${accountId}.sync.json`);
-    const dir = path38.dirname(fp);
-    if (!fs38.existsSync(dir)) fs38.mkdirSync(dir, { recursive: true });
-    fs38.writeFileSync(fp, JSON.stringify({ sync_buf: buf }));
+    const fp = path37.join(stateDir, "weixin", `${accountId}.sync.json`);
+    const dir = path37.dirname(fp);
+    if (!fs37.existsSync(dir)) fs37.mkdirSync(dir, { recursive: true });
+    fs37.writeFileSync(fp, JSON.stringify({ sync_buf: buf }));
   } catch {
   }
 }
@@ -35715,8 +35790,8 @@ var WechatAdapter = class {
     this.config = config2;
     this.baseUrl = config2.baseUrl?.replace(/\/$/, "") || ILINK_BASE_URL;
     this.cdnBaseUrl = config2.cdnBaseUrl?.replace(/\/$/, "") || WEIXIN_CDN_BASE_URL;
-    this.stateDir = config2.stateDir || path38.join(os4.homedir?.() || "/tmp", ".engine7");
-    if (!fs38.existsSync(this.stateDir)) fs38.mkdirSync(this.stateDir, { recursive: true });
+    this.stateDir = config2.stateDir || path37.join(os4.homedir?.() || "/tmp", ".engine7");
+    if (!fs37.existsSync(this.stateDir)) fs37.mkdirSync(this.stateDir, { recursive: true });
   }
   // --- ChannelAdapter interface ---
   onMessage(handler2) {
@@ -35769,8 +35844,8 @@ var WechatAdapter = class {
   }
   async sendFile(target, message, attachment) {
     const filePath = attachment.path;
-    if (!fs38.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-    const plaintext = fs38.readFileSync(filePath);
+    if (!fs37.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+    const plaintext = fs37.readFileSync(filePath);
     const mediaType = this.guessMediaType(filePath, attachment.mimeType);
     const filekey = crypto5.randomBytes(16).toString("hex");
     const aesKey = crypto5.randomBytes(16);
@@ -35802,7 +35877,7 @@ var WechatAdapter = class {
       aesKeyForApi,
       ciphertextSize: ciphertext.length,
       plaintextSize: rawsize,
-      filename: path38.basename(filePath),
+      filename: path37.basename(filePath),
       rawfilemd5,
       voiceDurationSec: attachment.voiceDurationSec
     });
@@ -36061,10 +36136,10 @@ var WechatAdapter = class {
       mediaRef.full_url,
       timeoutSec
     );
-    const tmpDir = path38.join(os4.tmpdir(), "weixin-media");
-    if (!fs38.existsSync(tmpDir)) fs38.mkdirSync(tmpDir, { recursive: true });
-    const tmpPath = path38.join(tmpDir, `${crypto5.randomUUID().replace(/-/g, "")}-${filename}`);
-    fs38.writeFileSync(tmpPath, data);
+    const tmpDir = path37.join(os4.tmpdir(), "weixin-media");
+    if (!fs37.existsSync(tmpDir)) fs37.mkdirSync(tmpDir, { recursive: true });
+    const tmpPath = path37.join(tmpDir, `${crypto5.randomUUID().replace(/-/g, "")}-${filename}`);
+    fs37.writeFileSync(tmpPath, data);
     return { url: `file://${tmpPath}`, filename, contentType, size: data.length };
   }
   // --- Internal: send helpers ---
@@ -36114,7 +36189,7 @@ var WechatAdapter = class {
     throw lastError;
   }
   guessMediaType(filePath, mimeType) {
-    const ext = path38.extname(filePath).toLowerCase();
+    const ext = path37.extname(filePath).toLowerCase();
     const mime = mimeType || mimeFromFilename(filePath);
     if (mime.startsWith("image/")) return MEDIA_IMAGE;
     if (mime.startsWith("video/")) return MEDIA_VIDEO;
@@ -36160,12 +36235,12 @@ init_voice_chat_tts_daemon();
 import { execFile as execFile2 } from "node:child_process";
 import { createInterface as createInterface2 } from "node:readline";
 import { promisify as promisify2 } from "node:util";
-import * as fs40 from "node:fs";
-import * as path40 from "node:path";
+import * as fs39 from "node:fs";
+import * as path39 from "node:path";
 import * as os5 from "node:os";
 import net3 from "net";
 var execFileAsync2 = promisify2(execFile2);
-var VOICE_DIR = path40.join(os5.tmpdir(), "engine-voice");
+var VOICE_DIR = path39.join(os5.tmpdir(), "engine-voice");
 function wavDurationSec(buf) {
   if (buf.length < 12 || buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WAVE") {
     throw new Error("wavDurationSec: not a RIFF/WAVE file");
@@ -36214,17 +36289,17 @@ function resolvePython(configuredPath) {
   }
   if (_pyCache) return _pyCache;
   const localAppData = process.env.LOCALAPPDATA;
-  const candidates = [
+  const candidates2 = [
     "python3",
     "python",
     // LOCALAPPDATA 缺席（非 Windows / 精简环境）时**不加这两个候选**：
     // 拼出来会是相对路径 'Microsoft/WindowsApps/python.exe'，那可能撞上 cwd 里的东西。
     ...localAppData ? [
-      path40.join(localAppData, "Microsoft", "WindowsApps", "python3.exe"),
-      path40.join(localAppData, "Microsoft", "WindowsApps", "python.exe")
+      path39.join(localAppData, "Microsoft", "WindowsApps", "python3.exe"),
+      path39.join(localAppData, "Microsoft", "WindowsApps", "python.exe")
     ] : []
   ];
-  for (const c of candidates) {
+  for (const c of candidates2) {
     try {
       __require("child_process").execFileSync(c, ["-c", "1"], { timeout: 5e3, stdio: "ignore" });
       _pyCache = c;
@@ -36241,8 +36316,8 @@ async function ttsCosyvoice(text, apiKey, model, voice, workspaceId, instruction
 }
 async function ttsCosyvoiceStream(text, cfg, onChunk) {
   const { apiKey, model, voice, workspaceId, instruction } = cfg;
-  fs40.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path40.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs39.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path39.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const script = `
 import sys, json, base64, threading
 import dashscope
@@ -36327,7 +36402,7 @@ print('EOS')
   header.writeUInt16LE(16, 34);
   header.write("data", 36);
   header.writeUInt32LE(pcm.length, 40);
-  fs40.writeFileSync(output, Buffer.concat([header, pcm]));
+  fs39.writeFileSync(output, Buffer.concat([header, pcm]));
   return output;
 }
 async function ttsCosyvoiceWorker(text, cfg, onChunk) {
@@ -36437,9 +36512,9 @@ async function ttsQwen3Opus(text, cfg) {
   const ogg = Buffer.from(await res.arrayBuffer());
   if (ogg.length < 20) throw new Error("qwen3-3060 opus: empty output");
   const durationMs = parseInt(res.headers.get("x-duration-ms") || "0", 10);
-  fs40.mkdirSync(VOICE_DIR, { recursive: true });
-  const oggPath = path40.join(VOICE_DIR, `tts_${Date.now()}.ogg`);
-  fs40.writeFileSync(oggPath, ogg);
+  fs39.mkdirSync(VOICE_DIR, { recursive: true });
+  const oggPath = path39.join(VOICE_DIR, `tts_${Date.now()}.ogg`);
+  fs39.writeFileSync(oggPath, ogg);
   return { oggPath, durationMs };
 }
 async function ttsGptsovits(text, c) {
@@ -36451,8 +36526,8 @@ async function ttsGptsovits(text, c) {
       "gptsovits \u672A\u914D\u7F6E\uFF1A\u9700\u8981 tools.my_voice \u91CC\u7684 gptsovitsUrl / gptsovitsRefWav / gptsovitsRefText\u3002\u53C2\u8003\u97F3\u9891\u4E0E\u53C2\u8003\u6587\u672C**\u5FC5\u987B\u9010\u5B57\u5BF9\u5E94**\uFF0C\u5426\u5219\u5408\u6210\u51FA\u6765\u7684\u58F0\u97F3\u4F1A\u5E26\u6742\u97F3\uFF080925 \u8E29\u8FC7\u88C1\u574F ref.wav \u7684\u5751\uFF09\u3002"
     );
   }
-  fs40.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path40.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs39.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path39.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const params = new URLSearchParams({
     text,
     text_language: "zh",
@@ -36463,13 +36538,13 @@ async function ttsGptsovits(text, c) {
   const res = await fetch(`${url}/?${params}`);
   if (!res.ok) throw new Error(`GPT-SoVITS API ${res.status}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs40.writeFileSync(output, buf);
+  fs39.writeFileSync(output, buf);
   return output;
 }
 var EDGE_VOICE = "zh-CN-XiaoxiaoNeural";
 async function ttsEdge(text) {
-  fs40.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path40.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
+  fs39.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path39.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
   const script = `
 import asyncio, edge_tts, sys
 async def main():
@@ -36514,8 +36589,8 @@ async function synthQwen3(text, _sink) {
     const pcmChunks = [];
     await ttsQwen3Local(text, { url: c.url, voice: c.voice, lang: c.lang }, (pcm2) => pcmChunks.push(pcm2));
     const pcm = Buffer.concat(pcmChunks);
-    fs40.mkdirSync(VOICE_DIR, { recursive: true });
-    const wavPath = path40.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+    fs39.mkdirSync(VOICE_DIR, { recursive: true });
+    const wavPath = path39.join(VOICE_DIR, `tts_${Date.now()}.wav`);
     const header = Buffer.alloc(44);
     header.write("RIFF", 0);
     header.writeUInt32LE(36 + pcm.length, 4);
@@ -36530,7 +36605,7 @@ async function synthQwen3(text, _sink) {
     header.writeUInt16LE(16, 34);
     header.write("data", 36);
     header.writeUInt32LE(pcm.length, 40);
-    fs40.writeFileSync(wavPath, Buffer.concat([header, pcm]));
+    fs39.writeFileSync(wavPath, Buffer.concat([header, pcm]));
     return { path: wavPath, format: "wav", unit: unit(text), voice: c.voice };
   }
 }
@@ -36555,22 +36630,22 @@ var DeskBuddyAdapter = class {
     try {
       if (!this.historyFile) {
         const os7 = __require("os");
-        const fs60 = __require("fs");
-        const path61 = __require("path");
-        const dir = path61.join(os7.homedir(), "xiaowen", "workspace", ".desktopBuddy");
-        fs60.mkdirSync(dir, { recursive: true });
-        this.historyFile = path61.join(dir, "history.json");
-        this._fs = fs60;
-      }
-      const fs59 = this._fs;
+        const fs59 = __require("fs");
+        const path60 = __require("path");
+        const dir = path60.join(os7.homedir(), "xiaowen", "workspace", ".desktopBuddy");
+        fs59.mkdirSync(dir, { recursive: true });
+        this.historyFile = path60.join(dir, "history.json");
+        this._fs = fs59;
+      }
+      const fs58 = this._fs;
       let arr = [];
       try {
-        arr = JSON.parse(fs59.readFileSync(this.historyFile, "utf-8")) || [];
+        arr = JSON.parse(fs58.readFileSync(this.historyFile, "utf-8")) || [];
       } catch {
       }
       arr.push({ ...entry, ts: (/* @__PURE__ */ new Date()).toLocaleString("zh-CN", { hour12: false }) });
       if (arr.length > 500) arr = arr.slice(-500);
-      fs59.writeFileSync(this.historyFile, JSON.stringify(arr, null, 1));
+      fs58.writeFileSync(this.historyFile, JSON.stringify(arr, null, 1));
     } catch (e) {
       console.warn("[deskBuddy] history write fail", e);
     }
@@ -36851,8 +36926,8 @@ var DeskBuddyAdapter = class {
 
 // src/channels/cc-bridge.ts
 init_live();
-import fs41 from "node:fs";
-import path41 from "node:path";
+import fs40 from "node:fs";
+import path40 from "node:path";
 import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket2 } from "ws";
 var DEFAULT_PORT = 16996;
 var CcBridgeAdapter = class {
@@ -36883,7 +36958,7 @@ var CcBridgeAdapter = class {
   // 只会在热加载后变成指向旧目录的幽灵路径（配置访问铁律）。
   outboxFile() {
     const sd = liveConfig.get("stateDir") || process.cwd();
-    return path41.join(sd, "state", "cc-bridge", "outbox.jsonl");
+    return path40.join(sd, "state", "cc-bridge", "outbox.jsonl");
   }
   /**
    * 读队列。**只有 ENOENT 才等于"空队列"。**
@@ -36897,7 +36972,7 @@ var CcBridgeAdapter = class {
   readOutbox() {
     let raw;
     try {
-      raw = fs41.readFileSync(this.outboxFile(), "utf8");
+      raw = fs40.readFileSync(this.outboxFile(), "utf8");
     } catch (e) {
       if (e?.code === "ENOENT") return [];
       throw e;
@@ -36927,9 +37002,9 @@ var CcBridgeAdapter = class {
   writeOutbox(items) {
     const file2 = this.outboxFile();
     const tmp = `${file2}.tmp`;
-    fs41.mkdirSync(path41.dirname(file2), { recursive: true });
-    fs41.writeFileSync(tmp, items.map((i) => JSON.stringify(i)).join("\n") + (items.length ? "\n" : ""), "utf8");
-    fs41.renameSync(tmp, file2);
+    fs40.mkdirSync(path40.dirname(file2), { recursive: true });
+    fs40.writeFileSync(tmp, items.map((i) => JSON.stringify(i)).join("\n") + (items.length ? "\n" : ""), "utf8");
+    fs40.renameSync(tmp, file2);
   }
   /** 入队（dedupe 不做 —— id 是新的，重复投递由 ack 收敛）。读/写失败都往外抛，不吞。 */
   enqueue(item) {
@@ -37007,7 +37082,7 @@ var CcBridgeAdapter = class {
   async connect() {
     const port = this.config.port ?? DEFAULT_PORT;
     try {
-      fs41.mkdirSync(path41.dirname(this.outboxFile()), { recursive: true });
+      fs40.mkdirSync(path40.dirname(this.outboxFile()), { recursive: true });
     } catch {
     }
     this.wss = new WebSocketServer2({
@@ -37180,14 +37255,14 @@ var CcBridgeAdapter = class {
   async sendFile(_target, message, attachment) {
     let st;
     try {
-      st = fs41.statSync(attachment.path);
+      st = fs40.statSync(attachment.path);
     } catch (e) {
       throw new Error(`\u9644\u4EF6\u4E0D\u5B58\u5728\uFF0C\u672A\u53D1\u9001\uFF1A${attachment.path}\uFF08${e?.code || e?.message}\uFF09`);
     }
     const file2 = {
       mode: "path-ref",
       path: attachment.path,
-      filename: attachment.filename || path41.basename(attachment.path),
+      filename: attachment.filename || path40.basename(attachment.path),
       mimeType: attachment.mimeType || "application/octet-stream",
       size: st.size,
       mtimeMs: Math.round(st.mtimeMs)
@@ -37543,20 +37618,20 @@ var ChannelManager = class {
 // src/session/session-manager.ts
 init_types();
 init_types();
-import * as path43 from "node:path";
-import * as fs43 from "node:fs";
+import * as path42 from "node:path";
+import * as fs42 from "node:fs";
 import * as crypto6 from "node:crypto";
 
 // src/session/reader.ts
 init_attachments();
-import * as fs42 from "node:fs";
-import * as path42 from "node:path";
+import * as fs41 from "node:fs";
+import * as path41 from "node:path";
 import * as readline2 from "node:readline";
 var SKIP_PRECOMPACT_THRESHOLD = 5 * 1024 * 1024;
 var TRANSCRIPT_READ_CHUNK_SIZE = 1024 * 1024;
 var MAX_TRANSCRIPT_READ_BYTES = 50 * 1024 * 1024;
 async function readSessionHeader(filePath) {
-  const stream = fs42.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs41.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream });
   return new Promise((resolve12) => {
     let resolved = false;
@@ -37587,7 +37662,7 @@ async function readSessionHeader(filePath) {
   });
 }
 async function readLargeFilePostBoundary(filePath) {
-  const stat4 = fs42.statSync(filePath);
+  const stat4 = fs41.statSync(filePath);
   const fileSize = stat4.size;
   const boundaryMarker = '"compact_boundary"';
   const CHUNK_SIZE = TRANSCRIPT_READ_CHUNK_SIZE;
@@ -37595,13 +37670,13 @@ async function readLargeFilePostBoundary(filePath) {
   let outLen = 0;
   let boundaryStartOffset = 0;
   const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
-  const fd = fs42.openSync(filePath, "r");
+  const fd = fs41.openSync(filePath, "r");
   try {
     let filePos = 0;
     let carryBuf;
     let carryLen = 0;
     while (filePos < fileSize) {
-      const bytesRead = fs42.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
+      const bytesRead = fs41.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
       if (bytesRead === 0) break;
       filePos += bytesRead;
       let scanBuf;
@@ -37653,7 +37728,7 @@ async function readLargeFilePostBoundary(filePath) {
       }
     }
   } finally {
-    fs42.closeSync(fd);
+    fs41.closeSync(fd);
   }
   const postBoundaryText = outBuf.subarray(0, outLen).toString("utf-8");
   return postBoundaryText.split("\n").filter((l) => l.trim().length > 0);
@@ -37777,7 +37852,7 @@ function recoverOrphanedParallelToolResults(allEntries, chain, byUuid, seen) {
   return result;
 }
 async function readSessionHistory(filePath) {
-  const stat4 = fs42.statSync(filePath);
+  const stat4 = fs41.statSync(filePath);
   const fileSize = stat4.size;
   if (fileSize > MAX_TRANSCRIPT_READ_BYTES) {
     console.warn(`[reader] Session file exceeds 50MB limit (${(fileSize / 1024 / 1024).toFixed(1)}MB), using chunked fd read with boundary skip`);
@@ -37816,7 +37891,7 @@ async function readSessionHistory(filePath) {
   return [...sessionStarts, ...filtered, ...restAttachments];
 }
 async function readAllLines(filePath) {
-  const stream = fs42.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs41.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream });
   const lines = [];
   return new Promise((resolve12, reject) => {
@@ -37970,12 +38045,12 @@ function extractText4(content) {
   return content.filter((b) => b.type === "text").map((b) => b.text || "").join("") || null;
 }
 function listSessions(sessionsDir) {
-  if (!fs42.existsSync(sessionsDir)) return [];
-  const files = fs42.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") || f.includes(".jsonl.")).map((f) => ({
-    file: path42.join(sessionsDir, f),
+  if (!fs41.existsSync(sessionsDir)) return [];
+  const files = fs41.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") || f.includes(".jsonl.")).map((f) => ({
+    file: path41.join(sessionsDir, f),
     id: f.replace(/\.jsonl.*$/, ""),
     // strip .jsonl and everything after (archived suffix)
-    modified: new Date(fs42.statSync(path42.join(sessionsDir, f)).mtimeMs)
+    modified: new Date(fs41.statSync(path41.join(sessionsDir, f)).mtimeMs)
   })).sort((a, b) => b.modified.getTime() - a.modified.getTime());
   return files;
 }
@@ -38010,24 +38085,24 @@ var SessionManager = class {
   constructor(config2) {
     this.config = config2;
     this.scopeConfig = config2.scopeConfig;
-    this.sessionsDir = path43.join(config2.stateDir, "agents", "main", "sessions");
-    this.indexPath = path43.join(this.sessionsDir, "session-index.json");
-    this.platformMapPath = path43.join(this.sessionsDir, "platform-map.json");
-    fs43.mkdirSync(this.sessionsDir, { recursive: true });
+    this.sessionsDir = path42.join(config2.stateDir, "agents", "main", "sessions");
+    this.indexPath = path42.join(this.sessionsDir, "session-index.json");
+    this.platformMapPath = path42.join(this.sessionsDir, "platform-map.json");
+    fs42.mkdirSync(this.sessionsDir, { recursive: true });
   }
   // === 索引操作 ===
   loadIndex() {
     try {
-      if (fs43.existsSync(this.indexPath)) {
-        const raw = fs43.readFileSync(this.indexPath, "utf-8");
+      if (fs42.existsSync(this.indexPath)) {
+        const raw = fs42.readFileSync(this.indexPath, "utf-8");
         const obj = JSON.parse(raw);
         this.index = new Map(Object.entries(obj));
         let fixed = 0;
         for (const [key, entry] of this.index) {
-          if (fs43.existsSync(entry.file)) continue;
-          const basename10 = path43.basename(entry.file);
-          const localPath = path43.join(this.sessionsDir, basename10);
-          if (fs43.existsSync(localPath)) {
+          if (fs42.existsSync(entry.file)) continue;
+          const basename10 = path42.basename(entry.file);
+          const localPath = path42.join(this.sessionsDir, basename10);
+          if (fs42.existsSync(localPath)) {
             entry.file = localPath;
             fixed++;
           }
@@ -38046,7 +38121,7 @@ var SessionManager = class {
     try {
       const obj = {};
       for (const [k, v] of this.index) obj[k] = v;
-      fs43.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
+      fs42.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
     } catch (err) {
       console.error(`[session] Failed to save index: ${err.message}`);
     }
@@ -38054,8 +38129,8 @@ var SessionManager = class {
   // === 平台映射 ===
   loadPlatformMap() {
     try {
-      if (fs43.existsSync(this.platformMapPath)) {
-        const raw = fs43.readFileSync(this.platformMapPath, "utf-8");
+      if (fs42.existsSync(this.platformMapPath)) {
+        const raw = fs42.readFileSync(this.platformMapPath, "utf-8");
         const obj = JSON.parse(raw);
         this.platformMap = new Map(Object.entries(obj));
         console.log(`[session] Platform map loaded: ${this.platformMap.size} entries`);
@@ -38067,7 +38142,7 @@ var SessionManager = class {
     try {
       const obj = {};
       for (const [k, v] of this.platformMap) obj[k] = v;
-      fs43.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
+      fs42.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
     } catch (err) {
       console.error(`[session] Failed to save platform map: ${err.message}`);
     }
@@ -38106,17 +38181,17 @@ var SessionManager = class {
    */
   getSessionFilePath(sessionId) {
     const entry = this.index.get(sessionId);
-    if (entry && fs43.existsSync(entry.file)) return entry.file;
-    const direct = path43.join(this.sessionsDir, `${sessionId}.jsonl`);
-    return fs43.existsSync(direct) ? direct : null;
+    if (entry && fs42.existsSync(entry.file)) return entry.file;
+    const direct = path42.join(this.sessionsDir, `${sessionId}.jsonl`);
+    return fs42.existsSync(direct) ? direct : null;
   }
   // === Writer 管理 ===
   getWriter(sessionId) {
     let writer = this.writers.get(sessionId);
     if (!writer) {
       const existing = this.index.get(sessionId);
-      if (existing && fs43.existsSync(existing.file)) {
-        const existingFileId = path43.basename(existing.file, ".jsonl");
+      if (existing && fs42.existsSync(existing.file)) {
+        const existingFileId = path42.basename(existing.file, ".jsonl");
         writer = new SessionWriter(this.sessionsDir, existingFileId);
         writer.open(this.config.workspace, sessionId);
       } else {
@@ -38128,7 +38203,7 @@ var SessionManager = class {
       this.saveIndex();
       this.writers.set(sessionId, writer);
       this.onWriterCreated?.(writer, sessionId);
-      console.log(`[session] ${existing ? "Resumed" : "New"}: ${sessionId} \u2192 ${path43.basename(writer.path)}`);
+      console.log(`[session] ${existing ? "Resumed" : "New"}: ${sessionId} \u2192 ${path42.basename(writer.path)}`);
     }
     return writer;
   }
@@ -38147,7 +38222,7 @@ var SessionManager = class {
     if (!writer) return null;
     try {
       this.lastArchiveCheck = Date.now();
-      const stat4 = fs43.statSync(writer.path);
+      const stat4 = fs42.statSync(writer.path);
       if (stat4.size < threshold) return null;
       const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
       const thresholdMB = (threshold / 1024 / 1024).toFixed(1);
@@ -38156,10 +38231,10 @@ var SessionManager = class {
       if (archivedPath) {
         this.index.set(sessionId, { file: writer.path, updatedAt: Date.now() });
         this.saveIndex();
-        const newSize = fs43.statSync(writer.path).size;
+        const newSize = fs42.statSync(writer.path).size;
         const oldSizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-        console.log(`[session] Archive complete: ${path43.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
-        const fileId = path43.basename(writer.path).replace(/\.jsonl$/, "");
+        console.log(`[session] Archive complete: ${path42.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
+        const fileId = path42.basename(writer.path).replace(/\.jsonl$/, "");
         this.purgeOldArchives(fileId, 3);
         return archivedPath;
       }
@@ -38175,15 +38250,15 @@ var SessionManager = class {
   purgeOldArchives(sessionId, keepCount = 3) {
     try {
       const dir = this.sessionsDir;
-      if (!fs43.existsSync(dir)) return;
-      const allFiles = fs43.readdirSync(dir);
+      if (!fs42.existsSync(dir)) return;
+      const allFiles = fs42.readdirSync(dir);
       const archiveFiles = allFiles.filter((f) => {
         if (!f.startsWith(sessionId)) return false;
         return f.includes(".archived.") || f.includes(".compaction.");
       }).map((f) => ({
         name: f,
-        path: path43.join(dir, f),
-        mtime: fs43.statSync(path43.join(dir, f)).mtimeMs
+        path: path42.join(dir, f),
+        mtime: fs42.statSync(path42.join(dir, f)).mtimeMs
       })).sort((a, b) => b.mtime - a.mtime);
       console.log(`[session] purgeOldArchives: sessionId=${sessionId.substring(0, 8)}... found=${archiveFiles.length} keep=${keepCount}`);
       if (archiveFiles.length <= keepCount) return;
@@ -38193,7 +38268,7 @@ var SessionManager = class {
           console.log(`[session] Skipping archived (kept for history): ${f.name}`);
           continue;
         }
-        fs43.unlinkSync(f.path);
+        fs42.unlinkSync(f.path);
         console.log(`[session] Purged old archive: ${f.name}`);
       }
       if (toDelete.length > 0) {
@@ -38242,29 +38317,29 @@ var SessionManager = class {
   /** 列出 session 的所有文件（当前 + 归档），按修改时间排序 */
   findAllSessionFiles(sessionId) {
     const results = [];
-    const mainFile = path43.join(this.sessionsDir, `${sessionId}.jsonl`);
-    if (fs43.existsSync(mainFile)) {
+    const mainFile = path42.join(this.sessionsDir, `${sessionId}.jsonl`);
+    if (fs42.existsSync(mainFile)) {
       results.push(mainFile);
     }
-    if (fs43.existsSync(this.sessionsDir)) {
-      const compactionFiles = fs43.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
+    if (fs42.existsSync(this.sessionsDir)) {
+      const compactionFiles = fs42.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
         name: f,
-        path: path43.join(this.sessionsDir, f),
-        mtime: fs43.statSync(path43.join(this.sessionsDir, f)).mtimeMs
+        path: path42.join(this.sessionsDir, f),
+        mtime: fs42.statSync(path42.join(this.sessionsDir, f)).mtimeMs
       })).sort((a, b) => b.mtime - a.mtime);
       if (compactionFiles.length > 0) {
         results.push(compactionFiles[0].path);
       }
     }
     results.sort((a, b) => {
-      const ta = fs43.statSync(a).mtimeMs;
-      const tb = fs43.statSync(b).mtimeMs;
+      const ta = fs42.statSync(a).mtimeMs;
+      const tb = fs42.statSync(b).mtimeMs;
       return ta - tb;
     });
     return results;
   }
   async findSessionFiles(sessionId) {
-    if (!fs43.existsSync(this.sessionsDir)) {
+    if (!fs42.existsSync(this.sessionsDir)) {
       console.log(`[session:find] SESSIONS_DIR not found: ${this.sessionsDir}`);
       return [];
     }
@@ -38276,15 +38351,15 @@ var SessionManager = class {
         return mappedFiles;
       }
       const indexedEntry = this.index.get(mappedId);
-      if (indexedEntry && fs43.existsSync(indexedEntry.file)) {
-        const fileUuid = path43.basename(indexedEntry.file, ".jsonl");
+      if (indexedEntry && fs42.existsSync(indexedEntry.file)) {
+        const fileUuid = path42.basename(indexedEntry.file, ".jsonl");
         return this.findAllSessionFiles(fileUuid);
       }
     }
     const allFiles = this.findAllSessionFiles(sessionId);
     if (allFiles.length > 0) {
       const labels = allFiles.map((f) => {
-        const base = path43.basename(f);
+        const base = path42.basename(f);
         return base.endsWith(".jsonl") ? base : `${base} (archived)`;
       });
       console.log(`[session:find] Found ${allFiles.length} file(s) for ${sessionId}: ${labels.join(", ")}`);
@@ -38292,9 +38367,9 @@ var SessionManager = class {
     }
     const indexed = this.index.get(sessionId);
     if (indexed) {
-      console.log(`[session:find] Index hit: ${sessionId} \u2192 ${indexed.file} (exists=${fs43.existsSync(indexed.file)})`);
-      if (fs43.existsSync(indexed.file)) {
-        return this.findAllSessionFiles(path43.basename(indexed.file, ".jsonl"));
+      console.log(`[session:find] Index hit: ${sessionId} \u2192 ${indexed.file} (exists=${fs42.existsSync(indexed.file)})`);
+      if (fs42.existsSync(indexed.file)) {
+        return this.findAllSessionFiles(path42.basename(indexed.file, ".jsonl"));
       }
     } else {
       console.log(`[session:find] Index miss: ${sessionId} (index has ${this.index.size} entries)`);
@@ -38323,8 +38398,8 @@ var SessionManager = class {
       return [];
     }
     files.sort((a, b) => {
-      const ta = fs43.statSync(a).mtimeMs;
-      const tb = fs43.statSync(b).mtimeMs;
+      const ta = fs42.statSync(a).mtimeMs;
+      const tb = fs42.statSync(b).mtimeMs;
       return ta - tb;
     });
     const latestFile = files[files.length - 1];
@@ -38332,7 +38407,7 @@ var SessionManager = class {
     if (!currentEntry || currentEntry.file !== latestFile) {
       this.index.set(sessionId, { file: latestFile, updatedAt: Date.now() });
       this.saveIndex();
-      console.log(`[session:restore] Synced index: ${sessionId} \u2192 ${path43.basename(latestFile)}`);
+      console.log(`[session:restore] Synced index: ${sessionId} \u2192 ${path42.basename(latestFile)}`);
     }
     const allMessages = [];
     for (const file2 of files) {
@@ -38371,7 +38446,7 @@ var SessionManager = class {
       if (isAttachmentMessage(m) && m.attachment.type === "relevant_memories") {
         for (const mem of m.attachment.memories) {
           rawCount++;
-          restoredPaths.add(path43.resolve(mem.path));
+          restoredPaths.add(path42.resolve(mem.path));
         }
       }
     }
@@ -38403,15 +38478,15 @@ var SessionManager = class {
    */
   rotateMainSession() {
     const entry = this.index.get("main");
-    if (!entry || !fs43.existsSync(entry.file)) return;
-    const oldFileId = path43.basename(entry.file, ".jsonl");
-    const stat4 = fs43.statSync(entry.file);
+    if (!entry || !fs42.existsSync(entry.file)) return;
+    const oldFileId = path42.basename(entry.file, ".jsonl");
+    const stat4 = fs42.statSync(entry.file);
     if (stat4.size < 1024) return;
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
     const archivedPath = `${entry.file}.archived.${ts}`;
-    fs43.renameSync(entry.file, archivedPath);
+    fs42.renameSync(entry.file, archivedPath);
     const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-    console.log(`[session] Archived: ${path43.basename(entry.file)} \u2192 ${path43.basename(archivedPath)} (${sizeMB}MB)`);
+    console.log(`[session] Archived: ${path42.basename(entry.file)} \u2192 ${path42.basename(archivedPath)} (${sizeMB}MB)`);
     const newWriter = new SessionWriter(this.sessionsDir);
     newWriter.open(this.config.workspace, "main");
     newWriter.writeModelChange(this.config.providerId, this.config.model);
@@ -38420,7 +38495,7 @@ var SessionManager = class {
     this.index.set("main", { file: newPath, updatedAt: Date.now() });
     this.saveIndex();
     this.purgeOldArchives(oldFileId, 3);
-    console.log(`[session] Rotated main: ${oldFileId}.jsonl \u2192 ${path43.basename(newPath)}`);
+    console.log(`[session] Rotated main: ${oldFileId}.jsonl \u2192 ${path42.basename(newPath)}`);
   }
   // === 迁移 ===
   /** 迁移旧索引：session-index.json 里有 "discord:xxx" 格式的 key 时，生成 UUID 替换 */
@@ -39312,12 +39387,12 @@ Examples:
 // src/tools/msg-husband.ts
 init_registry();
 init_live();
-import fs44 from "node:fs";
-import path44 from "node:path";
+import fs43 from "node:fs";
+import path43 from "node:path";
 function getHusbandFeishuId(workspace) {
-  const contactsPath = path44.join(workspace, "prompts", "contacts.md");
+  const contactsPath = path43.join(workspace, "prompts", "contacts.md");
   try {
-    const text = fs44.readFileSync(contactsPath, "utf-8");
+    const text = fs43.readFileSync(contactsPath, "utf-8");
     const m = text.match(/\|\s*翀哥\s*\|\s*(ou_[a-f0-9]+)\s*\|/);
     return m ? m[1] : null;
   } catch {
@@ -39459,8 +39534,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 fs59 = await import("node:fs");
-    if (!fs59.existsSync(filePath)) {
+    const fs58 = await import("node:fs");
+    if (!fs58.existsSync(filePath)) {
       return { content: `\u53D1\u9001\u5931\u8D25: \u6587\u4EF6\u4E0D\u5B58\u5728 ${filePath}`, isError: true };
     }
     const toIds = to ? to.split(",").map((s) => s.trim()).filter(Boolean) : [];
@@ -39488,7 +39563,7 @@ Examples:
       md: "text/markdown"
     };
     const mimeType = mimeTypeMap[ext] || "application/octet-stream";
-    const stat4 = fs59.statSync(filePath);
+    const stat4 = fs58.statSync(filePath);
     const sizeMB = stat4.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 };
@@ -39518,8 +39593,8 @@ Examples:
 init_live();
 init_registry();
 init_well_formed();
-import * as fs45 from "node:fs";
-import * as path45 from "node:path";
+import * as fs44 from "node:fs";
+import * as path44 from "node:path";
 var MIME_MAP = {
   ".jpg": "jpeg",
   ".jpeg": "jpeg",
@@ -39531,9 +39606,9 @@ var MIME_MAP = {
 var VIDEO_EXT = /\.(mp4|mov)$/i;
 var VIDEO_MAX_BYTES = 40 * 1024 * 1024;
 function resolveLatestImage(specifiedPath, mediaDir) {
-  if (specifiedPath && fs45.existsSync(specifiedPath)) return specifiedPath;
-  if (!fs45.existsSync(mediaDir)) return null;
-  const files = fs45.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp|mp4|mov)$/i.test(f)).map((f) => ({ name: f, p: path45.join(mediaDir, f), mtime: fs45.statSync(path45.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (specifiedPath && fs44.existsSync(specifiedPath)) return specifiedPath;
+  if (!fs44.existsSync(mediaDir)) return null;
+  const files = fs44.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp|mp4|mov)$/i.test(f)).map((f) => ({ name: f, p: path44.join(mediaDir, f), mtime: fs44.statSync(path44.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return files[0]?.p || null;
 }
 registry.register({
@@ -39564,21 +39639,21 @@ registry.register({
     if (!provider?.streamChat) {
       return { content: "Error: provider \u4E0D\u53EF\u7528\u3002", isError: true };
     }
-    const mediaDir = path45.join(ctx.stateDir, "media", "inbound");
+    const mediaDir = path44.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 = path45.extname(imagePath).toLowerCase();
+    const ext = path44.extname(imagePath).toLowerCase();
     if (VIDEO_EXT.test(imagePath)) {
-      const stat4 = fs45.statSync(imagePath);
+      const stat4 = fs44.statSync(imagePath);
       if (stat4.size > VIDEO_MAX_BYTES) {
         return { content: `Error: video too large (${(stat4.size / 1e6).toFixed(1)}MB > 40MB). Compress or trim first.`, isError: true };
       }
       const explicit = liveConfig.get("tools.my_eyes.videoBaseUrl");
       const baseUrl = explicit || providerCfg.baseUrl.replace(/\/anthropic\/?$/, "/v1").replace(/\/$/, "");
-      const vidB64 = fs45.readFileSync(imagePath).toString("base64");
+      const vidB64 = fs44.readFileSync(imagePath).toString("base64");
       try {
         const res = await fetch(`${baseUrl}/chat/completions`, {
           method: "POST",
@@ -39608,7 +39683,7 @@ registry.register({
       }
     }
     const mime = MIME_MAP[ext] || "jpeg";
-    const imgB64 = fs45.readFileSync(imagePath).toString("base64");
+    const imgB64 = fs44.readFileSync(imagePath).toString("base64");
     const userMsg = {
       role: "user",
       content: [
@@ -39686,7 +39761,7 @@ var TTS_PROVIDERS = [
 init_registry();
 
 // src/tools/opus-encoder.ts
-import * as fs46 from "node:fs";
+import * as fs45 from "node:fs";
 var FRAME_MS = 20;
 var PRESKIP_48K = 312;
 var OPUS_RATE = 48e3;
@@ -39803,7 +39878,7 @@ async function wavToOggOpusNative(wavPath) {
   const mod = await import("@discordjs/opus");
   const OpusEncoder = mod.OpusEncoder ?? mod.default?.OpusEncoder;
   if (!OpusEncoder) throw new Error("@discordjs/opus export shape unexpected");
-  const wav = parseWav(fs46.readFileSync(wavPath));
+  const wav = parseWav(fs45.readFileSync(wavPath));
   if (wav.channels !== 1) throw new Error(`unsupported ${wav.channels}ch (need mono)`);
   if (!NATIVE_RATES.includes(wav.sampleRate)) throw new Error(`unsupported rate ${wav.sampleRate}`);
   if (wav.pcm.length === 0) throw new Error("empty pcm data");
@@ -39839,7 +39914,7 @@ async function wavToOggOpusNative(wavPath) {
   }
   ogg.page(cur, pageGranule, false, true);
   const oggPath = wavPath.replace(/\.wav$/, ".ogg");
-  fs46.writeFileSync(oggPath, ogg.finish());
+  fs45.writeFileSync(oggPath, ogg.finish());
   return oggPath;
 }
 
@@ -39868,10 +39943,10 @@ function fallbackChainOf(raw) {
 init_live();
 
 // src/tools/tts/relay.ts
-import * as fs47 from "node:fs";
+import * as fs46 from "node:fs";
 import * as os6 from "node:os";
-import * as path46 from "node:path";
-var VOICE_DIR2 = path46.join(os6.tmpdir(), "engine-voice");
+import * as path45 from "node:path";
+var VOICE_DIR2 = path45.join(os6.tmpdir(), "engine-voice");
 var fetchFn = fetch;
 async function synthRelay(text, cfg) {
   const res = await fetchFn(`${cfg.baseUrl}/audio/speech`, {
@@ -39890,9 +39965,9 @@ async function synthRelay(text, cfg) {
   }
   const buf = Buffer.from(await res.arrayBuffer());
   if (buf.length < 20) throw new Error(`relay tts: \u54CD\u5E94\u4F53\u53EA\u6709 ${buf.length} \u5B57\u8282\uFF0C\u4E0D\u662F\u6709\u6548\u97F3\u9891`);
-  fs47.mkdirSync(VOICE_DIR2, { recursive: true });
-  const out = path46.join(VOICE_DIR2, `tts_relay_${Date.now()}.mp3`);
-  fs47.writeFileSync(out, buf);
+  fs46.mkdirSync(VOICE_DIR2, { recursive: true });
+  const out = path45.join(VOICE_DIR2, `tts_relay_${Date.now()}.mp3`);
+  fs46.writeFileSync(out, buf);
   return {
     path: out,
     format: "mp3",
@@ -40011,8 +40086,8 @@ function synthesize(id, text, sink) {
 // src/tools/my-voice.ts
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-import * as fs48 from "node:fs";
-import * as path47 from "node:path";
+import * as fs47 from "node:fs";
+import * as path46 from "node:path";
 var execFileAsync3 = promisify3(execFile3);
 async function toWav24kWithDuration(audioPath) {
   let wavPath = audioPath;
@@ -40030,15 +40105,15 @@ async function toWav24kWithDuration(audioPath) {
       "pcm_s16le",
       wavPath
     ], { timeout: 3e4 });
-    if (!fs48.existsSync(wavPath) || fs48.statSync(wavPath).size < 44) {
+    if (!fs47.existsSync(wavPath) || fs47.statSync(wavPath).size < 44) {
       throw new Error("toWav24k produced empty output");
     }
     try {
-      fs48.unlinkSync(audioPath);
+      fs47.unlinkSync(audioPath);
     } catch {
     }
   }
-  const durationSec = wavDurationSec(fs48.readFileSync(wavPath));
+  const durationSec = wavDurationSec(fs47.readFileSync(wavPath));
   return { wavPath, durationSec };
 }
 async function compressWav(wavPath) {
@@ -40056,7 +40131,7 @@ async function compressWav(wavPath) {
       "+faststart",
       m4aPath
     ], { timeout: 3e4 });
-    fs48.unlinkSync(wavPath);
+    fs47.unlinkSync(wavPath);
     return m4aPath;
   } catch {
     return wavPath;
@@ -40083,10 +40158,10 @@ async function wavToOggOpus(wavPath) {
       oggPath
     ], { timeout: 3e4 });
   }
-  if (!fs48.existsSync(oggPath) || fs48.statSync(oggPath).size < 20) {
+  if (!fs47.existsSync(oggPath) || fs47.statSync(oggPath).size < 20) {
     throw new Error("ogg/opus encode produced empty output");
   }
-  fs48.unlinkSync(wavPath);
+  fs47.unlinkSync(wavPath);
   return oggPath;
 }
 async function sendVoiceToMulticaIssue(text, issueId, opts) {
@@ -40101,7 +40176,7 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
   } catch (e) {
     return { content: `\u8BED\u97F3\u751F\u6210\u5931\u8D25\uFF08headless\u2192multaca\uFF09\uFF1A${e.message}\u3002\u8BF7\u7528\u6587\u5B57\u56DE\u590D\u4EE3\u66FF\u3002`, isError: true };
   }
-  if (!audioPath || !fs48.existsSync(audioPath)) {
+  if (!audioPath || !fs47.existsSync(audioPath)) {
     return { content: "\u8BED\u97F3\u751F\u6210\u5931\u8D25\uFF08headless\u2192multaca\uFF09\uFF1ATTS \u672A\u4EA7\u51FA\u6587\u4EF6\u3002\u8BF7\u7528\u6587\u5B57\u56DE\u590D\u4EE3\u66FF\u3002", isError: true };
   }
   if (audioPath.endsWith(".wav")) {
@@ -40111,21 +40186,21 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
       console.warn(`[my-voice:multaca] opus encode failed (${e.message}), attaching wav`);
     }
   }
-  const ext = path47.extname(audioPath).toLowerCase();
-  const sizeKB = fs48.statSync(audioPath).size / 1024;
+  const ext = path46.extname(audioPath).toLowerCase();
+  const sizeKB = fs47.statSync(audioPath).size / 1024;
   const voiceFile = `voice_${Date.now()}${ext}`;
-  const cwdCopy = path47.join(process.cwd(), voiceFile);
+  const cwdCopy = path46.join(process.cwd(), voiceFile);
   try {
-    fs48.copyFileSync(audioPath, cwdCopy);
+    fs47.copyFileSync(audioPath, cwdCopy);
   } catch (e) {
     try {
-      fs48.unlinkSync(audioPath);
+      fs47.unlinkSync(audioPath);
     } catch {
     }
     return { content: `\u8BED\u97F3\u6302\u8F7D\u5931\u8D25\uFF08\u62F7\u8D1D\u5230\u5DE5\u4F5C\u76EE\u5F55\uFF09\uFF1A${e.message}`, isError: true };
   }
   try {
-    fs48.unlinkSync(audioPath);
+    fs47.unlinkSync(audioPath);
   } catch {
   }
   const content = opts.caption || `\u{1F399}\uFE0F \u8BED\u97F3\u6D88\u606F\uFF08${text.length} \u5B57\uFF09`;
@@ -40154,13 +40229,13 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
     }
     if (!ok) throw new Error(`unexpected CLI output: ${String(stdout).slice(0, 200)}`);
     try {
-      fs48.unlinkSync(cwdCopy);
+      fs47.unlinkSync(cwdCopy);
     } catch {
     }
     return { content: `Voice sent to multaca issue ${issueId}! (${actualEngine}, ${sizeKB.toFixed(0)}KB, \u9644\u4EF6\u5DF2\u6302\u5230\u8BC4\u8BBA\u2014\u2014\u5728 multaca \u5BA2\u6237\u7AEF\u64AD\u653E)` };
   } catch (e) {
     try {
-      fs48.unlinkSync(cwdCopy);
+      fs47.unlinkSync(cwdCopy);
     } catch {
     }
     return { content: `\u8BED\u97F3\u6302\u5230 multaca issue \u5931\u8D25\uFF1A${e.message}\u3002\u8BF7\u7528\u6587\u5B57\u56DE\u590D\u4EE3\u66FF\u3002`, isError: true };
@@ -40277,10 +40352,10 @@ registry.register({
         audioPath = await compressWav(audioPath);
       }
     }
-    const ext = path47.extname(audioPath).toLowerCase();
+    const ext = path46.extname(audioPath).toLowerCase();
     const mimeMap = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4", ".ogg": "audio/ogg", ".silk": "audio/silk" };
     const mimeType = mimeMap[ext] || "audio/mpeg";
-    const sizeKB = fs48.statSync(audioPath).size / 1024;
+    const sizeKB = fs47.statSync(audioPath).size / 1024;
     try {
       await mgr.sendFile(resolvedChannel, target, caption, {
         path: audioPath,
@@ -40289,7 +40364,7 @@ registry.register({
         ...voiceDurationSec !== void 0 ? { voiceDurationSec } : {}
       });
       try {
-        fs48.unlinkSync(audioPath);
+        fs47.unlinkSync(audioPath);
       } catch {
       }
       return { content: `Voice sent! (${actualEngine}, ${sizeKB.toFixed(0)}KB, ${resolvedChannel})` };
@@ -40307,8 +40382,8 @@ registry.register({
 init_live();
 init_registry();
 init_well_formed();
-import * as fs49 from "node:fs";
-import * as path48 from "node:path";
+import * as fs48 from "node:fs";
+import * as path47 from "node:path";
 function getProxyDispatcher2() {
   const cfg = liveConfig.all();
   const proxy = cfg.providers?.xai?.proxy;
@@ -40322,7 +40397,7 @@ function getProxyDispatcher2() {
 }
 function dimsOf(p) {
   try {
-    const b = fs49.readFileSync(p);
+    const b = fs48.readFileSync(p);
     let w = 0, h = 0;
     if (b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
       w = b.readUInt32BE(16);
@@ -40445,9 +40520,9 @@ function registerPortrait(relPath, name) {
     const cur = cfg?.tools?.my_selfie?.references || cfg?.my_selfie?.references || [];
     const next = Array.isArray(cur) ? cur.filter((r) => r?.name !== name) : [];
     next.unshift({ name, path: relPath });
-    const path61 = cfg?.tools?.my_selfie ? "tools.my_selfie.references" : "my_selfie.references";
-    void liveConfig.set(path61, next);
-    console.log(`[my-selfie] \u5F62\u8C61\u5DF2\u767B\u8BB0\uFF1A${path61}[0] = ${relPath}`);
+    const path60 = cfg?.tools?.my_selfie ? "tools.my_selfie.references" : "my_selfie.references";
+    void liveConfig.set(path60, next);
+    console.log(`[my-selfie] \u5F62\u8C61\u5DF2\u767B\u8BB0\uFF1A${path60}[0] = ${relPath}`);
   } catch (e) {
     console.warn(`[my-selfie] \u5199\u5165 references \u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u672C\u6B21\u51FA\u56FE\uFF09: ${e.message}`);
   }
@@ -40728,10 +40803,10 @@ registry.register({
     const REFERENCES = getReferences(ctx);
     const refName = args2.reference || "default";
     const refEntry = REFERENCES.find((r) => r.name === refName) || REFERENCES[0];
-    let refPath = path48.join(ctx.workspace, refEntry.p);
+    let refPath = path47.join(ctx.workspace, refEntry.p);
     const adoptImg = args2.referenceImage?.trim();
     if (adoptImg) {
-      if (!fs49.existsSync(adoptImg)) {
+      if (!fs48.existsSync(adoptImg)) {
         return { content: `\u627E\u4E0D\u5230\u90A3\u5F20\u56FE\uFF1A${adoptImg}`, isError: true };
       }
       const acheck = dimsOf(adoptImg);
@@ -40742,16 +40817,16 @@ registry.register({
           isError: true
         };
       }
-      const adir = path48.join(ctx.workspace, "images");
-      if (!fs49.existsSync(adir)) fs49.mkdirSync(adir, { recursive: true });
-      const aext = (path48.extname(adoptImg) || ".png").toLowerCase();
+      const adir = path47.join(ctx.workspace, "images");
+      if (!fs48.existsSync(adir)) fs48.mkdirSync(adir, { recursive: true });
+      const aext = (path47.extname(adoptImg) || ".png").toLowerCase();
       const afname = `portrait_${Date.now()}${aext}`;
-      fs49.copyFileSync(adoptImg, path48.join(adir, afname));
+      fs48.copyFileSync(adoptImg, path47.join(adir, afname));
       registerPortrait(`images/${afname}`, refName);
-      refPath = path48.join(adir, afname);
+      refPath = path47.join(adir, afname);
       console.log(`[my-selfie] \u91C7\u7EB3\u73B0\u6210\u56FE\u5F53\u5F62\u8C61\uFF1Aimages/${afname}${acheck ? ` (${acheck})` : ""}`);
     }
-    if (provider !== "autodl" && !fs49.existsSync(refPath)) {
+    if (provider !== "autodl" && !fs48.existsSync(refPath)) {
       const cfgAll = liveConfig.all();
       const portraitDesc = resolvePortraitDesc(
         args2.portrait,
@@ -40776,16 +40851,16 @@ registry.register({
       } catch (e) {
         return { content: `\u5851\u9020\u5F62\u8C61\u5931\u8D25\uFF1A${e.message}`, isError: true };
       }
-      const pdir = path48.join(ctx.workspace, "images");
-      if (!fs49.existsSync(pdir)) fs49.mkdirSync(pdir, { recursive: true });
+      const pdir = path47.join(ctx.workspace, "images");
+      if (!fs48.existsSync(pdir)) fs48.mkdirSync(pdir, { recursive: true });
       const pfname = `portrait_${Date.now()}.png`;
-      fs49.writeFileSync(path48.join(pdir, pfname), portraitBuf);
+      fs48.writeFileSync(path47.join(pdir, pfname), portraitBuf);
       registerPortrait(`images/${pfname}`, refName);
-      refPath = path48.join(pdir, pfname);
+      refPath = path47.join(pdir, pfname);
       console.log(`[my-selfie] \u5F62\u8C61\u5DF2\u5B58 images/${pfname}\uFF0C\u7EE7\u7EED\u8FD9\u6B21\u81EA\u62CD`);
     }
     const resolution = args2.resolution || DEFAULT_RESOLUTION;
-    const refB64 = fs49.existsSync(refPath) ? fs49.readFileSync(refPath).toString("base64") : "";
+    const refB64 = fs48.existsSync(refPath) ? fs48.readFileSync(refPath).toString("base64") : "";
     let imageBuffer;
     try {
       if (provider === "autodl") {
@@ -40801,7 +40876,7 @@ registry.register({
           return { content: `Error: relay provider \u672A\u914D\u7F6E\u3002config \u91CC\u8981\u6709 models.providers.${cfgAll?.my_selfie?.relayProviderId || "7yi"} \u7684 baseUrl \u548C apiKey\u3002`, isError: true };
         }
         const model = cfgAll?.my_selfie?.relayModel || cfgAll?.tools?.my_selfie?.relayModel || "engine7-img-free";
-        const ext = path48.extname(refPath).toLowerCase();
+        const ext = path47.extname(refPath).toLowerCase();
         const mime = ext === ".png" ? "image/png" : ext === ".webp" ? "image/webp" : "image/jpeg";
         imageBuffer = await generateWithRelay(refB64, fullPrompt, mime, relay.baseUrl, relay.apiKey, model);
       } else {
@@ -40810,11 +40885,11 @@ registry.register({
     } catch (err) {
       return { content: `Selfie generation failed: ${err.message}`, isError: true };
     }
-    const imagesDir = path48.join(ctx.workspace, "images");
-    if (!fs49.existsSync(imagesDir)) fs49.mkdirSync(imagesDir, { recursive: true });
+    const imagesDir = path47.join(ctx.workspace, "images");
+    if (!fs48.existsSync(imagesDir)) fs48.mkdirSync(imagesDir, { recursive: true });
     const filename = `selfie_${Date.now()}.jpg`;
-    const outputPath = path48.join(imagesDir, filename);
-    fs49.writeFileSync(outputPath, imageBuffer);
+    const outputPath = path47.join(imagesDir, filename);
+    fs48.writeFileSync(outputPath, imageBuffer);
     const mgr = ctx.channelManager;
     if (mgr) {
       const resolvedChannel = ctx.channel || "feishu";
@@ -40825,11 +40900,11 @@ registry.register({
           mimeType: "image/jpeg"
         });
       } catch (err) {
-        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path48.resolve(outputPath)}`, isError: false };
+        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path47.resolve(outputPath)}`, isError: false };
       }
       return { content: `Selfie sent! Mode: ${mode}, Provider: ${provider}, Ref: ${refEntry.name}` };
     }
-    return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path48.resolve(outputPath)}` };
+    return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path47.resolve(outputPath)}` };
   },
   isConcurrencySafe: () => false,
   interruptBehavior: () => "block",
@@ -41381,8 +41456,8 @@ ${lines.join("\n")}` };
 init_registry();
 init_live();
 init_clock();
-import * as fs50 from "node:fs";
-import * as path49 from "node:path";
+import * as fs49 from "node:fs";
+import * as path48 from "node:path";
 import { exec as exec2, spawn as spawn6 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 var execAsync = promisify4(exec2);
@@ -41391,9 +41466,9 @@ function getServices() {
 }
 function serviceLogPath(fileName) {
   const stateDir = String(liveConfig.get("stateDir") ?? "");
-  const logDir = path49.join(stateDir, "logs");
-  if (!fs50.existsSync(logDir)) fs50.mkdirSync(logDir, { recursive: true });
-  return path49.join(logDir, fileName);
+  const logDir = path48.join(stateDir, "logs");
+  if (!fs49.existsSync(logDir)) fs49.mkdirSync(logDir, { recursive: true });
+  return path48.join(logDir, fileName);
 }
 async function runCmd(cmd, timeoutMs = 15e3) {
   try {
@@ -41712,16 +41787,16 @@ var EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
 init_planModeState();
 
 // src/utils/plans.ts
-import * as fs51 from "node:fs";
-import * as path50 from "node:path";
+import * as fs50 from "node:fs";
+import * as path49 from "node:path";
 import * as crypto7 from "node:crypto";
 var MAX_SLUG_RETRIES = 10;
 function generateSlug() {
   return crypto7.randomBytes(4).toString("hex");
 }
 function getPlansDirectory(stateDir) {
-  const plansDir = path50.join(stateDir, "plans");
-  fs51.mkdirSync(plansDir, { recursive: true });
+  const plansDir = path49.join(stateDir, "plans");
+  fs50.mkdirSync(plansDir, { recursive: true });
   return plansDir;
 }
 var planSlugCache = /* @__PURE__ */ new Map();
@@ -41731,8 +41806,8 @@ function getPlanSlug(sessionId, stateDir) {
     const plansDir = getPlansDirectory(stateDir);
     for (let i = 0; i < MAX_SLUG_RETRIES; i++) {
       slug = generateSlug();
-      const filePath = path50.join(plansDir, `${slug}.md`);
-      if (!fs51.existsSync(filePath)) {
+      const filePath = path49.join(plansDir, `${slug}.md`);
+      if (!fs50.existsSync(filePath)) {
         break;
       }
     }
@@ -41743,21 +41818,21 @@ function getPlanSlug(sessionId, stateDir) {
 function getPlanFilePath(sessionId, stateDir, agentId) {
   const slug = getPlanSlug(sessionId, stateDir);
   if (!agentId) {
-    return path50.join(getPlansDirectory(stateDir), `${slug}.md`);
+    return path49.join(getPlansDirectory(stateDir), `${slug}.md`);
   }
-  return path50.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
+  return path49.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
 }
 function getPlan(sessionId, stateDir, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
   try {
-    return fs51.readFileSync(filePath, "utf-8");
+    return fs50.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writePlan(sessionId, stateDir, content, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
-  fs51.writeFileSync(filePath, content, "utf-8");
+  fs50.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 
@@ -42398,8 +42473,8 @@ init_features2();
 init_agent_registry();
 
 // src/commands/work.ts
-import * as fs56 from "node:fs";
-import * as path56 from "node:path";
+import * as fs55 from "node:fs";
+import * as path55 from "node:path";
 registerCommand({
   name: "work",
   description: "\u5DE5\u4F5C\u6A21\u5F0F\uFF1A\u65E0\u53C2\u770B\u72B6\u6001\uFF0Con=\u5F3A\u5236work\uFF0Coff=\u5F3A\u5236emotion\uFF0Cauto=\u81EA\u52A8\u5224\u5B9A",
@@ -42412,20 +42487,20 @@ registerCommand({
   ],
   handler: async (ctx, deps) => {
     const mode = (ctx.args.mode || "").trim().toLowerCase();
-    const modeFile = path56.join(deps.config.workspace, ".work-mode");
+    const modeFile = path55.join(deps.config.workspace, ".work-mode");
     if (mode === "on" || mode === "off") {
-      fs56.writeFileSync(modeFile, mode, "utf8");
+      fs55.writeFileSync(modeFile, mode, "utf8");
       await ctx.reply(mode === "on" ? "\u5DE5\u4F5C\u6A21\u5F0F\u5DF2\u5F3A\u5236 **work**\uFF08\u6240\u6709\u6D88\u606F\u5168\u91CF\u4E0A\u4E0B\u6587\uFF0C\u4E0B\u4E00\u6761\u751F\u6548\uFF09" : "\u5DE5\u4F5C\u6A21\u5F0F\u5DF2\u5F3A\u5236 **emotion**\uFF08\u6240\u6709\u6D88\u606F\u8F7B\u91CF\u95F2\u804A\uFF0C\u4E0B\u4E00\u6761\u751F\u6548\uFF09");
     } else if (mode === "auto") {
       try {
-        fs56.unlinkSync(modeFile);
+        fs55.unlinkSync(modeFile);
       } catch {
       }
       await ctx.reply("\u5DE5\u4F5C\u6A21\u5F0F\u5DF2\u6062\u590D **auto**\uFF08emotion_state_machine \u9010\u6761\u81EA\u52A8\u5224\u5B9A\uFF09");
     } else {
       let cur = "auto";
       try {
-        cur = fs56.readFileSync(modeFile, "utf8").trim() || "auto";
+        cur = fs55.readFileSync(modeFile, "utf8").trim() || "auto";
       } catch {
       }
       const hint = cur === "on" ? "\uFF08\u5F3A\u5236 work\uFF1A\u5168\u91CF\u4E0A\u4E0B\u6587\uFF09" : cur === "off" ? "\uFF08\u5F3A\u5236 emotion\uFF1A\u8F7B\u91CF\u4E0A\u4E0B\u6587\uFF09" : "\uFF08\u6BCF\u6761\u6D88\u606F\u7531 emotion_state_machine \u81EA\u52A8\u5224\u5B9A\uFF09";
@@ -42895,8 +42970,8 @@ ${err.stack}`);
 });
 
 // src/commands/model.ts
-import * as fs57 from "node:fs";
-import * as path57 from "node:path";
+import * as fs56 from "node:fs";
+import * as path56 from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function collectModels(config2) {
   const aliases = config2.modelAliases || {};
@@ -42928,11 +43003,11 @@ function resolveConfigWritePath(config2, label) {
   const configPath2 = config2._configFilePath;
   if (!configPath2) return void 0;
   let writePath = configPath2;
-  if (configPath2 && !fs57.existsSync(configPath2)) {
+  if (configPath2 && !fs56.existsSync(configPath2)) {
     const __pFile = fileURLToPath8(import.meta.url);
-    const __pDir = path57.dirname(__pFile);
-    const altPath = path57.join(path57.resolve(__pDir, "../configs"), path57.basename(configPath2));
-    if (fs57.existsSync(altPath)) {
+    const __pDir = path56.dirname(__pFile);
+    const altPath = path56.join(path56.resolve(__pDir, "../configs"), path56.basename(configPath2));
+    if (fs56.existsSync(altPath)) {
       console.warn(`[${label}] Config not found at ${configPath2}, falling back to ${altPath}`);
       writePath = altPath;
     }
@@ -42991,22 +43066,22 @@ ${lines.join("\n")}`);
       await ctx.reply(wasOverride ? `Reset to default: **${defaultRef}** (auto-routing restored, fallback cooldowns cleared)` : `Already using default: **${defaultRef}**`);
       return;
     }
-    const candidates = matchModels(input, aliases, available);
-    if (candidates.length === 0) {
+    const candidates2 = matchModels(input, aliases, available);
+    if (candidates2.length === 0) {
       await ctx.reply(`No model matching "${input}". Use \`/model\` to see list.`);
       return;
     }
-    if (candidates.length > 1) {
-      const lines = candidates.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
-      const more = candidates.length > 10 ? `
-... and ${candidates.length - 10} more` : "";
+    if (candidates2.length > 1) {
+      const lines = candidates2.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
+      const more = candidates2.length > 10 ? `
+... and ${candidates2.length - 10} more` : "";
       await ctx.reply(`Multiple matches for "${input}":
 ${lines.join("\n")}${more}
 
-Use full ref like \`/model ${candidates[0].ref}\``);
+Use full ref like \`/model ${candidates2[0].ref}\``);
       return;
     }
-    const target = candidates[0].ref;
+    const target = candidates2[0].ref;
     let targetDeps = deps.modelDepsCache.get(target);
     if (!targetDeps) {
       targetDeps = deps.createModelDeps(target);
@@ -43044,8 +43119,8 @@ Use full ref like \`/model ${candidates[0].ref}\``);
       const writer = deps.sessions.getWriter(sid);
       writer.writeModelChange(pid, mid);
     }
-    console.log(`[model] Switched to ${target} (${candidates[0].name})`);
-    await ctx.reply(`Switched to **${target}** (${candidates[0].name})
+    console.log(`[model] Switched to ${target} (${candidates2[0].name})`);
+    await ctx.reply(`Switched to **${target}** (${candidates2[0].name})
 Auto-routing disabled \u2014 all messages use this model.
 \`/model auto\` to restore default.`);
   }
@@ -43068,35 +43143,35 @@ Usage: \`/primary provider/model\` to persist (restart required)`);
       return;
     }
     const { aliases, available } = collectModels(deps.config);
-    const candidates = matchModels(input, aliases, available);
-    if (candidates.length === 0) {
+    const candidates2 = matchModels(input, aliases, available);
+    if (candidates2.length === 0) {
       await ctx.reply(`No model matching "${input}".`);
       return;
     }
-    if (candidates.length > 1) {
-      const lines = candidates.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
+    if (candidates2.length > 1) {
+      const lines = candidates2.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
       await ctx.reply(`Multiple matches:
 ${lines.join("\n")}
 
-Use full ref like \`/primary ${candidates[0].ref}\``);
+Use full ref like \`/primary ${candidates2[0].ref}\``);
       return;
     }
-    const target = candidates[0].ref;
+    const target = candidates2[0].ref;
     if (!configPath2 || !writePath) {
       await ctx.reply(`\u26A0\uFE0F Config file path not available, cannot persist. Set manually in config.`);
       return;
     }
     try {
-      const raw = await fs57.promises.readFile(writePath, "utf-8");
+      const raw = await fs56.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 fs57.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+      await fs56.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})
+      await ctx.reply(`\u2705 Primary model set to **${target}** (${candidates2[0].name})
 Written to config, hot-reloading provider chain now.`);
     } catch (err) {
       await ctx.reply(`\u26A0\uFE0F Failed to write config: ${err.message}`);
@@ -43122,26 +43197,26 @@ Usage: \`/vision-primary provider/model\` to persist (hot-reload)
       return;
     }
     const { aliases, available } = collectModels(deps.config);
-    const candidates = matchModels(input, aliases, available);
-    if (candidates.length === 0) {
+    const candidates2 = matchModels(input, aliases, available);
+    if (candidates2.length === 0) {
       await ctx.reply(`No model matching "${input}".`);
       return;
     }
-    if (candidates.length > 1) {
-      const lines = candidates.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
+    if (candidates2.length > 1) {
+      const lines = candidates2.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
       await ctx.reply(`Multiple matches:
 ${lines.join("\n")}
 
-Use full ref like \`/vision-primary ${candidates[0].ref}\``);
+Use full ref like \`/vision-primary ${candidates2[0].ref}\``);
       return;
     }
-    const target = candidates[0].ref;
+    const target = candidates2[0].ref;
     if (!configPath2 || !writePath) {
       await ctx.reply(`\u26A0\uFE0F Config file path not available, cannot persist. Set manually in config.`);
       return;
     }
     try {
-      const raw = await fs57.promises.readFile(writePath, "utf-8");
+      const raw = await fs56.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`);
@@ -43149,14 +43224,14 @@ Use full ref like \`/vision-primary ${candidates[0].ref}\``);
       }
       if (input === "auto" || input === "reset") {
         delete cfg.agents.defaults.model.vision;
-        await fs57.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+        await fs56.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
         console.log(`[vision-primary] Cleared vision primary in ${writePath}`);
         await ctx.reply(`\u2705 Vision primary cleared (auto). Written to config. Hot-reload will apply.`);
       } else {
         cfg.agents.defaults.model.vision = target;
-        await fs57.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+        await fs56.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
         console.log(`[vision-primary] Persisted vision=${target} to ${writePath}`);
-        await ctx.reply(`\u2705 Vision primary set to **${target}** (${candidates[0].name})
+        await ctx.reply(`\u2705 Vision primary set to **${target}** (${candidates2[0].name})
 Written to config. Hot-reload will apply.`);
       }
     } catch (err) {
@@ -43188,20 +43263,20 @@ Available models: use \`/model\` to see full list
       return;
     }
     const { aliases, available } = collectModels(deps.config);
-    const candidates = matchModels(input, aliases, available);
-    if (candidates.length === 0) {
+    const candidates2 = matchModels(input, aliases, available);
+    if (candidates2.length === 0) {
       await ctx.reply(`No model matching "${input}".`);
       return;
     }
-    if (candidates.length > 1) {
-      const lines = candidates.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
+    if (candidates2.length > 1) {
+      const lines = candidates2.slice(0, 10).map((a) => `- \`${a.ref}\` \u2014 ${a.name}`);
       await ctx.reply(`Multiple matches:
 ${lines.join("\n")}
 
-Use full ref like \`/vision-model ${candidates[0].ref}\``);
+Use full ref like \`/vision-model ${candidates2[0].ref}\``);
       return;
     }
-    const target = candidates[0].ref;
+    const target = candidates2[0].ref;
     let targetDeps = deps.modelDepsCache.get(`vision:${target}`);
     if (!targetDeps) {
       targetDeps = deps.createModelDeps(target);
@@ -43214,7 +43289,7 @@ Use full ref like \`/vision-model ${candidates[0].ref}\``);
     deps.setVisionOverride(target);
     deps.setVisionDeps(targetDeps);
     console.log(`[vision-model] Override: ${target}`);
-    await ctx.reply(`Vision switched to **${target}** (${candidates[0].name}) (immediate)
+    await ctx.reply(`Vision switched to **${target}** (${candidates2[0].name}) (immediate)
 \`/vision-model auto\` to restore default.`);
   }
 });
@@ -43562,7 +43637,7 @@ async function startEngine(config2, opts) {
     const { initSessionMemory: initSessionMemory2 } = await Promise.resolve().then(() => (init_sessionMemory(), sessionMemory_exports));
     initSessionMemory2({
       workspace: config2.workspace,
-      stateDir: path60.join(config2.stateDir, "session-memory"),
+      stateDir: path59.join(config2.stateDir, "session-memory"),
       provider,
       model: config2.provider.modelId || config2.model || "deepseek-v4-flash",
       features: config2.profile.features
@@ -44033,7 +44108,7 @@ async function startEngine(config2, opts) {
     };
     const startReportingNow = () => {
       stopReporting();
-      reportingHandle = startReporting({ stateDir: config2.stateDir });
+      reportingHandle = startReporting({ stateDir: config2.stateDir, log: (m) => console.log(m) });
     };
     const reportingEnabled = () => liveConfig.get("reporting.enabled") !== false;
     reloadOrchestrator.register({
@@ -44091,11 +44166,7 @@ async function startEngine(config2, opts) {
 }
 
 // src/main.ts
-import { readFileSync as readFileSync48 } from "node:fs";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
-import { dirname as dirname16, join as join66 } from "node:path";
-var __dirname2 = dirname16(fileURLToPath9(import.meta.url));
-var pkg = JSON.parse(readFileSync48(join66(__dirname2, "..", "package.json"), "utf-8"));
+init_version();
 var epipeSeen = false;
 process.on("uncaughtException", (err) => {
   const code = err?.code ?? "";
@@ -44168,7 +44239,7 @@ if (args[0] === "features") {
 var secretsPath = configPath ? loadSecretsEnvForConfig(configPath) : null;
 console.log(secretsPath ? `[secrets] Loaded API keys from ${secretsPath}` : "[secrets] \u672A\u627E\u5230 .env \u2014\u2014 \u82E5 config \u7528\u7684\u662F env:XXX_API_KEY \u5360\u4F4D\u7B26\uFF0C\u5C06\u89E3\u6790\u5931\u8D25\uFF08401\uFF09");
 var config = loadConfig(configPath);
-console.log(`=== Engine 7 v${pkg.version} ===`);
+console.log(`=== Engine 7 v${readEngineVersion()} ===`);
 console.log(`PID: ${process.pid}`);
 console.log(configSummary(config));
 startEngine(config, { cliMode: true }).catch((err) => {