engine7 7.1.112 → 7.1.113

package/dist/engine-startup.mjs

@@ -2445,14 +2445,14 @@ var init_live = __esm({
       }
       /** 把改动写回 config 文件对应段（找不到文件路径则只内存生效） */
       async persistToFile(dotPath, val) {
-        const fs58 = await import("node:fs");
+        const fs59 = await import("node:fs");
         const cfgPath = this.current?._configFilePath;
-        if (!cfgPath || !fs58.existsSync(cfgPath)) {
+        if (!cfgPath || !fs59.existsSync(cfgPath)) {
           console.warn(`[liveConfig] set: no config file path, in-memory only (${dotPath})`);
           return;
         }
         try {
-          const raw = JSON.parse(fs58.readFileSync(cfgPath, "utf-8"));
+          const raw = JSON.parse(fs59.readFileSync(cfgPath, "utf-8"));
           const keys = dotPath.split(".");
           let o = raw;
           for (let i = 0; i < keys.length - 1; i++) {
@@ -2460,7 +2460,7 @@ var init_live = __esm({
             o = o[keys[i]];
           }
           o[keys[keys.length - 1]] = val;
-          fs58.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+          fs59.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
           console.log(`[liveConfig] persisted ${dotPath} = ${JSON.stringify(val)} to ${cfgPath}`);
           markSelfWrite();
         } catch (e) {
@@ -4004,7 +4004,7 @@ var init_skill_gate = __esm({
     DEVELOPMENT_HINTS = /代码|源码|编译|构建|测试|报错|错误|bug|修复|排查|调试|实现|开发|接口|脚本|函数|类型|依赖|部署|代码 review|code|build|test|debug|implement|fix|compile|typescript|javascript|python|git/i;
     TECHNICAL_OBJECTS = /代码|源码|仓库|项目|模块|插件|接口|服务|引擎|engine|voice[- ]?chat|docker|容器|llm|模型|延迟|工具|脚本|函数|依赖|部署|分支|commit|api/i;
     TECHNICAL_ACTIONS = /优化|瘦身|提速|迁移|重构|接线|收尾|改动|加上|删掉|换成|裁剪|升级|降级|修|接入|拆分|合并|调试|排查/i;
-    USER_CHANNELS = /* @__PURE__ */ new Set(["discord", "feishu", "wechat", "telegram", "cli", "console", "voice-chat", "deskBuddy"]);
+    USER_CHANNELS = /* @__PURE__ */ new Set(["discord", "feishu", "wechat", "telegram", "cli", "console", "voice-chat", "deskBuddy", "ccBridge"]);
     loadedBySession = /* @__PURE__ */ new Map();
     MAX_TRACKED_SESSIONS = 100;
   }
@@ -4038,9 +4038,9 @@ function isAutoMemPath(absolutePath, workspace) {
   return normalizedPath.startsWith(getAutoMemPath(workspace));
 }
 async function ensureMemoryDirExists(memoryDir) {
-  const fs58 = await import("node:fs");
+  const fs59 = await import("node:fs");
   try {
-    await fs58.promises.mkdir(memoryDir, { recursive: true });
+    await fs59.promises.mkdir(memoryDir, { recursive: true });
   } catch (e) {
     const code = e?.code;
     if (code !== "EEXIST") {
@@ -6717,7 +6717,13 @@ var init_anthropic_provider = __esm({
             thinking: { type: "enabled", budget_tokens: thinkingBudget }
           } : params.disableThinking ? {
             // 显式关闭 thinking（智谱 GLM-5.1 需要传 disabled 才真正关闭）
-            thinking: { type: "disabled" },
+            // 0928 修：MiniMax M3.1-Flash 系强制 adaptive，disabled 直接 400（码 2013，
+            // 实证：proactive 后台调用换 M3.1 后 LLM UNREACHABLE）——该系降级发 adaptive
+            ...params.model?.includes("M3.1-Flash") ? {
+              thinking: { type: "adaptive" }
+            } : {
+              thinking: { type: "disabled" }
+            },
             ...params.temperature !== void 0 ? { temperature: params.temperature } : {}
           } : {
             ...params.temperature !== void 0 ? { temperature: params.temperature } : {}
@@ -7786,7 +7792,10 @@ function loadConfig(configPath) {
     channels: agentDefaults.channels || [],
     extensions: agentDefaults.extensions,
     maxTurns: agentDefaults.maxTurns,
-    devMode: agentDefaults.devMode === true
+    // ⚠️ **默认 true**（0928 翀哥拍板）：开源项目，功能不按 license 分档。
+    // 要收起来才显式配 `agents.defaults.devMode: false`。
+    // 反过来写（=== true）时，任何没手配这一格的配置都会静默落进"基础引擎模式"。
+    devMode: agentDefaults.devMode !== false
   };
   const rawSession = raw.session || {};
   const sessionScope = Object.keys(rawSession).length > 0 ? { ...rawSession } : void 0;
@@ -8353,7 +8362,7 @@ async function acquireLock(inboxPath) {
   for (let i = 0; i < LOCK_RETRIES; i++) {
     if (await isLockStale(lockPath2)) {
       try {
-        await import("node:fs/promises").then((fs58) => fs58.rm(lockPath2, { force: true }));
+        await import("node:fs/promises").then((fs59) => fs59.rm(lockPath2, { force: true }));
       } catch {
       }
     }
@@ -8361,7 +8370,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((fs58) => fs58.rm(lockPath2, { force: true }));
+          await import("node:fs/promises").then((fs59) => fs59.rm(lockPath2, { force: true }));
         } catch {
         }
       };
@@ -10001,9 +10010,9 @@ Follow these principles when generating episodic memories:
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync6, existsSync as existsSync14, readdirSync as readdirSync2 } from "node:fs";
 import { join as join24 } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function contentHash(text) {
-  return createHash("sha256").update(text.replace(/\s+/g, "")).digest("hex").slice(0, 40);
+  return createHash2("sha256").update(text.replace(/\s+/g, "")).digest("hex").slice(0, 40);
 }
 function mem7Root(stateDir) {
   return join24(stateDir, "mem7");
@@ -16719,11 +16728,11 @@ async function readLastConsolidatedAt(memoryDir) {
   }
 }
 async function tryAcquireConsolidationLock(memoryDir) {
-  const path60 = lockPath(memoryDir);
+  const path61 = lockPath(memoryDir);
   let mtimeMs;
   let holderPid;
   try {
-    const [s, raw] = await Promise.all([stat3(path60), readFile5(path60, "utf8")]);
+    const [s, raw] = await Promise.all([stat3(path61), readFile5(path61, "utf8")]);
     mtimeMs = s.mtimeMs;
     const parsed = parseInt(raw.trim(), 10);
     holderPid = Number.isFinite(parsed) ? parsed : void 0;
@@ -16736,10 +16745,10 @@ async function tryAcquireConsolidationLock(memoryDir) {
     }
   }
   await mkdir3(memoryDir, { recursive: true });
-  await writeFile4(path60, String(process.pid));
+  await writeFile4(path61, String(process.pid));
   let verify2;
   try {
-    verify2 = await readFile5(path60, "utf8");
+    verify2 = await readFile5(path61, "utf8");
   } catch {
     return null;
   }
@@ -16747,15 +16756,15 @@ async function tryAcquireConsolidationLock(memoryDir) {
   return mtimeMs ?? 0;
 }
 async function rollbackConsolidationLock(memoryDir, priorMtime) {
-  const path60 = lockPath(memoryDir);
+  const path61 = lockPath(memoryDir);
   try {
     if (priorMtime === 0) {
-      await unlink(path60);
+      await unlink(path61);
       return;
     }
-    await writeFile4(path60, "");
+    await writeFile4(path61, "");
     const t = priorMtime / 1e3;
-    await utimes(path60, t, t);
+    await utimes(path61, t, t);
   } catch (e) {
     console.log(`[autoDream] rollback failed: ${e.message} \u2014 next trigger delayed to minHours`);
   }
@@ -17357,12 +17366,12 @@ async function executeAndDeliver(task, now, deps) {
     if (promptText.startsWith("@")) {
       let filePath = promptText.slice(1).trim();
       try {
-        const fs58 = await import("fs");
-        const path60 = await import("path");
-        if (!path60.isAbsolute(filePath)) {
-          filePath = path60.join(deps.sessions["config"].stateDir, filePath);
+        const fs59 = await import("fs");
+        const path61 = await import("path");
+        if (!path61.isAbsolute(filePath)) {
+          filePath = path61.join(deps.sessions["config"].stateDir, filePath);
         }
-        promptText = fs58.readFileSync(filePath, "utf-8");
+        promptText = fs59.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}`);
@@ -17400,16 +17409,16 @@ async function executeAndDeliver(task, now, deps) {
     let finalResult = result;
     if (task.postProcess) {
       try {
-        const path60 = await import("path");
-        const fs58 = await import("fs");
+        const path61 = await import("path");
+        const fs59 = await import("fs");
         let scriptPath = task.postProcess;
-        if (!path60.isAbsolute(scriptPath)) {
-          scriptPath = path60.join(deps.sessions["config"].stateDir, scriptPath);
+        if (!path61.isAbsolute(scriptPath)) {
+          scriptPath = path61.join(deps.sessions["config"].stateDir, scriptPath);
         }
-        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 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 { execFile: execFile5 } = await import("child_process");
         await new Promise((resolve12) => {
           execFile5("python", [scriptPath, "main", "--file", inputFile], {
@@ -17436,12 +17445,12 @@ async function executeAndDeliver(task, now, deps) {
       }
     }
     try {
-      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({
+      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({
         taskId: task.id,
         description: task.description,
         executedAt: now.toISOString(),
@@ -17771,30 +17780,30 @@ function registerCronTools() {
       }
     },
     handler: async (args) => {
-      const fs58 = await import("fs");
-      const path60 = await import("path");
-      const resultsDir = path60.join(getStorageDir(), "results");
-      if (!fs58.existsSync(resultsDir)) {
+      const fs59 = await import("fs");
+      const path61 = await import("path");
+      const resultsDir = path61.join(getStorageDir(), "results");
+      if (!fs59.existsSync(resultsDir)) {
         return { content: "\u6682\u65E0cron\u6267\u884C\u7ED3\u679C" };
       }
       if (args.task_id) {
-        const file2 = path60.join(resultsDir, `${args.task_id}.json`);
-        if (!fs58.existsSync(file2)) {
+        const file2 = path61.join(resultsDir, `${args.task_id}.json`);
+        if (!fs59.existsSync(file2)) {
           return { content: `\u4EFB\u52A1 ${args.task_id} \u6682\u65E0\u6267\u884C\u7ED3\u679C`, isError: true };
         }
-        const data = JSON.parse(fs58.readFileSync(file2, "utf-8"));
+        const data = JSON.parse(fs59.readFileSync(file2, "utf-8"));
         return { content: `## ${data.description}
 \u6267\u884C\u65F6\u95F4: ${data.executedAt}
 \u7B2C${data.runCount}\u6B21\u6267\u884C
 
 ${data.result}` };
       }
-      const files = fs58.readdirSync(resultsDir).filter((f) => f.endsWith(".json"));
+      const files = fs59.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(fs58.readFileSync(path60.join(resultsDir, f), "utf-8"));
+        const data = JSON.parse(fs59.readFileSync(path61.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 ? "..." : ""}`;
@@ -18469,10 +18478,10 @@ function ensureLoaded(workspace, configIds) {
       if (!state.blockedUserIds.includes(id)) state.blockedUserIds.push(id);
     }
   }
-  const path60 = join44(workspace, ".reply-blocklist.json");
+  const path61 = join44(workspace, ".reply-blocklist.json");
   try {
-    if (existsSync22(path60)) {
-      const raw = readFileSync32(path60, "utf-8");
+    if (existsSync22(path61)) {
+      const raw = readFileSync32(path61, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.blockedUserIds) {
         for (const id of parsed.blockedUserIds) {
@@ -18488,9 +18497,9 @@ function ensureLoaded(workspace, configIds) {
   loaded = true;
 }
 function save(workspace) {
-  const path60 = join44(workspace, ".reply-blocklist.json");
+  const path61 = join44(workspace, ".reply-blocklist.json");
   try {
-    writeFileSync10(path60, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync10(path61, JSON.stringify(state, null, 2), "utf-8");
   } catch (err) {
     console.warn(`[reply-blocklist] Failed to save: ${err.message}`);
   }
@@ -19060,15 +19069,15 @@ var read_exports = {};
 __export(read_exports, {
   readFileState: () => readFileState
 });
-import * as fs51 from "node:fs";
-import * as path50 from "node:path";
+import * as fs52 from "node:fs";
+import * as path51 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 = fs51.statSync(filePath);
+  const stat4 = fs52.statSync(filePath);
   const mtimeMs = stat4.mtimeMs;
   const prev = readHistory.get(filePath);
   if (prev && prev.offset === offset && prev.limit === limit && prev.mtimeMs === mtimeMs) {
@@ -19082,19 +19091,19 @@ function checkReadLoop(filePath, offset, limit) {
   return null;
 }
 function readFileContent(filePath) {
-  const fd = fs51.openSync(filePath, "r");
+  const fd = fs52.openSync(filePath, "r");
   const bom = Buffer.alloc(2);
-  fs51.readSync(fd, bom, 0, 2, 0);
-  fs51.closeSync(fd);
+  fs52.readSync(fd, bom, 0, 2, 0);
+  fs52.closeSync(fd);
   let encoding = "utf8";
   if (bom[0] === 255 && bom[1] === 254) {
     encoding = "utf16le";
   }
-  const stat4 = fs51.statSync(filePath);
+  const stat4 = fs52.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 = fs51.readFileSync(filePath, encoding);
+  const raw = fs52.readFileSync(filePath, encoding);
   const content = raw.toString().replaceAll("\r\n", "\n");
   return { content, encoding };
 }
@@ -19236,11 +19245,11 @@ Usage:
         } catch (e) {
           return { content: e.message, isError: true };
         }
-        if (!fs51.existsSync(filePath)) {
+        if (!fs52.existsSync(filePath)) {
           return { content: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, isError: true };
         }
-        const stat4 = fs51.statSync(filePath);
-        const baseName = path50.basename(filePath).toUpperCase();
+        const stat4 = fs52.statSync(filePath);
+        const baseName = path51.basename(filePath).toUpperCase();
         if (BLOCKED_BASENAMES.has(baseName)) {
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6: ${filePath}`, isError: true };
         }
@@ -19248,11 +19257,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 = fs51.readdirSync(filePath);
+          const entries2 = fs52.readdirSync(filePath);
           const items = entries2.map((e) => {
-            const full = path50.join(filePath, e);
+            const full = path51.join(filePath, e);
             try {
-              const s = fs51.statSync(full);
+              const s = fs52.statSync(full);
               return s.isDirectory() ? `${e}/` : e;
             } catch {
               return e;
@@ -19261,7 +19270,7 @@ Usage:
           return { content: `\u76EE\u5F55 (${entries2.length} \u9879):
 ${items.join("\n")}` };
         }
-        const ext = path50.extname(filePath).toLowerCase();
+        const ext = path51.extname(filePath).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext)) {
           return { content: `\u4E8C\u8FDB\u5236\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6 (${ext}): ${filePath}`, isError: true };
         }
@@ -19309,22 +19318,22 @@ ${result}` : result };
 
 // src/tools/write.ts
 var write_exports = {};
-import * as fs52 from "node:fs";
-import * as path51 from "node:path";
+import * as fs53 from "node:fs";
+import * as path52 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";
-  fs52.writeFileSync(tmpPath, content, "utf-8");
+  fs53.writeFileSync(tmpPath, content, "utf-8");
   try {
-    fs52.renameSync(tmpPath, filePath);
+    fs53.renameSync(tmpPath, filePath);
   } catch (e) {
     try {
-      fs52.unlinkSync(tmpPath);
+      fs53.unlinkSync(tmpPath);
     } catch {
     }
-    fs52.writeFileSync(filePath, content, "utf-8");
+    fs53.writeFileSync(filePath, content, "utf-8");
   }
 }
 function simpleDiff(oldContent, newContent) {
@@ -19418,15 +19427,15 @@ Usage:
         }
         const rawContent = args.content;
         const content = rawContent.replaceAll("\r\n", "\n");
-        if (fs52.existsSync(filePath) && fs52.statSync(filePath).isDirectory()) {
+        if (fs53.existsSync(filePath) && fs53.statSync(filePath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
         }
         let oldContent = null;
         let isCreate = true;
-        if (fs52.existsSync(filePath)) {
+        if (fs53.existsSync(filePath)) {
           isCreate = false;
           try {
-            oldContent = fs52.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            oldContent = fs53.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
           } catch {
             isCreate = true;
           }
@@ -19442,10 +19451,10 @@ Usage:
               isError: true
             };
           }
-          const currentStat = fs52.statSync(filePath);
+          const currentStat = fs53.statSync(filePath);
           const lastWriteTime = Math.floor(currentStat.mtimeMs);
           if (lastWriteTime > readState.timestamp) {
-            const currentContent = fs52.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            const currentContent = fs53.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}`,
@@ -19454,9 +19463,9 @@ Usage:
             }
           }
         }
-        const dir = path51.dirname(filePath);
+        const dir = path52.dirname(filePath);
         try {
-          fs52.mkdirSync(dir, { recursive: true });
+          fs53.mkdirSync(dir, { recursive: true });
         } catch (e) {
           return { content: `\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${dir} \u2014 ${e.message}`, isError: true };
         }
@@ -19465,11 +19474,11 @@ Usage:
         } catch (e) {
           return { content: `\u5199\u5165\u5931\u8D25: ${e.message}`, isError: true };
         }
-        readFileState.set(filePath, { timestamp: fs52.statSync(filePath).mtimeMs });
+        readFileState.set(filePath, { timestamp: fs53.statSync(filePath).mtimeMs });
         const action = isCreate ? "\u521B\u5EFA" : "\u66F4\u65B0";
         const lines = content.split("\n").length;
         const chars = content.length;
-        const stat4 = fs52.statSync(filePath);
+        const stat4 = fs53.statSync(filePath);
         let diff = "";
         if (!isCreate && oldContent !== null) {
           diff = `
@@ -19489,8 +19498,8 @@ ${simpleDiff(oldContent, content)}`;
 
 // src/tools/edit.ts
 var edit_exports = {};
-import * as fs53 from "node:fs";
-import * as path52 from "node:path";
+import * as fs54 from "node:fs";
+import * as path53 from "node:path";
 function normalizeQuotes(str) {
   return str.replaceAll(LEFT_SINGLE_CURLY, "'").replaceAll(RIGHT_SINGLE_CURLY, "'").replaceAll(LEFT_DOUBLE_CURLY, '"').replaceAll(RIGHT_DOUBLE_CURLY, '"');
 }
@@ -19643,7 +19652,7 @@ Usage:
         }
         let fileContent = null;
         try {
-          const stat4 = fs53.statSync(filePath);
+          const stat4 = fs54.statSync(filePath);
           if (stat4.isDirectory()) {
             return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
           }
@@ -19653,21 +19662,21 @@ Usage:
         } catch (e) {
           if (e.code === "ENOENT") {
             if (oldString === "") {
-              const dir = path52.dirname(filePath);
-              fs53.mkdirSync(dir, { recursive: true });
-              fs53.writeFileSync(filePath, newString, "utf-8");
-              readFileState.set(filePath, { timestamp: fs53.statSync(filePath).mtimeMs });
+              const dir = path53.dirname(filePath);
+              fs54.mkdirSync(dir, { recursive: true });
+              fs54.writeFileSync(filePath, newString, "utf-8");
+              readFileState.set(filePath, { timestamp: fs54.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 = fs53.readFileSync(filePath, "utf-8");
+        const rawContent = fs54.readFileSync(filePath, "utf-8");
         fileContent = rawContent.replaceAll("\r\n", "\n");
         if (oldString === "" && fileContent.trim() === "") {
-          fs53.writeFileSync(filePath, newString, "utf-8");
-          readFileState.set(filePath, { timestamp: fs53.statSync(filePath).mtimeMs });
+          fs54.writeFileSync(filePath, newString, "utf-8");
+          readFileState.set(filePath, { timestamp: fs54.statSync(filePath).mtimeMs });
           return { content: `\u5199\u5165\u7A7A\u6587\u4EF6: ${filePath} (${newString.split("\n").length} \u884C)` };
         }
         const readState = readFileState.get(filePath);
@@ -19677,11 +19686,11 @@ Usage:
             isError: true
           };
         }
-        const currentStat = fs53.statSync(filePath);
+        const currentStat = fs54.statSync(filePath);
         const lastWriteTime = Math.floor(currentStat.mtimeMs);
         if (lastWriteTime > readState.timestamp) {
           if (fileContent !== rawContent.replaceAll("\r\n", "\n")) {
-            if (fileContent !== fs53.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n")) {
+            if (fileContent !== fs54.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
@@ -19713,8 +19722,8 @@ ${preview}
         const actualNewString = preserveQuoteStyle(oldString, actualOldString, newString);
         const diffView = generateEditDiff(fileContent, actualOldString, actualNewString);
         const newContent = applyEditToFile(fileContent, actualOldString, actualNewString, replaceAll);
-        fs53.writeFileSync(filePath, newContent, "utf-8");
-        readFileState.set(filePath, { timestamp: fs53.statSync(filePath).mtimeMs });
+        fs54.writeFileSync(filePath, newContent, "utf-8");
+        readFileState.set(filePath, { timestamp: fs54.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`;
@@ -19732,8 +19741,8 @@ ${diffView}`
 
 // src/tools/glob.ts
 var glob_exports = {};
-import * as fs54 from "node:fs";
-import * as path53 from "node:path";
+import * as fs55 from "node:fs";
+import * as path54 from "node:path";
 function globMatch(pattern, filename) {
   const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   try {
@@ -19753,18 +19762,18 @@ function findFiles(dir, pattern, limit, baseDir) {
     }
     let entries2;
     try {
-      entries2 = fs54.readdirSync(currentDir, { withFileTypes: true });
+      entries2 = fs55.readdirSync(currentDir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries2) {
       if (truncated) return;
-      const fullPath = path53.join(currentDir, entry.name);
+      const fullPath = path54.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (VCS_DIRS.has(entry.name)) continue;
         walk(fullPath);
       } else if (entry.isFile()) {
-        const relativePath = path53.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = path54.relative(baseDir, fullPath).replace(/\\/g, "/");
         const patternsToTry = [pattern];
         if (pattern.startsWith("**/")) {
           patternsToTry.push(pattern.slice(3));
@@ -19774,7 +19783,7 @@ function findFiles(dir, pattern, limit, baseDir) {
         );
         if (matched) {
           try {
-            const stat4 = fs54.statSync(fullPath);
+            const stat4 = fs55.statSync(fullPath);
             results.push({ path: fullPath, mtimeMs: stat4.mtimeMs });
           } catch {
           }
@@ -19791,7 +19800,7 @@ function findFiles(dir, pattern, limit, baseDir) {
   };
 }
 function toRelativePath(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path53.sep)) {
+  if (absolutePath.startsWith(cwd + path54.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   return absolutePath;
@@ -19824,10 +19833,10 @@ var init_glob = __esm({
         const searchPath = args.path ? resolvePath(args.path, ctx.workspace) : ctx.workspace;
         const pattern = args.pattern;
         const limit = args.limit || DEFAULT_LIMIT;
-        if (!fs54.existsSync(searchPath)) {
+        if (!fs55.existsSync(searchPath)) {
           return { content: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${searchPath}`, isError: true };
         }
-        if (!fs54.statSync(searchPath).isDirectory()) {
+        if (!fs55.statSync(searchPath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${searchPath}`, isError: true };
         }
         const start = Date.now();
@@ -19852,7 +19861,7 @@ ${filenames.join("\n")}${truncatedNote}`
 // src/tools/grep.ts
 var grep_exports = {};
 import { execFile as execFile4 } from "node:child_process";
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 function ripGrep(args, searchPath, signal) {
   return new Promise((resolve12) => {
     const fullArgs = [...args, searchPath];
@@ -19884,7 +19893,7 @@ function applyHeadLimit(items, limit, offset = 0) {
   };
 }
 function toRelativePath2(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path54.sep)) {
+  if (absolutePath.startsWith(cwd + path55.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   if (absolutePath.startsWith(cwd)) {
@@ -21693,7 +21702,7 @@ var init_TeamDeleteTool = __esm({
       },
       isEnabled: () => isAgentSwarmsEnabled(),
       handler: async (_args, ctx) => {
-        const teamName = ctx.teamName;
+        const teamName = ctx.teamName || getLeaderTeamName() || void 0;
         if (teamName) {
           const teamFile = readTeamFile(teamName);
           if (teamFile) {
@@ -21777,7 +21786,7 @@ function getAgentName(ctx) {
   return ctx.agentName || TEAM_LEAD_NAME;
 }
 function getTeamName(ctx) {
-  return ctx.teamName;
+  return ctx.teamName || getLeaderTeamName() || void 0;
 }
 async function handleMessage(recipientName, content, summary, ctx) {
   const teamName = getTeamName(ctx);
@@ -22406,8 +22415,8 @@ __export(manager_exports, {
   McpManager: () => McpManager,
   convertInputSchema: () => convertInputSchema
 });
-import * as fs57 from "node:fs";
-import * as path57 from "node:path";
+import * as fs58 from "node:fs";
+import * as path58 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";
@@ -22448,12 +22457,12 @@ function convertInputSchema(inputSchema) {
 }
 function persistBinary(base64Data, mimeType, persistId) {
   const ext = mimeType?.split("/")[1] || "bin";
-  const dir = path57.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
-  fs57.mkdirSync(dir, { recursive: true });
-  const filepath = path57.join(dir, `${persistId}.${ext}`);
+  const dir = path58.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
+  fs58.mkdirSync(dir, { recursive: true });
+  const filepath = path58.join(dir, `${persistId}.${ext}`);
   try {
     const buf = Buffer.from(base64Data, "base64");
-    fs57.writeFileSync(filepath, buf);
+    fs58.writeFileSync(filepath, buf);
     return { filepath, size: buf.length };
   } catch (err) {
     return { error: err.message };
@@ -22787,7 +22796,7 @@ __export(resources_exports, {
   registerMcpResourceTools: () => registerMcpResourceTools,
   unregisterMcpResourceTools: () => unregisterMcpResourceTools
 });
-import * as path58 from "node:path";
+import * as path59 from "node:path";
 function registerMcpResourceTools(manager) {
   mcpManagerRef = manager;
   registry.register(listResourcesTool);
@@ -22805,7 +22814,7 @@ var init_resources = __esm({
     "use strict";
     init_registry();
     MAX_RESULT_CHARS2 = 1e5;
-    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path58.join(process.env.ENGINE_STATE_DIR || ".engine", "media", "inbound");
+    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path59.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;
@@ -22893,7 +22902,7 @@ ${lines.join("\n\n")}`;
 // src/engine-startup.ts
 init_query();
 init_live();
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 
 // src/startup/providers.ts
 init_provider_factory();
@@ -23138,16 +23147,32 @@ import * as path10 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/config/secrets-env.ts
-import { basename, dirname, join as join9 } from "node:path";
+import { createHash } from "node:crypto";
+import { basename, dirname, join as join9, normalize as normalize3 } from "node:path";
 function secretsHome() {
   return process.env.HOME || process.env.USERPROFILE || ".";
 }
+function normalizeStateDir(stateDir) {
+  return normalize3(stateDir).split("\\").join("/").replace(/\/+$/, "").toLowerCase();
+}
+function stateKey(stateDir) {
+  return createHash("sha256").update(normalizeStateDir(stateDir)).digest("hex").slice(0, 8);
+}
+function isDefaultStateDir(stateDir) {
+  return normalizeStateDir(stateDir) === normalizeStateDir(join9(secretsHome(), ".engine7"));
+}
 function secretsCandidates(stateDir, configName) {
-  return [
-    join9(secretsHome(), ".engine7-secrets", `${configName}.env`),
+  const shared = join9(secretsHome(), ".engine7-secrets", `${configName}.env`);
+  const inState = [
     join9(stateDir, "configs", `.env.${configName}`),
     join9(stateDir, "configs", ".env")
   ];
+  if (isDefaultStateDir(stateDir)) return [shared, ...inState];
+  return [
+    join9(secretsHome(), ".engine7-secrets", `${configName}-${stateKey(stateDir)}.env`),
+    shared,
+    ...inState
+  ];
 }
 
 // src/reload/orchestrator.ts
@@ -24259,7 +24284,7 @@ ${formatted}` };
   };
 }
 function createEverosGetTool() {
-  const fs58 = __require("node:fs/promises");
+  const fs59 = __require("node:fs/promises");
   return {
     name: "memory_get",
     description: "Read a memory file by path.",
@@ -24275,7 +24300,7 @@ function createEverosGetTool() {
     handler: async (args) => {
       try {
         const filePath = args.path;
-        const content = await fs58.readFile(filePath, "utf-8");
+        const content = await fs59.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         const fromLine = args.from ?? 1;
         const numLines = args.lines ?? lines.length;
@@ -24327,11 +24352,11 @@ var ALL_PAID_FEATURES = [
   "report-gen",
   "custom-soul"
 ];
-function loadLicense(stateDir, devMode) {
+function loadLicense(stateDir, devMode = true) {
   if (_licenseChecked) return _cachedLicense;
   _licenseChecked = true;
   if (devMode) {
-    console.log("[license] devMode enabled \u2014 all features active (internal development)");
+    console.log("[license] \u5F00\u653E\u6A21\u5F0F \u2014 \u5168\u90E8 feature \u6FC0\u6D3B\uFF08\u8981\u5206\u6863\uFF1Aagents.defaults.devMode = false\uFF09");
     const allActive = {};
     for (const id of ALL_PAID_FEATURES) {
       allActive[id] = { active: true };
@@ -24341,7 +24366,7 @@ function loadLicense(stateDir, devMode) {
   }
   const licensePath = path15.join(stateDir, "license.json");
   if (!fs16.existsSync(licensePath)) {
-    console.log("[license] No license.json found, running basic engine only");
+    console.log("[license] devMode=false \u4E14\u65E0 license.json \u2014\u2014 \u57FA\u7840\u5F15\u64CE\u6A21\u5F0F");
     return null;
   }
   try {
@@ -26163,18 +26188,18 @@ function resetSessionStartInjection(sessionId) {
 }
 var externalChanRulesCache = null;
 function loadExternalChanRules(workspace) {
-  const path60 = join36(workspace, "prompts", "external-chan-rules.md");
-  if (externalChanRulesCache && externalChanRulesCache.path === path60) return externalChanRulesCache;
+  const path61 = join36(workspace, "prompts", "external-chan-rules.md");
+  if (externalChanRulesCache && externalChanRulesCache.path === path61) return externalChanRulesCache;
   let content = "";
-  if (existsSync19(path60)) {
+  if (existsSync19(path61)) {
     try {
-      content = readFileSync26(path60, "utf-8").trim();
+      content = readFileSync26(path61, "utf-8").trim();
     } catch (e) {
       console.warn(`[external-chan-rules] Failed to load: ${e}`);
     }
   }
-  externalChanRulesCache = { path: path60, content };
-  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path60}`);
+  externalChanRulesCache = { path: path61, content };
+  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path61}`);
   return externalChanRulesCache;
 }
 function getExternalChanRulesBlock(inboundMeta, workspace) {
@@ -27061,15 +27086,15 @@ function registerCompactHooks(config) {
       const dailyDir = path22.join(workspace, "memory", "daily");
       const dailyPath = path22.join(dailyDir, `${dateStr}.md`);
       try {
-        const fs58 = await import("node:fs");
-        if (!fs58.existsSync(dailyDir)) {
-          fs58.mkdirSync(dailyDir, { recursive: true });
+        const fs59 = await import("node:fs");
+        if (!fs59.existsSync(dailyDir)) {
+          fs59.mkdirSync(dailyDir, { recursive: true });
         }
         const sessionsDir = path22.join(config.stateDir, "agents", "main", "sessions");
         const sessionFile = path22.join(sessionsDir, `${sessionId}.jsonl`);
         const recentLines = [];
-        if (fs58.existsSync(sessionFile)) {
-          const content = fs58.readFileSync(sessionFile, "utf-8");
+        if (fs59.existsSync(sessionFile)) {
+          const content = fs59.readFileSync(sessionFile, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           const userLines = lines.filter((l) => {
             try {
@@ -27099,10 +27124,10 @@ function registerCompactHooks(config) {
         const entry = `${header}
 ${body}
 `;
-        if (fs58.existsSync(dailyPath)) {
-          fs58.appendFileSync(dailyPath, entry);
+        if (fs59.existsSync(dailyPath)) {
+          fs59.appendFileSync(dailyPath, entry);
         } else {
-          fs58.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
+          fs59.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
 ${entry}`);
         }
         console.log(`[hooks] PreCompact: saved ${recentLines.length} lines to ${dailyPath}`);
@@ -27118,16 +27143,16 @@ ${entry}`);
       const workspace = input.cwd || input.workspace || "";
       if (!workspace) return { continue: true };
       try {
-        const fs58 = await import("node:fs");
+        const fs59 = await import("node:fs");
         const bufferPath = path22.join(workspace, "memory", "working-buffer.md");
-        if (fs58.existsSync(bufferPath)) {
-          const stat4 = fs58.statSync(bufferPath);
+        if (fs59.existsSync(bufferPath)) {
+          const stat4 = fs59.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 = fs58.readFileSync(bufferPath, "utf-8");
+          const content = fs59.readFileSync(bufferPath, "utf-8");
           if (content.trim()) {
             console.log(`[hooks] PostCompact: injecting working-buffer (${content.length} chars, ${ageMin}min old)`);
             return {
@@ -33582,10 +33607,10 @@ function writeReportState(stateDir, s) {
 }
 
 // src/optional/reporting/payload.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import * as os3 from "node:os";
 function installKeyOf(installId, installSecret) {
-  return createHash2("sha256").update(installId + installSecret).digest("hex").slice(0, 32);
+  return createHash3("sha256").update(installId + installSecret).digest("hex").slice(0, 32);
 }
 function buildReportPayload(opts) {
   const p = {
@@ -33962,13 +33987,13 @@ var DiscordAdapter = class _DiscordAdapter {
   }
   /** 发送媒体附件（图片/文件/音频）— discord.js channel.send({ files }) */
   async sendFile(target, message, attachment) {
-    const fs58 = await import("node:fs");
-    const path60 = await import("node:path");
-    if (!fs58.existsSync(attachment.path)) {
+    const fs59 = await import("node:fs");
+    const path61 = await import("node:path");
+    if (!fs59.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path60.basename(attachment.path);
-    const fileBuffer = fs58.readFileSync(attachment.path);
+    const filename = attachment.filename || path61.basename(attachment.path);
+    const fileBuffer = fs59.readFileSync(attachment.path);
     const filePayload = {
       attachment: fileBuffer,
       name: filename
@@ -34417,13 +34442,13 @@ var FeishuAdapter = class _FeishuAdapter {
   }
   /** 发送媒体附件（图片/文件） */
   async sendFile(target, message, attachment) {
-    const fs58 = await import("node:fs");
-    const path60 = await import("node:path");
-    if (!fs58.existsSync(attachment.path)) {
+    const fs59 = await import("node:fs");
+    const path61 = await import("node:path");
+    if (!fs59.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path60.basename(attachment.path);
-    const fileBuffer = fs58.readFileSync(attachment.path);
+    const filename = attachment.filename || path61.basename(attachment.path);
+    const fileBuffer = fs59.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";
@@ -36245,22 +36270,22 @@ var DeskBuddyAdapter = class {
     try {
       if (!this.historyFile) {
         const os7 = __require("os");
-        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;
+        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;
       let arr = [];
       try {
-        arr = JSON.parse(fs58.readFileSync(this.historyFile, "utf-8")) || [];
+        arr = JSON.parse(fs59.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);
-      fs58.writeFileSync(this.historyFile, JSON.stringify(arr, null, 1));
+      fs59.writeFileSync(this.historyFile, JSON.stringify(arr, null, 1));
     } catch (e) {
       console.warn("[deskBuddy] history write fail", e);
     }
@@ -36539,8 +36564,365 @@ var DeskBuddyAdapter = class {
   }
 };
 
+// src/channels/cc-bridge.ts
+init_live();
+import fs41 from "node:fs";
+import path41 from "node:path";
+import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket2 } from "ws";
+var DEFAULT_PORT = 16996;
+var CcBridgeAdapter = class {
+  name = "ccBridge";
+  config;
+  wss = null;
+  clients = /* @__PURE__ */ new Set();
+  messageHandler = null;
+  seq = 0;
+  constructor(config) {
+    this.config = config;
+  }
+  /** 工具流水默认不推（见 CcBridgeConfig.showToolDisplay） */
+  get suppressToolDisplay() {
+    return this.config.showToolDisplay !== true;
+  }
+  /** 实际监听的端口。配 `port: 0` 时由内核分配 —— 测试用它拿真端口，不用赌某个数字没被占 */
+  get boundPort() {
+    const a = this.wss?.address();
+    return a && typeof a === "object" ? a.port : null;
+  }
+  onMessage(handler2) {
+    this.messageHandler = handler2;
+  }
+  // ── outbox（持久队列）──
+  //
+  // 每次现读 stateDir，不缓存 —— stateDir 的 effect 是 restart，缓存下来的
+  // 只会在热加载后变成指向旧目录的幽灵路径（配置访问铁律）。
+  outboxFile() {
+    const sd = liveConfig.get("stateDir") || process.cwd();
+    return path41.join(sd, "state", "cc-bridge", "outbox.jsonl");
+  }
+  /**
+   * 读队列。**只有 ENOENT 才等于"空队列"。**
+   *
+   * ⚠️ 这里原来写的是 `catch { return [] }` —— 那是**会丢数据的**：
+   * 读失败（Windows 上 AV/同步盘/搜索索引的瞬时共享锁 EBUSY，或 EPERM/EACCES）
+   * 返回空数组，紧接着 `enqueue` 拿这份空数组**整份覆写**，待投递的消息全没，
+   * 而且一句警告都没有。而"读不了"和"不存在"是完全不同的两件事 ——
+   * 这个区分正是"宁可重复，不可丢失"能不能成立的支点。
+   */
+  readOutbox() {
+    let raw;
+    try {
+      raw = fs41.readFileSync(this.outboxFile(), "utf8");
+    } catch (e) {
+      if (e?.code === "ENOENT") return [];
+      throw e;
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        out.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return out;
+  }
+  /**
+   * 写队列：**先写 .tmp 再 rename**。
+   *
+   * `writeFileSync(file, ...)` 是原地截断（`w` 模式先清零再写）——
+   * 在这中间被 taskkill / OOM / 断电，文件就是空的或半截，
+   * 下次读回来是 [] 且无从分辨，最多 maxQueue 条待投递消息整体消失。
+   * rename 到已存在文件走的是替换语义，落盘要么全旧要么全新。
+   *
+   * **失败要抛**：调用方（cron/heartbeat 经 `manager.send`）必须知道没存住 ——
+   * 吞成 warning 的话，磁盘满/只读时客户端在线还能收到实时那条，
+   * 客户端离线就是真丢，而这恰恰是这个通道要保的场景。
+   */
+  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);
+  }
+  /** 入队（dedupe 不做 —— id 是新的，重复投递由 ack 收敛）。读/写失败都往外抛，不吞。 */
+  enqueue(item) {
+    const items = this.readOutbox();
+    items.push(item);
+    const cap = this.config.maxQueue ?? 500;
+    if (items.length > cap) {
+      const dropped = items.length - cap;
+      items.splice(0, dropped);
+      console.warn(`[ccBridge] outbox \u8D85\u8FC7 ${cap} \u6761\uFF0C\u4E22\u4E86\u6700\u8001\u7684 ${dropped} \u6761 \u2014\u2014 CC \u592A\u4E45\u6CA1\u6765\u6536`);
+    }
+    this.writeOutbox(items);
+  }
+  /**
+   * ack：从队列删掉客户端确认过的。
+   *
+   * 读失败时**返回 0 而不是抛** —— 这里宁可"删不掉"也不能"删错"：
+   * ack 的语义是收敛，失败留给下一轮再收敛，代价只是重复投递。
+   */
+  ack(ids) {
+    if (!ids.length) return 0;
+    const set = new Set(ids);
+    let items;
+    try {
+      items = this.readOutbox();
+    } catch (e) {
+      console.warn(`[ccBridge] ack \u8BFB\u961F\u5217\u5931\u8D25\uFF0C\u672C\u8F6E\u4E0D\u5220\uFF08\u6D88\u606F\u4F1A\u91CD\u590D\u6295\u9012\uFF09\uFF1A${e.message}`);
+      return 0;
+    }
+    const kept = items.filter((i) => !set.has(i.id));
+    const removed = items.length - kept.length;
+    if (removed) {
+      try {
+        this.writeOutbox(kept);
+      } catch (e) {
+        console.warn(`[ccBridge] ack \u5199\u961F\u5217\u5931\u8D25\uFF0C\u672C\u8F6E\u4E0D\u5220\uFF1A${e.message}`);
+        return 0;
+      }
+    }
+    return removed;
+  }
+  /** 队列条数（读不到就算 0 —— 只用于日志/握手，不能用来做删除决策） */
+  queuedCount() {
+    try {
+      return this.readOutbox().length;
+    } catch {
+      return 0;
+    }
+  }
+  /** 读队列但**不因读失败而中断**（握手补发、日志这类"读不到也能继续"的场合） */
+  safeReadOutbox(where) {
+    try {
+      return this.readOutbox();
+    } catch (e) {
+      console.warn(`[ccBridge] ${where}\uFF1A\u8BFB\u961F\u5217\u5931\u8D25\uFF0C\u672C\u8F6E\u5F53\u4F5C\u7A7A\uFF08**\u672A\u5220\u9664\u4EFB\u4F55\u4E1C\u897F**\uFF09\uFF1A${e.message}`);
+      return [];
+    }
+  }
+  /**
+   * 升级握手校验。见 `connect()` 里那段注释 —— 绑回环挡不住浏览器。
+   * 返回 false 时 `ws` 会直接拒绝升级（HTTP 401），连接根本建立不起来。
+   */
+  verifyUpgrade(info) {
+    const h = info?.req?.headers ?? {};
+    if (h.origin) {
+      console.warn(`[ccBridge] \u26D4 \u62D2\u7EDD\u5E26 Origin \u7684\u8FDE\u63A5\uFF1A${h.origin}\uFF08\u7591\u4F3C\u7F51\u9875\u53D1\u8D77\uFF09`);
+      return false;
+    }
+    const host = String(h.host || "").replace(/:\d+$/, "").toLowerCase();
+    const ok = host === "127.0.0.1" || host === "localhost" || host === "[::1]" || host === "::1" || host === "";
+    if (!ok) console.warn(`[ccBridge] \u26D4 \u62D2\u7EDD\u975E\u56DE\u73AF Host\uFF1A${h.host}\uFF08\u7591\u4F3C DNS rebinding\uFF09`);
+    return ok;
+  }
+  // ── 连接 ──
+  async connect() {
+    const port = this.config.port ?? DEFAULT_PORT;
+    try {
+      fs41.mkdirSync(path41.dirname(this.outboxFile()), { recursive: true });
+    } catch {
+    }
+    this.wss = new WebSocketServer2({
+      port,
+      host: "127.0.0.1",
+      maxPayload: 4 * 1024 * 1024,
+      // ⛔ **绑 127.0.0.1 不是安全边界。** WebSocket 不受同源策略约束，
+      // 用户浏览器里**任意** http 页面都能 `new WebSocket('ws://127.0.0.1:16996')`
+      // 连上来 —— 而这里连上就能以任意 `from` 往 agent 主会话注入消息
+      // （实测过：伪造 Origin/Host 能成功注入一条 `from: 翀哥` 的消息）。
+      // 所以必须自己校验：
+      //   · 带 `Origin` 头 = 网页发起的 → 直接拒（`scripts/cc-inbox.mjs` 是 Node
+      //     客户端，本来就不发这个头，不受影响）
+      //   · `Host` 必须是本机回环 → 挡 DNS rebinding（域名解析到 127.0.0.1 时
+      //     Host 会是那个域名，而不是 127.0.0.1）
+      verifyClient: (info) => this.verifyUpgrade(info)
+    });
+    this.wss.on("connection", (ws) => {
+      this.clients.add(ws);
+      console.log(`[ccBridge] CC connected (${this.clients.size} online)`);
+      const pending2 = this.safeReadOutbox("\u63E1\u624B\u8865\u53D1");
+      this.sendTo(ws, { type: "hello", channel: this.name, queued: pending2.length });
+      if (pending2.length) {
+        console.log(`[ccBridge] \u8865\u53D1 ${pending2.length} \u6761\u79EF\u538B`);
+        this.sendTo(ws, { type: "backlog", messages: pending2 });
+      }
+      ws.on("message", (data) => this.handleFrame(ws, data));
+      ws.on("close", () => {
+        this.clients.delete(ws);
+        console.log(`[ccBridge] CC disconnected (${this.clients.size} online)`);
+      });
+      ws.on("error", () => this.clients.delete(ws));
+    });
+    this.wss.on("error", (e) => {
+      console.error(`[ccBridge] server error on 127.0.0.1:${port}: ${e.message}`);
+    });
+    await new Promise((resolve12, reject) => {
+      const wss = this.wss;
+      const ok = () => {
+        wss.off("error", bad);
+        resolve12();
+      };
+      const bad = (e) => {
+        wss.off("listening", ok);
+        reject(e);
+      };
+      wss.once("listening", ok);
+      wss.once("error", bad);
+    });
+    console.log(`[ccBridge] listening on 127.0.0.1:${this.boundPort} (${this.queuedCount()} queued)`);
+  }
+  handleFrame(ws, data) {
+    let msg2;
+    try {
+      msg2 = JSON.parse(String(data));
+    } catch {
+      this.sendTo(ws, { type: "error", error: "bad json" });
+      return;
+    }
+    if (msg2.type === "ping") {
+      this.sendTo(ws, { type: "pong" });
+      return;
+    }
+    if (msg2.type === "ack") {
+      const ids = Array.isArray(msg2.ids) ? msg2.ids.map(String) : [];
+      const n = this.ack(ids);
+      this.sendTo(ws, { type: "ack-ok", removed: n, queued: this.queuedCount() });
+      return;
+    }
+    if (msg2.type === "chat") {
+      const text = String(msg2.text ?? "").trim();
+      if (!text) {
+        this.sendTo(ws, { type: "error", error: "empty text" });
+        return;
+      }
+      const from = String(msg2.from || this.config.userId || "cc");
+      const inbound = {
+        content: text,
+        from,
+        fromName: String(msg2.fromName || from),
+        channel_id: this.name,
+        channel: this.name,
+        channelType: "dm",
+        isBot: false,
+        messageId: `ccb-${Date.now()}-${++this.seq}`,
+        recvAt: Date.now()
+      };
+      console.log(`[ccBridge] \u2190 ${inbound.fromName}: ${text.slice(0, 80)}`);
+      this.messageHandler?.(inbound);
+      return;
+    }
+    this.sendTo(ws, { type: "error", error: `unknown type: ${msg2.type}` });
+  }
+  sendTo(ws, payload) {
+    if (ws.readyState !== WebSocket2.OPEN) return;
+    try {
+      ws.send(JSON.stringify(payload));
+    } catch {
+    }
+  }
+  /** 广播给出站消息之外的控制帧（握手/pong 走 sendTo 单播） */
+  broadcast(payload) {
+    const s = JSON.stringify(payload);
+    let n = 0;
+    for (const ws of [...this.clients]) {
+      if (ws.readyState !== WebSocket2.OPEN) {
+        this.clients.delete(ws);
+        continue;
+      }
+      try {
+        ws.send(s);
+        n++;
+      } catch {
+        this.clients.delete(ws);
+      }
+    }
+    return n;
+  }
+  async disconnect() {
+    for (const ws of [...this.clients]) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    this.wss?.close();
+    this.wss = null;
+  }
+  // ── 出站 ──
+  /**
+   * 发消息给 CC。
+   *
+   * **先落 outbox 再推实时** —— 顺序反过来的话，推送成功但 CC 恰好这时断开，
+   * 这条消息就既不在队列里也没送达，静默消失。宁可重复，不可丢失：
+   * 重复只是多读一遍，丢失是 agent 主动说了话而没人知道。
+   */
+  async send(_target, message, _options) {
+    if (!message.trim()) return;
+    const item = {
+      id: `m${Date.now()}-${++this.seq}`,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      text: message,
+      agent: this.config.agentName || "agent"
+    };
+    this.enqueue(item);
+    const n = this.broadcast({ type: "message", message: item });
+    if (n === 0) console.log(`[ccBridge] CC \u4E0D\u5728\u7EBF\uFF0C\u5DF2\u5165\u961F\uFF08${this.queuedCount()} \u6761\u5F85\u6536\uFF09`);
+  }
+  /**
+   * 发文件。
+   *
+   * **只送路径，不送内容**（`mode: 'path-ref'`）。这个通道两端都在 127.0.0.1 上
+   * （引擎与 CC 同机），把文件 base64 塞进 WS 帧纯属浪费 —— 大文件还会把 outbox 撑爆。
+   *
+   * ⚠️ **但"只送路径"是把解析推迟到接收端，推迟不等于可以不做。**
+   * 它有一个很难看的退化形态：发送端返回「已发送」（路径形式上没问题），
+   * 接收端拿着路径在**它自己的机器上**找不到 —— **失败发生在接收端，
+   * 而发送端日志一切正常**。（张小T 0928 指出的，她是对的。）
+   *
+   * 所以这里补两道：
+   *   1. **入队前 `statSync`** —— 路径打错/文件被挪走，**在本机就报错**，
+   *      而不是等接收端去找一个不存在的路径
+   *   2. 帧里带 `size`/`mtimeMs` + `mode: 'path-ref'` —— 接收端知道这是**引用不是内容**，
+   *      且能对一下"拿到的是不是你说的那份"
+   *
+   * 客户端那侧对应地**读不到就不 ack**（见 `scripts/cc-inbox.mjs`）——
+   * ack 的语义是"我拿到了"，拿到一半不能算。
+   */
+  async sendFile(_target, message, attachment) {
+    let st;
+    try {
+      st = fs41.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),
+      mimeType: attachment.mimeType || "application/octet-stream",
+      size: st.size,
+      mtimeMs: Math.round(st.mtimeMs)
+    };
+    const item = {
+      id: `f${Date.now()}-${++this.seq}`,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      text: message || "",
+      agent: this.config.agentName || "agent",
+      file: file2
+    };
+    this.enqueue(item);
+    if (this.broadcast({ type: "message", message: item }) === 0) {
+      console.log(`[ccBridge] CC \u4E0D\u5728\u7EBF\uFF0C\u9644\u4EF6\u5DF2\u5165\u961F\uFF1A${file2.filename}`);
+    }
+  }
+};
+
 // src/channels/manager.ts
-var MANAGED_CHANNEL_NAMES = ["discord", "feishu", "wechat", "deskBuddy"];
+var MANAGED_CHANNEL_NAMES = ["discord", "feishu", "wechat", "deskBuddy", "ccBridge"];
 var defaultFactories = {
   discord: (block) => {
     const accounts = block.accounts || {};
@@ -36602,6 +36984,9 @@ var defaultFactories = {
   },
   deskBuddy: (block) => {
     return new DeskBuddyAdapter(block);
+  },
+  ccBridge: (block) => {
+    return new CcBridgeAdapter(block);
   }
 };
 var ChannelManager = class {
@@ -36873,20 +37258,20 @@ var ChannelManager = class {
 // src/session/session-manager.ts
 init_types();
 init_types();
-import * as path42 from "node:path";
-import * as fs42 from "node:fs";
+import * as path43 from "node:path";
+import * as fs43 from "node:fs";
 import * as crypto6 from "node:crypto";
 
 // src/session/reader.ts
 init_attachments();
-import * as fs41 from "node:fs";
-import * as path41 from "node:path";
+import * as fs42 from "node:fs";
+import * as path42 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 = fs41.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs42.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream });
   return new Promise((resolve12) => {
     let resolved = false;
@@ -36917,7 +37302,7 @@ async function readSessionHeader(filePath) {
   });
 }
 async function readLargeFilePostBoundary(filePath) {
-  const stat4 = fs41.statSync(filePath);
+  const stat4 = fs42.statSync(filePath);
   const fileSize = stat4.size;
   const boundaryMarker = '"compact_boundary"';
   const CHUNK_SIZE = TRANSCRIPT_READ_CHUNK_SIZE;
@@ -36925,13 +37310,13 @@ async function readLargeFilePostBoundary(filePath) {
   let outLen = 0;
   let boundaryStartOffset = 0;
   const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
-  const fd = fs41.openSync(filePath, "r");
+  const fd = fs42.openSync(filePath, "r");
   try {
     let filePos = 0;
     let carryBuf;
     let carryLen = 0;
     while (filePos < fileSize) {
-      const bytesRead = fs41.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
+      const bytesRead = fs42.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
       if (bytesRead === 0) break;
       filePos += bytesRead;
       let scanBuf;
@@ -36983,7 +37368,7 @@ async function readLargeFilePostBoundary(filePath) {
       }
     }
   } finally {
-    fs41.closeSync(fd);
+    fs42.closeSync(fd);
   }
   const postBoundaryText = outBuf.subarray(0, outLen).toString("utf-8");
   return postBoundaryText.split("\n").filter((l) => l.trim().length > 0);
@@ -37107,7 +37492,7 @@ function recoverOrphanedParallelToolResults(allEntries, chain, byUuid, seen) {
   return result;
 }
 async function readSessionHistory(filePath) {
-  const stat4 = fs41.statSync(filePath);
+  const stat4 = fs42.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`);
@@ -37146,7 +37531,7 @@ async function readSessionHistory(filePath) {
   return [...sessionStarts, ...filtered, ...restAttachments];
 }
 async function readAllLines(filePath) {
-  const stream = fs41.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs42.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream });
   const lines = [];
   return new Promise((resolve12, reject) => {
@@ -37300,12 +37685,12 @@ function extractText4(content) {
   return content.filter((b) => b.type === "text").map((b) => b.text || "").join("") || null;
 }
 function listSessions(sessionsDir) {
-  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),
+  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),
     id: f.replace(/\.jsonl.*$/, ""),
     // strip .jsonl and everything after (archived suffix)
-    modified: new Date(fs41.statSync(path41.join(sessionsDir, f)).mtimeMs)
+    modified: new Date(fs42.statSync(path42.join(sessionsDir, f)).mtimeMs)
   })).sort((a, b) => b.modified.getTime() - a.modified.getTime());
   return files;
 }
@@ -37340,24 +37725,24 @@ var SessionManager = class {
   constructor(config) {
     this.config = config;
     this.scopeConfig = config.scopeConfig;
-    this.sessionsDir = path42.join(config.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 });
+    this.sessionsDir = path43.join(config.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 });
   }
   // === 索引操作 ===
   loadIndex() {
     try {
-      if (fs42.existsSync(this.indexPath)) {
-        const raw = fs42.readFileSync(this.indexPath, "utf-8");
+      if (fs43.existsSync(this.indexPath)) {
+        const raw = fs43.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 (fs42.existsSync(entry.file)) continue;
-          const basename10 = path42.basename(entry.file);
-          const localPath = path42.join(this.sessionsDir, basename10);
-          if (fs42.existsSync(localPath)) {
+          if (fs43.existsSync(entry.file)) continue;
+          const basename10 = path43.basename(entry.file);
+          const localPath = path43.join(this.sessionsDir, basename10);
+          if (fs43.existsSync(localPath)) {
             entry.file = localPath;
             fixed++;
           }
@@ -37376,7 +37761,7 @@ var SessionManager = class {
     try {
       const obj = {};
       for (const [k, v] of this.index) obj[k] = v;
-      fs42.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
+      fs43.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
     } catch (err) {
       console.error(`[session] Failed to save index: ${err.message}`);
     }
@@ -37384,8 +37769,8 @@ var SessionManager = class {
   // === 平台映射 ===
   loadPlatformMap() {
     try {
-      if (fs42.existsSync(this.platformMapPath)) {
-        const raw = fs42.readFileSync(this.platformMapPath, "utf-8");
+      if (fs43.existsSync(this.platformMapPath)) {
+        const raw = fs43.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`);
@@ -37397,7 +37782,7 @@ var SessionManager = class {
     try {
       const obj = {};
       for (const [k, v] of this.platformMap) obj[k] = v;
-      fs42.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
+      fs43.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
     } catch (err) {
       console.error(`[session] Failed to save platform map: ${err.message}`);
     }
@@ -37436,17 +37821,17 @@ var SessionManager = class {
    */
   getSessionFilePath(sessionId) {
     const entry = this.index.get(sessionId);
-    if (entry && fs42.existsSync(entry.file)) return entry.file;
-    const direct = path42.join(this.sessionsDir, `${sessionId}.jsonl`);
-    return fs42.existsSync(direct) ? direct : null;
+    if (entry && fs43.existsSync(entry.file)) return entry.file;
+    const direct = path43.join(this.sessionsDir, `${sessionId}.jsonl`);
+    return fs43.existsSync(direct) ? direct : null;
   }
   // === Writer 管理 ===
   getWriter(sessionId) {
     let writer = this.writers.get(sessionId);
     if (!writer) {
       const existing = this.index.get(sessionId);
-      if (existing && fs42.existsSync(existing.file)) {
-        const existingFileId = path42.basename(existing.file, ".jsonl");
+      if (existing && fs43.existsSync(existing.file)) {
+        const existingFileId = path43.basename(existing.file, ".jsonl");
         writer = new SessionWriter(this.sessionsDir, existingFileId);
         writer.open(this.config.workspace, sessionId);
       } else {
@@ -37458,7 +37843,7 @@ var SessionManager = class {
       this.saveIndex();
       this.writers.set(sessionId, writer);
       this.onWriterCreated?.(writer, sessionId);
-      console.log(`[session] ${existing ? "Resumed" : "New"}: ${sessionId} \u2192 ${path42.basename(writer.path)}`);
+      console.log(`[session] ${existing ? "Resumed" : "New"}: ${sessionId} \u2192 ${path43.basename(writer.path)}`);
     }
     return writer;
   }
@@ -37477,7 +37862,7 @@ var SessionManager = class {
     if (!writer) return null;
     try {
       this.lastArchiveCheck = Date.now();
-      const stat4 = fs42.statSync(writer.path);
+      const stat4 = fs43.statSync(writer.path);
       if (stat4.size < threshold) return null;
       const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
       const thresholdMB = (threshold / 1024 / 1024).toFixed(1);
@@ -37486,10 +37871,10 @@ var SessionManager = class {
       if (archivedPath) {
         this.index.set(sessionId, { file: writer.path, updatedAt: Date.now() });
         this.saveIndex();
-        const newSize = fs42.statSync(writer.path).size;
+        const newSize = fs43.statSync(writer.path).size;
         const oldSizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-        console.log(`[session] Archive complete: ${path42.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
-        const fileId = path42.basename(writer.path).replace(/\.jsonl$/, "");
+        console.log(`[session] Archive complete: ${path43.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
+        const fileId = path43.basename(writer.path).replace(/\.jsonl$/, "");
         this.purgeOldArchives(fileId, 3);
         return archivedPath;
       }
@@ -37505,15 +37890,15 @@ var SessionManager = class {
   purgeOldArchives(sessionId, keepCount = 3) {
     try {
       const dir = this.sessionsDir;
-      if (!fs42.existsSync(dir)) return;
-      const allFiles = fs42.readdirSync(dir);
+      if (!fs43.existsSync(dir)) return;
+      const allFiles = fs43.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: path42.join(dir, f),
-        mtime: fs42.statSync(path42.join(dir, f)).mtimeMs
+        path: path43.join(dir, f),
+        mtime: fs43.statSync(path43.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;
@@ -37523,7 +37908,7 @@ var SessionManager = class {
           console.log(`[session] Skipping archived (kept for history): ${f.name}`);
           continue;
         }
-        fs42.unlinkSync(f.path);
+        fs43.unlinkSync(f.path);
         console.log(`[session] Purged old archive: ${f.name}`);
       }
       if (toDelete.length > 0) {
@@ -37572,29 +37957,29 @@ var SessionManager = class {
   /** 列出 session 的所有文件（当前 + 归档），按修改时间排序 */
   findAllSessionFiles(sessionId) {
     const results = [];
-    const mainFile = path42.join(this.sessionsDir, `${sessionId}.jsonl`);
-    if (fs42.existsSync(mainFile)) {
+    const mainFile = path43.join(this.sessionsDir, `${sessionId}.jsonl`);
+    if (fs43.existsSync(mainFile)) {
       results.push(mainFile);
     }
-    if (fs42.existsSync(this.sessionsDir)) {
-      const compactionFiles = fs42.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
+    if (fs43.existsSync(this.sessionsDir)) {
+      const compactionFiles = fs43.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
         name: f,
-        path: path42.join(this.sessionsDir, f),
-        mtime: fs42.statSync(path42.join(this.sessionsDir, f)).mtimeMs
+        path: path43.join(this.sessionsDir, f),
+        mtime: fs43.statSync(path43.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 = fs42.statSync(a).mtimeMs;
-      const tb = fs42.statSync(b).mtimeMs;
+      const ta = fs43.statSync(a).mtimeMs;
+      const tb = fs43.statSync(b).mtimeMs;
       return ta - tb;
     });
     return results;
   }
   async findSessionFiles(sessionId) {
-    if (!fs42.existsSync(this.sessionsDir)) {
+    if (!fs43.existsSync(this.sessionsDir)) {
       console.log(`[session:find] SESSIONS_DIR not found: ${this.sessionsDir}`);
       return [];
     }
@@ -37606,15 +37991,15 @@ var SessionManager = class {
         return mappedFiles;
       }
       const indexedEntry = this.index.get(mappedId);
-      if (indexedEntry && fs42.existsSync(indexedEntry.file)) {
-        const fileUuid = path42.basename(indexedEntry.file, ".jsonl");
+      if (indexedEntry && fs43.existsSync(indexedEntry.file)) {
+        const fileUuid = path43.basename(indexedEntry.file, ".jsonl");
         return this.findAllSessionFiles(fileUuid);
       }
     }
     const allFiles = this.findAllSessionFiles(sessionId);
     if (allFiles.length > 0) {
       const labels = allFiles.map((f) => {
-        const base = path42.basename(f);
+        const base = path43.basename(f);
         return base.endsWith(".jsonl") ? base : `${base} (archived)`;
       });
       console.log(`[session:find] Found ${allFiles.length} file(s) for ${sessionId}: ${labels.join(", ")}`);
@@ -37622,9 +38007,9 @@ var SessionManager = class {
     }
     const indexed = this.index.get(sessionId);
     if (indexed) {
-      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"));
+      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"));
       }
     } else {
       console.log(`[session:find] Index miss: ${sessionId} (index has ${this.index.size} entries)`);
@@ -37653,8 +38038,8 @@ var SessionManager = class {
       return [];
     }
     files.sort((a, b) => {
-      const ta = fs42.statSync(a).mtimeMs;
-      const tb = fs42.statSync(b).mtimeMs;
+      const ta = fs43.statSync(a).mtimeMs;
+      const tb = fs43.statSync(b).mtimeMs;
       return ta - tb;
     });
     const latestFile = files[files.length - 1];
@@ -37662,7 +38047,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 ${path42.basename(latestFile)}`);
+      console.log(`[session:restore] Synced index: ${sessionId} \u2192 ${path43.basename(latestFile)}`);
     }
     const allMessages = [];
     for (const file2 of files) {
@@ -37701,7 +38086,7 @@ var SessionManager = class {
       if (isAttachmentMessage(m) && m.attachment.type === "relevant_memories") {
         for (const mem of m.attachment.memories) {
           rawCount++;
-          restoredPaths.add(path42.resolve(mem.path));
+          restoredPaths.add(path43.resolve(mem.path));
         }
       }
     }
@@ -37733,15 +38118,15 @@ var SessionManager = class {
    */
   rotateMainSession() {
     const entry = this.index.get("main");
-    if (!entry || !fs42.existsSync(entry.file)) return;
-    const oldFileId = path42.basename(entry.file, ".jsonl");
-    const stat4 = fs42.statSync(entry.file);
+    if (!entry || !fs43.existsSync(entry.file)) return;
+    const oldFileId = path43.basename(entry.file, ".jsonl");
+    const stat4 = fs43.statSync(entry.file);
     if (stat4.size < 1024) return;
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
     const archivedPath = `${entry.file}.archived.${ts}`;
-    fs42.renameSync(entry.file, archivedPath);
+    fs43.renameSync(entry.file, archivedPath);
     const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-    console.log(`[session] Archived: ${path42.basename(entry.file)} \u2192 ${path42.basename(archivedPath)} (${sizeMB}MB)`);
+    console.log(`[session] Archived: ${path43.basename(entry.file)} \u2192 ${path43.basename(archivedPath)} (${sizeMB}MB)`);
     const newWriter = new SessionWriter(this.sessionsDir);
     newWriter.open(this.config.workspace, "main");
     newWriter.writeModelChange(this.config.providerId, this.config.model);
@@ -37750,7 +38135,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 ${path42.basename(newPath)}`);
+    console.log(`[session] Rotated main: ${oldFileId}.jsonl \u2192 ${path43.basename(newPath)}`);
   }
   // === 迁移 ===
   /** 迁移旧索引：session-index.json 里有 "discord:xxx" 格式的 key 时，生成 UUID 替换 */
@@ -38553,7 +38938,7 @@ Examples:
     properties: {
       to: { type: "string", description: "\u63A5\u6536\u8005ID\u3002\u586B channel_id \u65F6\u81EA\u52A8 @\u5BF9\u65B9\uFF1B\u4E0D\u586B channel_id \u65F6\u53D1 DM\u3002\u591A\u4E2A\u6536\u4EF6\u4EBA\u7528\u9017\u53F7\u5206\u9694\u3002" },
       channel_id: { type: "string", description: "\u9891\u9053 ID\uFF08\u53EF\u9009\uFF09\u3002\u4E0D\u586B\u5219\u53D1 DM \u7ED9 to\u3002\u90FD\u4E0D\u586B\u65F6\u56DE\u590D\u6765\u6E90\u9891\u9053\u3002" },
-      source: { type: "string", description: "\u6765\u6E90\u901A\u9053\uFF1Adiscord / feishu / wechat / deskBuddy\uFF08\u684C\u9762\u5C0F\u96EF\u8BED\u97F3\uFF09\u3002\u4E0D\u586B\u65F6\u4F7F\u7528\u5F53\u524D\u6765\u6E90\u901A\u9053\u3002", enum: ["discord", "feishu", "wechat", "deskBuddy"] },
+      source: { type: "string", description: "\u6765\u6E90\u901A\u9053\uFF1Adiscord / feishu / wechat / deskBuddy\uFF08\u684C\u9762\u5C0F\u96EF\u8BED\u97F3\uFF09/ ccBridge\uFF08CC\uFF0C\u672C\u673A\u5F00\u53D1\u901A\u9053\uFF09\u3002\u4E0D\u586B\u65F6\u4F7F\u7528\u5F53\u524D\u6765\u6E90\u901A\u9053\u3002", enum: ["discord", "feishu", "wechat", "deskBuddy", "ccBridge"] },
       content: { type: "string", description: "\u6D88\u606F\u6B63\u6587" }
     },
     required: ["content", "to"]
@@ -38642,12 +39027,12 @@ Examples:
 // src/tools/msg-husband.ts
 init_registry();
 init_live();
-import fs43 from "node:fs";
-import path43 from "node:path";
+import fs44 from "node:fs";
+import path44 from "node:path";
 function getHusbandFeishuId(workspace) {
-  const contactsPath = path43.join(workspace, "prompts", "contacts.md");
+  const contactsPath = path44.join(workspace, "prompts", "contacts.md");
   try {
-    const text = fs43.readFileSync(contactsPath, "utf-8");
+    const text = fs44.readFileSync(contactsPath, "utf-8");
     const m = text.match(/\|\s*翀哥\s*\|\s*(ou_[a-f0-9]+)\s*\|/);
     return m ? m[1] : null;
   } catch {
@@ -38789,8 +39174,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 fs58 = await import("node:fs");
-    if (!fs58.existsSync(filePath)) {
+    const fs59 = await import("node:fs");
+    if (!fs59.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) : [];
@@ -38818,7 +39203,7 @@ Examples:
       md: "text/markdown"
     };
     const mimeType = mimeTypeMap[ext] || "application/octet-stream";
-    const stat4 = fs58.statSync(filePath);
+    const stat4 = fs59.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 };
@@ -38848,8 +39233,8 @@ Examples:
 init_live();
 init_registry();
 init_well_formed();
-import * as fs44 from "node:fs";
-import * as path44 from "node:path";
+import * as fs45 from "node:fs";
+import * as path45 from "node:path";
 var MIME_MAP = {
   ".jpg": "jpeg",
   ".jpeg": "jpeg",
@@ -38861,9 +39246,9 @@ var MIME_MAP = {
 var VIDEO_EXT = /\.(mp4|mov)$/i;
 var VIDEO_MAX_BYTES = 40 * 1024 * 1024;
 function resolveLatestImage(specifiedPath, mediaDir) {
-  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);
+  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);
   return files[0]?.p || null;
 }
 registry.register({
@@ -38894,21 +39279,21 @@ registry.register({
     if (!provider?.streamChat) {
       return { content: "Error: provider \u4E0D\u53EF\u7528\u3002", isError: true };
     }
-    const mediaDir = path44.join(ctx.stateDir, "media", "inbound");
+    const mediaDir = path45.join(ctx.stateDir, "media", "inbound");
     const imagePath = resolveLatestImage(args.image_path, mediaDir);
     if (!imagePath) {
       return { content: "Error: no image found. Provide image_path or ensure media/inbound has images.", isError: true };
     }
     const rawPrompt = args.prompt?.trim() || "\u63CF\u8FF0\u8FD9\u5F20\u56FE\u7247\u7684\u5185\u5BB9";
-    const ext = path44.extname(imagePath).toLowerCase();
+    const ext = path45.extname(imagePath).toLowerCase();
     if (VIDEO_EXT.test(imagePath)) {
-      const stat4 = fs44.statSync(imagePath);
+      const stat4 = fs45.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 = fs44.readFileSync(imagePath).toString("base64");
+      const vidB64 = fs45.readFileSync(imagePath).toString("base64");
       try {
         const res = await fetch(`${baseUrl}/chat/completions`, {
           method: "POST",
@@ -38938,7 +39323,7 @@ registry.register({
       }
     }
     const mime = MIME_MAP[ext] || "jpeg";
-    const imgB64 = fs44.readFileSync(imagePath).toString("base64");
+    const imgB64 = fs45.readFileSync(imagePath).toString("base64");
     const userMsg = {
       role: "user",
       content: [
@@ -39016,7 +39401,7 @@ var TTS_PROVIDERS = [
 init_registry();
 
 // src/tools/opus-encoder.ts
-import * as fs45 from "node:fs";
+import * as fs46 from "node:fs";
 var FRAME_MS = 20;
 var PRESKIP_48K = 312;
 var OPUS_RATE = 48e3;
@@ -39133,7 +39518,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(fs45.readFileSync(wavPath));
+  const wav = parseWav(fs46.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");
@@ -39169,7 +39554,7 @@ async function wavToOggOpusNative(wavPath) {
   }
   ogg.page(cur, pageGranule, false, true);
   const oggPath = wavPath.replace(/\.wav$/, ".ogg");
-  fs45.writeFileSync(oggPath, ogg.finish());
+  fs46.writeFileSync(oggPath, ogg.finish());
   return oggPath;
 }
 
@@ -39198,10 +39583,10 @@ function fallbackChainOf(raw) {
 init_live();
 
 // src/tools/tts/relay.ts
-import * as fs46 from "node:fs";
+import * as fs47 from "node:fs";
 import * as os6 from "node:os";
-import * as path45 from "node:path";
-var VOICE_DIR2 = path45.join(os6.tmpdir(), "engine-voice");
+import * as path46 from "node:path";
+var VOICE_DIR2 = path46.join(os6.tmpdir(), "engine-voice");
 var fetchFn = fetch;
 async function synthRelay(text, cfg) {
   const res = await fetchFn(`${cfg.baseUrl}/audio/speech`, {
@@ -39220,9 +39605,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`);
-  fs46.mkdirSync(VOICE_DIR2, { recursive: true });
-  const out = path45.join(VOICE_DIR2, `tts_relay_${Date.now()}.mp3`);
-  fs46.writeFileSync(out, buf);
+  fs47.mkdirSync(VOICE_DIR2, { recursive: true });
+  const out = path46.join(VOICE_DIR2, `tts_relay_${Date.now()}.mp3`);
+  fs47.writeFileSync(out, buf);
   return {
     path: out,
     format: "mp3",
@@ -39341,8 +39726,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 fs47 from "node:fs";
-import * as path46 from "node:path";
+import * as fs48 from "node:fs";
+import * as path47 from "node:path";
 var execFileAsync3 = promisify3(execFile3);
 async function toWav24kWithDuration(audioPath) {
   let wavPath = audioPath;
@@ -39360,15 +39745,15 @@ async function toWav24kWithDuration(audioPath) {
       "pcm_s16le",
       wavPath
     ], { timeout: 3e4 });
-    if (!fs47.existsSync(wavPath) || fs47.statSync(wavPath).size < 44) {
+    if (!fs48.existsSync(wavPath) || fs48.statSync(wavPath).size < 44) {
       throw new Error("toWav24k produced empty output");
     }
     try {
-      fs47.unlinkSync(audioPath);
+      fs48.unlinkSync(audioPath);
     } catch {
     }
   }
-  const durationSec = wavDurationSec(fs47.readFileSync(wavPath));
+  const durationSec = wavDurationSec(fs48.readFileSync(wavPath));
   return { wavPath, durationSec };
 }
 async function compressWav(wavPath) {
@@ -39386,7 +39771,7 @@ async function compressWav(wavPath) {
       "+faststart",
       m4aPath
     ], { timeout: 3e4 });
-    fs47.unlinkSync(wavPath);
+    fs48.unlinkSync(wavPath);
     return m4aPath;
   } catch {
     return wavPath;
@@ -39413,10 +39798,10 @@ async function wavToOggOpus(wavPath) {
       oggPath
     ], { timeout: 3e4 });
   }
-  if (!fs47.existsSync(oggPath) || fs47.statSync(oggPath).size < 20) {
+  if (!fs48.existsSync(oggPath) || fs48.statSync(oggPath).size < 20) {
     throw new Error("ogg/opus encode produced empty output");
   }
-  fs47.unlinkSync(wavPath);
+  fs48.unlinkSync(wavPath);
   return oggPath;
 }
 async function sendVoiceToMulticaIssue(text, issueId, opts) {
@@ -39431,7 +39816,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 || !fs47.existsSync(audioPath)) {
+  if (!audioPath || !fs48.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")) {
@@ -39441,21 +39826,21 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
       console.warn(`[my-voice:multaca] opus encode failed (${e.message}), attaching wav`);
     }
   }
-  const ext = path46.extname(audioPath).toLowerCase();
-  const sizeKB = fs47.statSync(audioPath).size / 1024;
+  const ext = path47.extname(audioPath).toLowerCase();
+  const sizeKB = fs48.statSync(audioPath).size / 1024;
   const voiceFile = `voice_${Date.now()}${ext}`;
-  const cwdCopy = path46.join(process.cwd(), voiceFile);
+  const cwdCopy = path47.join(process.cwd(), voiceFile);
   try {
-    fs47.copyFileSync(audioPath, cwdCopy);
+    fs48.copyFileSync(audioPath, cwdCopy);
   } catch (e) {
     try {
-      fs47.unlinkSync(audioPath);
+      fs48.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 {
-    fs47.unlinkSync(audioPath);
+    fs48.unlinkSync(audioPath);
   } catch {
   }
   const content = opts.caption || `\u{1F399}\uFE0F \u8BED\u97F3\u6D88\u606F\uFF08${text.length} \u5B57\uFF09`;
@@ -39484,13 +39869,13 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
     }
     if (!ok) throw new Error(`unexpected CLI output: ${String(stdout).slice(0, 200)}`);
     try {
-      fs47.unlinkSync(cwdCopy);
+      fs48.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 {
-      fs47.unlinkSync(cwdCopy);
+      fs48.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 };
@@ -39607,10 +39992,10 @@ registry.register({
         audioPath = await compressWav(audioPath);
       }
     }
-    const ext = path46.extname(audioPath).toLowerCase();
+    const ext = path47.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 = fs47.statSync(audioPath).size / 1024;
+    const sizeKB = fs48.statSync(audioPath).size / 1024;
     try {
       await mgr.sendFile(resolvedChannel, target, caption, {
         path: audioPath,
@@ -39619,7 +40004,7 @@ registry.register({
         ...voiceDurationSec !== void 0 ? { voiceDurationSec } : {}
       });
       try {
-        fs47.unlinkSync(audioPath);
+        fs48.unlinkSync(audioPath);
       } catch {
       }
       return { content: `Voice sent! (${actualEngine}, ${sizeKB.toFixed(0)}KB, ${resolvedChannel})` };
@@ -39637,8 +40022,8 @@ registry.register({
 init_live();
 init_registry();
 init_well_formed();
-import * as fs48 from "node:fs";
-import * as path47 from "node:path";
+import * as fs49 from "node:fs";
+import * as path48 from "node:path";
 function getProxyDispatcher2() {
   const cfg = liveConfig.all();
   const proxy = cfg.providers?.xai?.proxy;
@@ -39652,7 +40037,7 @@ function getProxyDispatcher2() {
 }
 function dimsOf(p) {
   try {
-    const b = fs48.readFileSync(p);
+    const b = fs49.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);
@@ -39775,9 +40160,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 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}`);
+    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}`);
   } catch (e) {
     console.warn(`[my-selfie] \u5199\u5165 references \u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u672C\u6B21\u51FA\u56FE\uFF09: ${e.message}`);
   }
@@ -40058,10 +40443,10 @@ registry.register({
     const REFERENCES = getReferences(ctx);
     const refName = args.reference || "default";
     const refEntry = REFERENCES.find((r) => r.name === refName) || REFERENCES[0];
-    let refPath = path47.join(ctx.workspace, refEntry.p);
+    let refPath = path48.join(ctx.workspace, refEntry.p);
     const adoptImg = args.referenceImage?.trim();
     if (adoptImg) {
-      if (!fs48.existsSync(adoptImg)) {
+      if (!fs49.existsSync(adoptImg)) {
         return { content: `\u627E\u4E0D\u5230\u90A3\u5F20\u56FE\uFF1A${adoptImg}`, isError: true };
       }
       const acheck = dimsOf(adoptImg);
@@ -40072,16 +40457,16 @@ registry.register({
           isError: true
         };
       }
-      const adir = path47.join(ctx.workspace, "images");
-      if (!fs48.existsSync(adir)) fs48.mkdirSync(adir, { recursive: true });
-      const aext = (path47.extname(adoptImg) || ".png").toLowerCase();
+      const adir = path48.join(ctx.workspace, "images");
+      if (!fs49.existsSync(adir)) fs49.mkdirSync(adir, { recursive: true });
+      const aext = (path48.extname(adoptImg) || ".png").toLowerCase();
       const afname = `portrait_${Date.now()}${aext}`;
-      fs48.copyFileSync(adoptImg, path47.join(adir, afname));
+      fs49.copyFileSync(adoptImg, path48.join(adir, afname));
       registerPortrait(`images/${afname}`, refName);
-      refPath = path47.join(adir, afname);
+      refPath = path48.join(adir, afname);
       console.log(`[my-selfie] \u91C7\u7EB3\u73B0\u6210\u56FE\u5F53\u5F62\u8C61\uFF1Aimages/${afname}${acheck ? ` (${acheck})` : ""}`);
     }
-    if (provider !== "autodl" && !fs48.existsSync(refPath)) {
+    if (provider !== "autodl" && !fs49.existsSync(refPath)) {
       const cfgAll = liveConfig.all();
       const portraitDesc = resolvePortraitDesc(
         args.portrait,
@@ -40106,16 +40491,16 @@ registry.register({
       } catch (e) {
         return { content: `\u5851\u9020\u5F62\u8C61\u5931\u8D25\uFF1A${e.message}`, isError: true };
       }
-      const pdir = path47.join(ctx.workspace, "images");
-      if (!fs48.existsSync(pdir)) fs48.mkdirSync(pdir, { recursive: true });
+      const pdir = path48.join(ctx.workspace, "images");
+      if (!fs49.existsSync(pdir)) fs49.mkdirSync(pdir, { recursive: true });
       const pfname = `portrait_${Date.now()}.png`;
-      fs48.writeFileSync(path47.join(pdir, pfname), portraitBuf);
+      fs49.writeFileSync(path48.join(pdir, pfname), portraitBuf);
       registerPortrait(`images/${pfname}`, refName);
-      refPath = path47.join(pdir, pfname);
+      refPath = path48.join(pdir, pfname);
       console.log(`[my-selfie] \u5F62\u8C61\u5DF2\u5B58 images/${pfname}\uFF0C\u7EE7\u7EED\u8FD9\u6B21\u81EA\u62CD`);
     }
     const resolution = args.resolution || DEFAULT_RESOLUTION;
-    const refB64 = fs48.existsSync(refPath) ? fs48.readFileSync(refPath).toString("base64") : "";
+    const refB64 = fs49.existsSync(refPath) ? fs49.readFileSync(refPath).toString("base64") : "";
     let imageBuffer;
     try {
       if (provider === "autodl") {
@@ -40131,7 +40516,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 = path47.extname(refPath).toLowerCase();
+        const ext = path48.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 {
@@ -40140,11 +40525,11 @@ registry.register({
     } catch (err) {
       return { content: `Selfie generation failed: ${err.message}`, isError: true };
     }
-    const imagesDir = path47.join(ctx.workspace, "images");
-    if (!fs48.existsSync(imagesDir)) fs48.mkdirSync(imagesDir, { recursive: true });
+    const imagesDir = path48.join(ctx.workspace, "images");
+    if (!fs49.existsSync(imagesDir)) fs49.mkdirSync(imagesDir, { recursive: true });
     const filename = `selfie_${Date.now()}.jpg`;
-    const outputPath = path47.join(imagesDir, filename);
-    fs48.writeFileSync(outputPath, imageBuffer);
+    const outputPath = path48.join(imagesDir, filename);
+    fs49.writeFileSync(outputPath, imageBuffer);
     const mgr = ctx.channelManager;
     if (mgr) {
       const resolvedChannel = ctx.channel || "feishu";
@@ -40155,11 +40540,11 @@ registry.register({
           mimeType: "image/jpeg"
         });
       } catch (err) {
-        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path47.resolve(outputPath)}`, isError: false };
+        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path48.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: ${path47.resolve(outputPath)}` };
+    return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path48.resolve(outputPath)}` };
   },
   isConcurrencySafe: () => false,
   interruptBehavior: () => "block",
@@ -40711,8 +41096,8 @@ ${lines.join("\n")}` };
 init_registry();
 init_live();
 init_clock();
-import * as fs49 from "node:fs";
-import * as path48 from "node:path";
+import * as fs50 from "node:fs";
+import * as path49 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);
@@ -40721,9 +41106,9 @@ function getServices() {
 }
 function serviceLogPath(fileName) {
   const stateDir = String(liveConfig.get("stateDir") ?? "");
-  const logDir = path48.join(stateDir, "logs");
-  if (!fs49.existsSync(logDir)) fs49.mkdirSync(logDir, { recursive: true });
-  return path48.join(logDir, fileName);
+  const logDir = path49.join(stateDir, "logs");
+  if (!fs50.existsSync(logDir)) fs50.mkdirSync(logDir, { recursive: true });
+  return path49.join(logDir, fileName);
 }
 async function runCmd(cmd, timeoutMs = 15e3) {
   try {
@@ -41042,16 +41427,16 @@ var EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
 init_planModeState();
 
 // src/utils/plans.ts
-import * as fs50 from "node:fs";
-import * as path49 from "node:path";
+import * as fs51 from "node:fs";
+import * as path50 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 = path49.join(stateDir, "plans");
-  fs50.mkdirSync(plansDir, { recursive: true });
+  const plansDir = path50.join(stateDir, "plans");
+  fs51.mkdirSync(plansDir, { recursive: true });
   return plansDir;
 }
 var planSlugCache = /* @__PURE__ */ new Map();
@@ -41061,8 +41446,8 @@ function getPlanSlug(sessionId, stateDir) {
     const plansDir = getPlansDirectory(stateDir);
     for (let i = 0; i < MAX_SLUG_RETRIES; i++) {
       slug = generateSlug();
-      const filePath = path49.join(plansDir, `${slug}.md`);
-      if (!fs50.existsSync(filePath)) {
+      const filePath = path50.join(plansDir, `${slug}.md`);
+      if (!fs51.existsSync(filePath)) {
         break;
       }
     }
@@ -41073,21 +41458,21 @@ function getPlanSlug(sessionId, stateDir) {
 function getPlanFilePath(sessionId, stateDir, agentId) {
   const slug = getPlanSlug(sessionId, stateDir);
   if (!agentId) {
-    return path49.join(getPlansDirectory(stateDir), `${slug}.md`);
+    return path50.join(getPlansDirectory(stateDir), `${slug}.md`);
   }
-  return path49.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
+  return path50.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
 }
 function getPlan(sessionId, stateDir, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
   try {
-    return fs50.readFileSync(filePath, "utf-8");
+    return fs51.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writePlan(sessionId, stateDir, content, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
-  fs50.writeFileSync(filePath, content, "utf-8");
+  fs51.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 
@@ -41905,8 +42290,8 @@ async function setupFeatures(features, licensedFeatures) {
 init_agent_registry();
 
 // src/commands/work.ts
-import * as fs55 from "node:fs";
-import * as path55 from "node:path";
+import * as fs56 from "node:fs";
+import * as path56 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",
@@ -41919,20 +42304,20 @@ registerCommand({
   ],
   handler: async (ctx, deps) => {
     const mode = (ctx.args.mode || "").trim().toLowerCase();
-    const modeFile = path55.join(deps.config.workspace, ".work-mode");
+    const modeFile = path56.join(deps.config.workspace, ".work-mode");
     if (mode === "on" || mode === "off") {
-      fs55.writeFileSync(modeFile, mode, "utf8");
+      fs56.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 {
-        fs55.unlinkSync(modeFile);
+        fs56.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 = fs55.readFileSync(modeFile, "utf8").trim() || "auto";
+        cur = fs56.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";
@@ -42402,8 +42787,8 @@ ${err.stack}`);
 });
 
 // src/commands/model.ts
-import * as fs56 from "node:fs";
-import * as path56 from "node:path";
+import * as fs57 from "node:fs";
+import * as path57 from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function collectModels(config) {
   const aliases = config.modelAliases || {};
@@ -42435,11 +42820,11 @@ function resolveConfigWritePath(config, label) {
   const configPath = config._configFilePath;
   if (!configPath) return void 0;
   let writePath = configPath;
-  if (configPath && !fs56.existsSync(configPath)) {
+  if (configPath && !fs57.existsSync(configPath)) {
     const __pFile = fileURLToPath8(import.meta.url);
-    const __pDir = path56.dirname(__pFile);
-    const altPath = path56.join(path56.resolve(__pDir, "../configs"), path56.basename(configPath));
-    if (fs56.existsSync(altPath)) {
+    const __pDir = path57.dirname(__pFile);
+    const altPath = path57.join(path57.resolve(__pDir, "../configs"), path57.basename(configPath));
+    if (fs57.existsSync(altPath)) {
       console.warn(`[${label}] Config not found at ${configPath}, falling back to ${altPath}`);
       writePath = altPath;
     }
@@ -42594,14 +42979,14 @@ Use full ref like \`/primary ${candidates[0].ref}\``);
       return;
     }
     try {
-      const raw = await fs56.promises.readFile(writePath, "utf-8");
+      const raw = await fs57.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 fs56.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+      await fs57.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
       console.log(`[primary] Persisted primary=${target} to ${writePath}`);
       await ctx.reply(`\u2705 Primary model set to **${target}** (${candidates[0].name})
 Written to config, hot-reloading provider chain now.`);
@@ -42648,7 +43033,7 @@ Use full ref like \`/vision-primary ${candidates[0].ref}\``);
       return;
     }
     try {
-      const raw = await fs56.promises.readFile(writePath, "utf-8");
+      const raw = await fs57.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`);
@@ -42656,12 +43041,12 @@ Use full ref like \`/vision-primary ${candidates[0].ref}\``);
       }
       if (input === "auto" || input === "reset") {
         delete cfg.agents.defaults.model.vision;
-        await fs56.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+        await fs57.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 fs56.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+        await fs57.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})
 Written to config. Hot-reload will apply.`);
@@ -43069,7 +43454,7 @@ async function startEngine(config, opts) {
     const { initSessionMemory: initSessionMemory2 } = await Promise.resolve().then(() => (init_sessionMemory(), sessionMemory_exports));
     initSessionMemory2({
       workspace: config.workspace,
-      stateDir: path59.join(config.stateDir, "session-memory"),
+      stateDir: path60.join(config.stateDir, "session-memory"),
       provider,
       model: config.provider.modelId || config.model || "deepseek-v4-flash",
       features: config.profile.features