engine7 7.1.117 → 7.1.119

package/dist/cli.mjs

@@ -408,14 +408,14 @@ var init_live = __esm({
       }
       /** 把改动写回 config 文件对应段（找不到文件路径则只内存生效） */
       async persistToFile(dotPath, val) {
-        const fs43 = await import("node:fs");
+        const fs44 = await import("node:fs");
         const cfgPath = this.current?._configFilePath;
-        if (!cfgPath || !fs43.existsSync(cfgPath)) {
+        if (!cfgPath || !fs44.existsSync(cfgPath)) {
           console.warn(`[liveConfig] set: no config file path, in-memory only (${dotPath})`);
           return;
         }
         try {
-          const raw = JSON.parse(fs43.readFileSync(cfgPath, "utf-8"));
+          const raw = JSON.parse(fs44.readFileSync(cfgPath, "utf-8"));
           const keys = dotPath.split(".");
           let o = raw;
           for (let i = 0; i < keys.length - 1; i++) {
@@ -423,7 +423,7 @@ var init_live = __esm({
             o = o[keys[i]];
           }
           o[keys[keys.length - 1]] = val;
-          fs43.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+          fs44.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
           console.log(`[liveConfig] persisted ${dotPath} = ${JSON.stringify(val)} to ${cfgPath}`);
           markSelfWrite();
         } catch (e) {
@@ -714,8 +714,8 @@ function listSchemaFields() {
   if (process.env.ENGINE7_INTERNAL === "1") return FIELDS.slice();
   return FIELDS.filter((f) => !f.internal);
 }
-function getField(path43) {
-  return FIELDS.find((f) => f.path === path43);
+function getField(path44) {
+  return FIELDS.find((f) => f.path === path44);
 }
 function pick(obj, dotPath) {
   let cur = obj;
@@ -2073,6 +2073,19 @@ function resolveConfigIdentity(configPath) {
   const stateDir = basename2(cfgDir) === "configs" ? dirname2(cfgDir) : cfgDir;
   return { stateDir, configName: cfgName };
 }
+function engineStateDirOfConfig(configPath, env = process.env) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync3(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw?.stateDir === "string" && raw.stateDir.trim()) return raw.stateDir.trim();
+  const fromEnv = env.ENGINE_STATE_DIR;
+  if (fromEnv && fromEnv.trim()) return fromEnv.trim();
+  if (basename2(dirname2(configPath)) !== "configs") return null;
+  return resolveConfigIdentity(configPath).stateDir;
+}
 function writeSecretsValue(configPath, envKey, value) {
   const { stateDir, configName } = resolveConfigIdentity(configPath);
   const dir = join3(secretsHome(), ".engine7-secrets");
@@ -2191,8 +2204,8 @@ __export(loader_exports, {
   resolveTimezone: () => resolveTimezone,
   takeLoadWarnings: () => takeLoadWarnings
 });
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 function parseModelRef(ref) {
   const idx = ref.indexOf("/");
   if (idx <= 0 || idx === ref.length - 1) {
@@ -2232,13 +2245,13 @@ function isUnresolvedEnvRef(value) {
   return typeof value === "string" && ENV_REF_RE.test(value);
 }
 function loadConfig(configPath) {
-  const resolvedPath = path3.resolve(
+  const resolvedPath = path4.resolve(
     configPath || process.env.ENGINE_CONFIG || "engine-config.json"
   );
-  if (!fs3.existsSync(resolvedPath)) {
+  if (!fs4.existsSync(resolvedPath)) {
     throw new Error(`Config file not found: ${resolvedPath}`);
   }
-  const raw = JSON.parse(fs3.readFileSync(resolvedPath, "utf-8"));
+  const raw = JSON.parse(fs4.readFileSync(resolvedPath, "utf-8"));
   const missingEnvKeys = /* @__PURE__ */ new Set();
   const resolveEnv = (node) => {
     if (typeof node === "string") {
@@ -2341,9 +2354,9 @@ function loadConfig(configPath) {
       }
     }
   }
-  const stateDir = raw.stateDir || process.env.ENGINE_STATE_DIR || path3.resolve(".engine");
-  const workspace = process.env.ENGINE_WORKSPACE || agentDefaults.workspace || path3.join(stateDir, "workspace");
-  const mediaDir = raw.mediaDir || path3.join(stateDir, "media", "inbound");
+  const stateDir = raw.stateDir || process.env.ENGINE_STATE_DIR || path4.resolve(".engine");
+  const workspace = process.env.ENGINE_WORKSPACE || agentDefaults.workspace || path4.join(stateDir, "workspace");
+  const mediaDir = raw.mediaDir || path4.join(stateDir, "media", "inbound");
   if (!agentDefaults.features) agentDefaults.features = {};
   for (const [k, v] of Object.entries(FEATURE_DEFAULTS)) {
     if (agentDefaults.features[k] === void 0) {
@@ -2615,17 +2628,17 @@ var init_registry2 = __esm({
 });
 
 // src/calendar/db.ts
-import * as path4 from "node:path";
-import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+import * as fs5 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 function getSqlite() {
   if (!_sqlite) _sqlite = createRequire2(import.meta.url)("node:sqlite");
   return _sqlite;
 }
 function openDb(workspace) {
-  const dir = path4.join(workspace, ".calendar");
-  fs4.mkdirSync(dir, { recursive: true });
-  const dbPath = path4.join(dir, "calendar.db");
+  const dir = path5.join(workspace, ".calendar");
+  fs5.mkdirSync(dir, { recursive: true });
+  const dbPath = path5.join(dir, "calendar.db");
   const db2 = new DatabaseSync(dbPath);
   db2.exec("PRAGMA journal_mode=WAL");
   db2.exec(`CREATE TABLE IF NOT EXISTS events (
@@ -2699,14 +2712,14 @@ var init_db = __esm({
 });
 
 // src/goals/store.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import crypto from "node:crypto";
 function file(stateDir) {
-  return path5.join(stateDir, "goals.json");
+  return path6.join(stateDir, "goals.json");
 }
 function eventFile(stateDir) {
-  return path5.join(stateDir, "goal-events.jsonl");
+  return path6.join(stateDir, "goal-events.jsonl");
 }
 function db(stateDir) {
   const d = openDb(stateDir);
@@ -2723,17 +2736,17 @@ function db(stateDir) {
   return d;
 }
 function event(stateDir, goalId, type2, payload = {}) {
-  fs5.mkdirSync(stateDir, { recursive: true });
+  fs6.mkdirSync(stateDir, { recursive: true });
   const id = `ge-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`;
   const at = (/* @__PURE__ */ new Date()).toISOString();
-  fs5.appendFileSync(eventFile(stateDir), JSON.stringify({ eventId: id, goalId, type: type2, at, ...payload }) + "\n", "utf8");
+  fs6.appendFileSync(eventFile(stateDir), JSON.stringify({ eventId: id, goalId, type: type2, at, ...payload }) + "\n", "utf8");
   const d = db(stateDir);
   d.prepare("INSERT INTO goal_events (event_id, goal_id, type, payload_json, created_at) VALUES (?, ?, ?, ?, ?)").run(id, goalId, type2, JSON.stringify(payload), at);
   d.close?.();
 }
 function read(stateDir) {
   try {
-    const v = JSON.parse(fs5.readFileSync(file(stateDir), "utf8"));
+    const v = JSON.parse(fs6.readFileSync(file(stateDir), "utf8"));
     return Array.isArray(v) ? v : [];
   } catch {
     return [];
@@ -2756,7 +2769,7 @@ function listGoals(stateDir) {
 }
 function listGoalEvents(stateDir) {
   try {
-    return fs5.readFileSync(eventFile(stateDir), "utf8").split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+    return fs6.readFileSync(eventFile(stateDir), "utf8").split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
   } catch {
     return [];
   }
@@ -2826,9 +2839,9 @@ function isAutoMemPath(absolutePath, workspace) {
   return normalizedPath.startsWith(getAutoMemPath(workspace));
 }
 async function ensureMemoryDirExists(memoryDir) {
-  const fs43 = await import("node:fs");
+  const fs44 = await import("node:fs");
   try {
-    await fs43.promises.mkdir(memoryDir, { recursive: true });
+    await fs44.promises.mkdir(memoryDir, { recursive: true });
   } catch (e) {
     const code = e?.code;
     if (code !== "EEXIST") {
@@ -3159,13 +3172,13 @@ __export(prompt_exports, {
   buildSystemPrompt: () => buildSystemPrompt,
   buildVolatileRuntimeContext: () => buildVolatileRuntimeContext
 });
-import * as path6 from "node:path";
-import * as fs6 from "node:fs";
+import * as path7 from "node:path";
+import * as fs7 from "node:fs";
 import * as os2 from "node:os";
 function readFileIfExists(filePath) {
   try {
-    if (fs6.existsSync(filePath)) {
-      return fs6.readFileSync(filePath, "utf-8");
+    if (fs7.existsSync(filePath)) {
+      return fs7.readFileSync(filePath, "utf-8");
     }
   } catch {
   }
@@ -3324,7 +3337,7 @@ function loadStaticFiles(workspace, staticFiles) {
   if (!staticFiles || staticFiles.length === 0) return null;
   const parts = [];
   for (const file2 of staticFiles) {
-    const filePath = path6.isAbsolute(file2) ? file2 : path6.join(workspace, file2);
+    const filePath = path7.isAbsolute(file2) ? file2 : path7.join(workspace, file2);
     const content = readFileIfExists(filePath);
     if (content) parts.push(content);
   }
@@ -3343,7 +3356,7 @@ function loadMemoryInstructions(workspace) {
   }
 }
 function resolveBlockContent(block, ctx) {
-  const overridePath = path6.join(ctx.workspace, "prompts", `${block.name}.md`);
+  const overridePath = path7.join(ctx.workspace, "prompts", `${block.name}.md`);
   const override = readFileIfExists(overridePath);
   if (override) return override;
   return block.generate(ctx);
@@ -3392,7 +3405,7 @@ function buildCustomPrompt(workspace, config) {
       continue;
     }
     if (name.endsWith(".md")) {
-      const filePath = path6.isAbsolute(name) ? name : path6.join(workspace, name);
+      const filePath = path7.isAbsolute(name) ? name : path7.join(workspace, name);
       const content = readFileIfExists(filePath);
       if (content) {
         parts.push(content);
@@ -3508,7 +3521,7 @@ var init_prompt = __esm({
       { name: "tone-style", description: "\u8BED\u6C14\u98CE\u683C\uFF08\u7B80\u6D01\u3001\u4E0D\u7528emoji\uFF09", generate: (_) => getToneAndStyleSection() },
       { name: "output-efficiency", description: "\u8F93\u51FA\u6548\u7387\uFF08\u76F4\u5954\u4E3B\u9898\uFF09", generate: (_) => getOutputEfficiencySection() },
       // OpenClaw 叠加层
-      { name: "soul", description: "SOUL.md \u4EBA\u683C\u8EAB\u4EFD", generate: (ctx) => readFileIfExists(path6.join(ctx.workspace, "SOUL.md")) },
+      { name: "soul", description: "SOUL.md \u4EBA\u683C\u8EAB\u4EFD", generate: (ctx) => readFileIfExists(path7.join(ctx.workspace, "SOUL.md")) },
       { name: "static-files", description: "\u914D\u7F6E\u6587\u4EF6\u6307\u5B9A\u7684\u989D\u5916\u6587\u4EF6\uFF08AGENTS/USER/MEMORY\u7B49\uFF09", generate: (ctx) => loadStaticFiles(ctx.workspace, ctx.staticFiles) },
       { name: "auto-memory-instructions", description: "auto memory \u5B8C\u6574\u6307\u4EE4\uFF08\u5B58+\u8BFB+recall\u8BF4\u660E\uFF09", generate: (ctx) => loadMemoryInstructions(ctx.workspace) },
       // Boundary（永远在最后）
@@ -6462,8 +6475,8 @@ var init_attachments = __esm({
 });
 
 // src/utils/context-dump.ts
-import * as fs7 from "node:fs";
-import * as path7 from "node:path";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
 function dumpApiRequest(opts) {
   const lines = [
     "=== API Request Debug\uFF08\u53D1\u7ED9 LLM \u7684\u6700\u7EC8\u8BF7\u6C42\u4F53\uFF0C\u6BCF\u6B21\u8986\u76D6\u5199\uFF09===",
@@ -6496,7 +6509,7 @@ function dumpApiRequest(opts) {
       lines.push(`[${i}] ${m.role}: (empty)`);
     }
   }
-  fs7.writeFileSync(path7.join(opts.workspace, ".context-debug.txt"), lines.join("\n") + "\n", "utf-8");
+  fs8.writeFileSync(path8.join(opts.workspace, ".context-debug.txt"), lines.join("\n") + "\n", "utf-8");
 }
 var init_context_dump = __esm({
   "src/utils/context-dump.ts"() {
@@ -7556,7 +7569,7 @@ var init_contextOverflow = __esm({
 });
 
 // src/utils/path.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 function fixMsysPath(p) {
   let fixed = p.includes("\\") ? p.replace(/\\/g, "/") : p;
   if (process.platform === "win32") {
@@ -7566,15 +7579,15 @@ function fixMsysPath(p) {
 }
 function resolvePath(p, workspace) {
   const fixed = fixMsysPath(p);
-  const resolved = path8.isAbsolute(fixed) ? path8.normalize(fixed) : path8.resolve(workspace, fixed);
-  const normalized = path8.normalize(resolved);
-  const normalizedWorkspace = path8.normalize(workspace);
+  const resolved = path9.isAbsolute(fixed) ? path9.normalize(fixed) : path9.resolve(workspace, fixed);
+  const normalized = path9.normalize(resolved);
+  const normalizedWorkspace = path9.normalize(workspace);
   if (sandboxOff) return normalized;
-  if (normalized === normalizedWorkspace || normalized.startsWith(normalizedWorkspace + path8.sep)) {
+  if (normalized === normalizedWorkspace || normalized.startsWith(normalizedWorkspace + path9.sep)) {
     return normalized;
   }
   for (const allowed of extraAllowedPaths) {
-    if (normalized === allowed || normalized.startsWith(allowed + path8.sep)) {
+    if (normalized === allowed || normalized.startsWith(allowed + path9.sep)) {
       return normalized;
     }
   }
@@ -7809,9 +7822,9 @@ __export(BashTool_exports, {
   findShell: () => findShell,
   killChild: () => killChild
 });
-import { spawn as spawn2, execSync } from "node:child_process";
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
+import { spawn as spawn2, execSync as execSync2 } from "node:child_process";
+import * as fs9 from "node:fs";
+import * as path10 from "node:path";
 function isWslBash(p) {
   const normalized = p.replace(/\//g, "\\").toLowerCase();
   return WSL_PATH_MARKERS.some((m) => normalized.includes(m.toLowerCase()));
@@ -7823,14 +7836,14 @@ function findShell() {
     return cachedShell;
   }
   try {
-    const result = execSync("where.exe bash", {
+    const result = execSync2("where.exe bash", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["ignore", "pipe", "ignore"]
     });
     const candidates = result.trim().split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
     const nonWsl = candidates.find((p) => !isWslBash(p));
-    if (nonWsl && fs8.existsSync(nonWsl)) {
+    if (nonWsl && fs9.existsSync(nonWsl)) {
       cachedShell = { shell: nonWsl, args: ["-c"] };
       return cachedShell;
     }
@@ -7840,10 +7853,10 @@ function findShell() {
     "C:\\Program Files\\Git\\bin\\bash.exe",
     "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
     "C:\\Program Files\\Git\\usr\\bin\\bash.exe",
-    path9.join(process.env.LOCALAPPDATA || "", "Programs", "Git", "bin", "bash.exe")
+    path10.join(process.env.LOCALAPPDATA || "", "Programs", "Git", "bin", "bash.exe")
   ];
   for (const p of knownPaths) {
-    if (p && fs8.existsSync(p)) {
+    if (p && fs9.existsSync(p)) {
       cachedShell = { shell: p, args: ["-c"] };
       return cachedShell;
     }
@@ -7946,8 +7959,8 @@ For commands that are harder to parse at a glance (piped commands, obscure flags
         }
         const MAX_OUTPUT = 100 * 1024;
         const osMod = await import("node:os");
-        const outputFile = path9.join(osMod.tmpdir(), `exec-${Date.now()}-${Math.random().toString(36).slice(2)}.out`);
-        const outputHandle = await fs8.promises.open(outputFile, "w");
+        const outputFile = path10.join(osMod.tmpdir(), `exec-${Date.now()}-${Math.random().toString(36).slice(2)}.out`);
+        const outputHandle = await fs9.promises.open(outputFile, "w");
         return new Promise((resolve12) => {
           const { shell, args: shellArgs } = findShell();
           const child = spawn2(shell, [...shellArgs, command], {
@@ -7966,21 +7979,21 @@ For commands that are harder to parse at a glance (piped commands, obscure flags
             let fileOutput = "";
             let truncated = false;
             try {
-              const st = await fs8.promises.stat(outputFile);
+              const st = await fs9.promises.stat(outputFile);
               if (st.size > MAX_OUTPUT) {
-                const rfd = await fs8.promises.open(outputFile, "r");
+                const rfd = await fs9.promises.open(outputFile, "r");
                 const buf = Buffer.alloc(MAX_OUTPUT);
                 await rfd.read(buf, 0, MAX_OUTPUT, 0);
                 await rfd.close();
                 fileOutput = buf.toString("utf-8");
                 truncated = true;
               } else {
-                fileOutput = await fs8.promises.readFile(outputFile, "utf-8");
+                fileOutput = await fs9.promises.readFile(outputFile, "utf-8");
               }
             } catch {
             }
             try {
-              await fs8.promises.unlink(outputFile);
+              await fs9.promises.unlink(outputFile);
             } catch {
             }
             const processedStdout = fileOutput.replace(/^(\s*\n)+/, "").trimEnd();
@@ -8057,8 +8070,8 @@ __export(task_manager_exports, {
 });
 import { randomBytes } from "node:crypto";
 import { spawn as spawn3 } from "node:child_process";
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
+import * as fs10 from "node:fs";
+import * as path11 from "node:path";
 function generateTaskId(type2 = "local_bash") {
   const prefix = TASK_ID_PREFIXES[type2] ?? "x";
   const bytes = randomBytes(8);
@@ -8071,42 +8084,42 @@ function generateTaskId(type2 = "local_bash") {
 function getTaskOutputDir() {
   if (_taskOutputDir === void 0) {
     const stateDir = process.env.ENGINE_STATE_DIR || process.cwd();
-    _taskOutputDir = path10.join(stateDir, "tasks");
+    _taskOutputDir = path11.join(stateDir, "tasks");
   }
   return _taskOutputDir;
 }
 function getTaskOutputPath(taskId) {
-  return path10.join(getTaskOutputDir(), `${taskId}.output`);
+  return path11.join(getTaskOutputDir(), `${taskId}.output`);
 }
 function ensureOutputDir() {
   const dir = getTaskOutputDir();
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, { recursive: true });
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
 }
 function initTaskOutput(taskId) {
   ensureOutputDir();
   const outputPath = getTaskOutputPath(taskId);
-  fs9.writeFileSync(outputPath, "", "utf-8");
+  fs10.writeFileSync(outputPath, "", "utf-8");
   return outputPath;
 }
 function persistTask(state2) {
   try {
     ensureOutputDir();
     const p = taskIndexPath();
-    const existing = fs9.existsSync(p) ? JSON.parse(fs9.readFileSync(p, "utf8")) : [];
+    const existing = fs10.existsSync(p) ? JSON.parse(fs10.readFileSync(p, "utf8")) : [];
     const next = existing.filter((t) => t.id !== state2.id);
     next.push({ ...state2 });
     const tmp = `${p}.${process.pid}.tmp`;
-    fs9.writeFileSync(tmp, JSON.stringify(next, null, 2));
-    fs9.renameSync(tmp, p);
+    fs10.writeFileSync(tmp, JSON.stringify(next, null, 2));
+    fs10.renameSync(tmp, p);
   } catch (err) {
     console.warn(`[task-manager] persist failed: ${err.message}`);
   }
 }
 function loadPersistedTasks() {
   try {
-    const v = JSON.parse(fs9.readFileSync(taskIndexPath(), "utf8"));
+    const v = JSON.parse(fs10.readFileSync(taskIndexPath(), "utf8"));
     return Array.isArray(v) ? v : [];
   } catch {
     return [];
@@ -8116,7 +8129,7 @@ function loadNotificationQueue() {
   if (notificationsLoaded) return;
   notificationsLoaded = true;
   try {
-    const value = JSON.parse(fs9.readFileSync(notificationQueuePath(), "utf8"));
+    const value = JSON.parse(fs10.readFileSync(notificationQueuePath(), "utf8"));
     if (Array.isArray(value)) pendingNotifications.push(...value.filter((x) => x && typeof x.notification === "string"));
   } catch {
   }
@@ -8126,8 +8139,8 @@ function persistNotificationQueue() {
     ensureOutputDir();
     const p = notificationQueuePath();
     const tmp = `${p}.${process.pid}.tmp`;
-    fs9.writeFileSync(tmp, JSON.stringify(pendingNotifications, null, 2), "utf8");
-    fs9.renameSync(tmp, p);
+    fs10.writeFileSync(tmp, JSON.stringify(pendingNotifications, null, 2), "utf8");
+    fs10.renameSync(tmp, p);
   } catch (err) {
     console.warn(`[task-manager] notification persist failed: ${err.message}`);
   }
@@ -8264,14 +8277,14 @@ function spawnBackgroundTask(opts) {
   const taskId = generateTaskId("local_bash");
   const outputPath = initTaskOutput(taskId);
   const { shell, args: shellArgs } = findShell();
-  const outputFd = fs9.openSync(outputPath, "w");
+  const outputFd = fs10.openSync(outputPath, "w");
   const child = spawn3(shell, [...shellArgs, opts.command], {
     cwd: opts.cwd,
     env: opts.env || process.env,
     stdio: ["ignore", outputFd, outputFd]
   });
   try {
-    fs9.closeSync(outputFd);
+    fs10.closeSync(outputFd);
   } catch {
   }
   processes.set(taskId, child);
@@ -8303,12 +8316,12 @@ function spawnBackgroundTask(opts) {
   let killedForSize = false;
   sizeWatchdog = setInterval(() => {
     if (tasks.get(taskId)?.status !== "running") return;
-    fs9.stat(outputPath, (err, st) => {
+    fs10.stat(outputPath, (err, st) => {
       if (err || st.size <= MAX_TASK_OUTPUT_BYTES) return;
       killedForSize = true;
       if (sizeWatchdog) clearInterval(sizeWatchdog);
       try {
-        fs9.appendFileSync(outputPath, "\n[output truncated: exceeded 5GB disk cap]\n");
+        fs10.appendFileSync(outputPath, "\n[output truncated: exceeded 5GB disk cap]\n");
       } catch {
       }
       killChild(child);
@@ -8438,16 +8451,16 @@ function getTaskOutput(taskId, maxBytes = 8 * 1024 * 1024) {
   if (!state2) return "";
   try {
     const outputPath = state2.outputFile;
-    if (!fs9.existsSync(outputPath)) return "";
-    const stat4 = fs9.statSync(outputPath);
+    if (!fs10.existsSync(outputPath)) return "";
+    const stat4 = fs10.statSync(outputPath);
     if (stat4.size <= maxBytes) {
-      return fs9.readFileSync(outputPath, "utf-8");
+      return fs10.readFileSync(outputPath, "utf-8");
     }
-    const fd = fs9.openSync(outputPath, "r");
+    const fd = fs10.openSync(outputPath, "r");
     const start = stat4.size - maxBytes;
     const buf = Buffer.alloc(maxBytes);
-    fs9.readSync(fd, buf, 0, maxBytes, start);
-    fs9.closeSync(fd);
+    fs10.readSync(fd, buf, 0, maxBytes, start);
+    fs10.closeSync(fd);
     const content = buf.toString("utf-8");
     const omitted = Math.round((stat4.size - maxBytes) / 1024);
     return `[${omitted}KB of earlier output omitted]
@@ -8461,14 +8474,14 @@ function getTaskOutputDelta(taskId, fromOffset, maxBytes = 8 * 1024 * 1024) {
   if (!state2) return { content: "", newOffset: fromOffset };
   try {
     const outputPath = state2.outputFile;
-    if (!fs9.existsSync(outputPath)) return { content: "", newOffset: fromOffset };
-    const stat4 = fs9.statSync(outputPath);
+    if (!fs10.existsSync(outputPath)) return { content: "", newOffset: fromOffset };
+    const stat4 = fs10.statSync(outputPath);
     if (fromOffset >= stat4.size) return { content: "", newOffset: stat4.size };
     const readLen = Math.min(maxBytes, stat4.size - fromOffset);
     const buf = Buffer.alloc(readLen);
-    const fd = fs9.openSync(outputPath, "r");
-    fs9.readSync(fd, buf, 0, readLen, fromOffset);
-    fs9.closeSync(fd);
+    const fd = fs10.openSync(outputPath, "r");
+    fs10.readSync(fd, buf, 0, readLen, fromOffset);
+    fs10.closeSync(fd);
     return { content: buf.toString("utf-8"), newOffset: fromOffset + readLen };
   } catch {
     return { content: "", newOffset: fromOffset };
@@ -8478,8 +8491,8 @@ function getTaskOutputSize(taskId) {
   const state2 = tasks.get(taskId);
   if (!state2) return 0;
   try {
-    if (!fs9.existsSync(state2.outputFile)) return 0;
-    return fs9.statSync(state2.outputFile).size;
+    if (!fs10.existsSync(state2.outputFile)) return 0;
+    return fs10.statSync(state2.outputFile).size;
   } catch {
     return 0;
   }
@@ -8517,10 +8530,10 @@ var init_task_manager = __esm({
     MAX_TASK_OUTPUT_BYTES = 5 * 1024 * 1024 * 1024;
     tasks = /* @__PURE__ */ new Map();
     processes = /* @__PURE__ */ new Map();
-    taskIndexPath = () => path10.join(process.env.ENGINE_STATE_DIR || process.cwd(), "tasks", "index.json");
+    taskIndexPath = () => path11.join(process.env.ENGINE_STATE_DIR || process.cwd(), "tasks", "index.json");
     pendingNotifications = [];
     notificationsLoaded = false;
-    notificationQueuePath = () => path10.join(process.env.ENGINE_STATE_DIR || process.cwd(), "tasks", "notifications.json");
+    notificationQueuePath = () => path11.join(process.env.ENGINE_STATE_DIR || process.cwd(), "tasks", "notifications.json");
     notificationCallback = null;
     DEAD_LETTER_MAX_ATTEMPTS = 10;
     RETRY_BASE_MS = 1e3;
@@ -8662,8 +8675,8 @@ __export(context_analyzer_exports, {
   formatContextReport: () => formatContextReport,
   scanMemoryFiles: () => scanMemoryFiles
 });
-import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as fs11 from "node:fs";
+import * as path12 from "node:path";
 function estimateMessageTokens2(m) {
   let tokens = 0;
   if (typeof m.content === "string") {
@@ -8773,9 +8786,9 @@ function breakdownMessages(messages) {
 }
 async function scanMemoryFiles(workspace) {
   const files = [];
-  const soul = readFileIfExists2(path11.join(workspace, "SOUL.md"));
+  const soul = readFileIfExists2(path12.join(workspace, "SOUL.md"));
   if (soul) files.push({ path: "SOUL.md", tokens: roughTokenCountEstimation(soul), stable: true });
-  const agents = readFileIfExists2(path11.join(workspace, "AGENTS.md"));
+  const agents = readFileIfExists2(path12.join(workspace, "AGENTS.md"));
   if (agents) files.push({ path: "AGENTS.md", tokens: roughTokenCountEstimation(agents), stable: true });
   try {
     const { buildMemoryPrompt: buildMemoryPrompt2 } = await Promise.resolve().then(() => (init_memdir(), memdir_exports));
@@ -8791,7 +8804,7 @@ async function scanMemoryFiles(workspace) {
 }
 function readFileIfExists2(filePath) {
   try {
-    if (fs10.existsSync(filePath)) return fs10.readFileSync(filePath, "utf-8");
+    if (fs11.existsSync(filePath)) return fs11.readFileSync(filePath, "utf-8");
   } catch {
   }
   return null;
@@ -9770,8 +9783,8 @@ ${perTurnSystemDynamic}` : deferredHint || perTurnSystemDynamic;
 });
 
 // src/session/writer.ts
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
 import * as crypto2 from "node:crypto";
 function assistantWriteParamsFrom(m) {
   const anyM = m;
@@ -9807,7 +9820,7 @@ var init_writer = __esm({
         this.sessionId = sessionId || crypto2.randomUUID();
         this.engineSessionId = "";
         const filename = `${this.sessionId}.jsonl`;
-        this.filePath = path12.join(sessionsDir, filename);
+        this.filePath = path13.join(sessionsDir, filename);
       }
       get id() {
         return this.sessionId;
@@ -9818,9 +9831,9 @@ var init_writer = __esm({
       /** 打开文件写入 header（新文件才写 header） */
       open(cwd, engineSessionId) {
         this.engineSessionId = engineSessionId || "";
-        fs11.mkdirSync(path12.dirname(this.filePath), { recursive: true });
-        const fileExists = fs11.existsSync(this.filePath) && fs11.statSync(this.filePath).size > 0;
-        this.stream = fs11.createWriteStream(this.filePath, { flags: "a" });
+        fs12.mkdirSync(path13.dirname(this.filePath), { recursive: true });
+        const fileExists = fs12.existsSync(this.filePath) && fs12.statSync(this.filePath).size > 0;
+        this.stream = fs12.createWriteStream(this.filePath, { flags: "a" });
         this.stream.on("error", (err) => {
           console.error(`[SessionWriter] write error on ${this.filePath}:`, err.message);
         });
@@ -10023,17 +10036,17 @@ var init_writer = __esm({
           this.stream.end();
           this.stream = null;
         }
-        if (!fs11.existsSync(this.filePath)) return null;
-        const fileSize = fs11.statSync(this.filePath).size;
+        if (!fs12.existsSync(this.filePath)) return null;
+        const fileSize = fs12.statSync(this.filePath).size;
         if (fileSize === 0) return null;
         const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
         const archivedPath = `${this.filePath}.${reason}.${ts}`;
-        fs11.renameSync(this.filePath, archivedPath);
+        fs12.renameSync(this.filePath, archivedPath);
         const sizeMB = (fileSize / 1024 / 1024).toFixed(1);
-        console.log(`[SessionWriter] Archived JSONL: ${path12.basename(this.filePath)} \u2192 ${path12.basename(archivedPath)} (${sizeMB}MB)`);
+        console.log(`[SessionWriter] Archived JSONL: ${path13.basename(this.filePath)} \u2192 ${path13.basename(archivedPath)} (${sizeMB}MB)`);
         const postBoundaryData = this.readPostBoundaryFromArchived(archivedPath);
-        const dir = path12.dirname(this.filePath);
-        fs11.mkdirSync(dir, { recursive: true });
+        const dir = path13.dirname(this.filePath);
+        fs12.mkdirSync(dir, { recursive: true });
         const header = {
           type: "session",
           version: 3,
@@ -10047,8 +10060,8 @@ var init_writer = __esm({
         if (postBoundaryData.length > 0) {
           initialData += postBoundaryData.toString("utf-8");
         }
-        fs11.writeFileSync(this.filePath, initialData, "utf-8");
-        this.stream = fs11.createWriteStream(this.filePath, { flags: "a" });
+        fs12.writeFileSync(this.filePath, initialData, "utf-8");
+        this.stream = fs12.createWriteStream(this.filePath, { flags: "a" });
         this.stream.on("error", (err) => {
           console.error(`[SessionWriter] write error on ${this.filePath}:`, err.message);
         });
@@ -10058,10 +10071,10 @@ var init_writer = __esm({
        * 从归档文件中读取最后一个 compact_boundary 之后的内容
        */
       readPostBoundaryFromArchived(archivedPath) {
-        const fileSize = fs11.statSync(archivedPath).size;
+        const fileSize = fs12.statSync(archivedPath).size;
         if (fileSize === 0) return Buffer.alloc(0);
         if (fileSize <= 5 * 1024 * 1024) {
-          const content = fs11.readFileSync(archivedPath, "utf-8");
+          const content = fs12.readFileSync(archivedPath, "utf-8");
           const lines = content.split("\n");
           let lastBoundaryIdx = -1;
           for (let i = lines.length - 1; i >= 0; i--) {
@@ -10078,11 +10091,11 @@ var init_writer = __esm({
         {
           const probeSize = Math.min(fileSize, 1024 * 1024);
           const probeBuf = Buffer.allocUnsafe(probeSize);
-          const probeFd = fs11.openSync(archivedPath, "r");
+          const probeFd = fs12.openSync(archivedPath, "r");
           let hasBoundary = false;
           let probed = 0;
           while (probed < fileSize) {
-            const n = fs11.readSync(probeFd, probeBuf, 0, Math.min(probeSize, fileSize - probed), probed);
+            const n = fs12.readSync(probeFd, probeBuf, 0, Math.min(probeSize, fileSize - probed), probed);
             if (n === 0) break;
             if (probeBuf.subarray(0, n).includes(Buffer.from(boundaryMarker))) {
               hasBoundary = true;
@@ -10090,19 +10103,19 @@ var init_writer = __esm({
             }
             probed += n;
           }
-          fs11.closeSync(probeFd);
+          fs12.closeSync(probeFd);
           if (!hasBoundary) return Buffer.alloc(0);
         }
         const outBuf = Buffer.allocUnsafe(Math.min(fileSize, 8 * 1024 * 1024));
         let outLen = 0;
         const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
-        const fd = fs11.openSync(archivedPath, "r");
+        const fd = fs12.openSync(archivedPath, "r");
         try {
           let filePos = 0;
           let carryBuf;
           let carryLen = 0;
           while (filePos < fileSize) {
-            const bytesRead = fs11.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
+            const bytesRead = fs12.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
             if (bytesRead === 0) break;
             filePos += bytesRead;
             let scanBuf;
@@ -10151,7 +10164,7 @@ var init_writer = __esm({
             }
           }
         } finally {
-          fs11.closeSync(fd);
+          fs12.closeSync(fd);
         }
         return outBuf.subarray(0, outLen);
       }
@@ -10163,15 +10176,15 @@ var init_writer = __esm({
        */
       readLastId() {
         try {
-          const stat4 = fs11.statSync(this.filePath);
+          const stat4 = fs12.statSync(this.filePath);
           if (stat4.size === 0) return null;
           const readSize = Math.min(stat4.size, 4096);
           const buf = Buffer.alloc(readSize);
-          const fd = fs11.openSync(this.filePath, "r");
+          const fd = fs12.openSync(this.filePath, "r");
           try {
-            fs11.readSync(fd, buf, 0, readSize, stat4.size - readSize);
+            fs12.readSync(fd, buf, 0, readSize, stat4.size - readSize);
           } finally {
-            fs11.closeSync(fd);
+            fs12.closeSync(fd);
           }
           const text = buf.toString("utf-8");
           const lines = text.split("\n").filter((l) => l.trim().length > 0);
@@ -10218,11 +10231,11 @@ var init_writer = __esm({
 });
 
 // src/session/reader.ts
-import * as fs12 from "node:fs";
-import * as path13 from "node:path";
+import * as fs13 from "node:fs";
+import * as path14 from "node:path";
 import * as readline from "node:readline";
 async function readSessionHeader(filePath) {
-  const stream = fs12.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs13.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream });
   return new Promise((resolve12) => {
     let resolved = false;
@@ -10253,7 +10266,7 @@ async function readSessionHeader(filePath) {
   });
 }
 async function readLargeFilePostBoundary(filePath) {
-  const stat4 = fs12.statSync(filePath);
+  const stat4 = fs13.statSync(filePath);
   const fileSize = stat4.size;
   const boundaryMarker = '"compact_boundary"';
   const CHUNK_SIZE = TRANSCRIPT_READ_CHUNK_SIZE;
@@ -10261,13 +10274,13 @@ async function readLargeFilePostBoundary(filePath) {
   let outLen = 0;
   let boundaryStartOffset = 0;
   const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
-  const fd = fs12.openSync(filePath, "r");
+  const fd = fs13.openSync(filePath, "r");
   try {
     let filePos = 0;
     let carryBuf;
     let carryLen = 0;
     while (filePos < fileSize) {
-      const bytesRead = fs12.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
+      const bytesRead = fs13.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
       if (bytesRead === 0) break;
       filePos += bytesRead;
       let scanBuf;
@@ -10319,7 +10332,7 @@ async function readLargeFilePostBoundary(filePath) {
       }
     }
   } finally {
-    fs12.closeSync(fd);
+    fs13.closeSync(fd);
   }
   const postBoundaryText = outBuf.subarray(0, outLen).toString("utf-8");
   return postBoundaryText.split("\n").filter((l) => l.trim().length > 0);
@@ -10443,7 +10456,7 @@ function recoverOrphanedParallelToolResults(allEntries, chain, byUuid, seen) {
   return result;
 }
 async function readSessionHistory(filePath) {
-  const stat4 = fs12.statSync(filePath);
+  const stat4 = fs13.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`);
@@ -10482,7 +10495,7 @@ async function readSessionHistory(filePath) {
   return [...sessionStarts, ...filtered, ...restAttachments];
 }
 async function readAllLines(filePath) {
-  const stream = fs12.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs13.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream });
   const lines = [];
   return new Promise((resolve12, reject) => {
@@ -10636,12 +10649,12 @@ function extractText(content) {
   return content.filter((b) => b.type === "text").map((b) => b.text || "").join("") || null;
 }
 function listSessions(sessionsDir) {
-  if (!fs12.existsSync(sessionsDir)) return [];
-  const files = fs12.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") || f.includes(".jsonl.")).map((f) => ({
-    file: path13.join(sessionsDir, f),
+  if (!fs13.existsSync(sessionsDir)) return [];
+  const files = fs13.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") || f.includes(".jsonl.")).map((f) => ({
+    file: path14.join(sessionsDir, f),
     id: f.replace(/\.jsonl.*$/, ""),
     // strip .jsonl and everything after (archived suffix)
-    modified: new Date(fs12.statSync(path13.join(sessionsDir, f)).mtimeMs)
+    modified: new Date(fs13.statSync(path14.join(sessionsDir, f)).mtimeMs)
   })).sort((a, b) => b.modified.getTime() - a.modified.getTime());
   return files;
 }
@@ -10662,8 +10675,8 @@ __export(session_manager_exports, {
   SessionManager: () => SessionManager,
   alignRestoreHeadToTurnBoundary: () => alignRestoreHeadToTurnBoundary
 });
-import * as path14 from "node:path";
-import * as fs13 from "node:fs";
+import * as path15 from "node:path";
+import * as fs14 from "node:fs";
 import * as crypto3 from "node:crypto";
 function alignRestoreHeadToTurnBoundary(messages, minKeep = RESTORE_MIN_KEEP_MESSAGES) {
   const isTurnBoundary = (m) => isAttachmentMessage(m) ? true : m.role === "user";
@@ -10702,24 +10715,24 @@ var init_session_manager = __esm({
       constructor(config) {
         this.config = config;
         this.scopeConfig = config.scopeConfig;
-        this.sessionsDir = path14.join(config.stateDir, "agents", "main", "sessions");
-        this.indexPath = path14.join(this.sessionsDir, "session-index.json");
-        this.platformMapPath = path14.join(this.sessionsDir, "platform-map.json");
-        fs13.mkdirSync(this.sessionsDir, { recursive: true });
+        this.sessionsDir = path15.join(config.stateDir, "agents", "main", "sessions");
+        this.indexPath = path15.join(this.sessionsDir, "session-index.json");
+        this.platformMapPath = path15.join(this.sessionsDir, "platform-map.json");
+        fs14.mkdirSync(this.sessionsDir, { recursive: true });
       }
       // === 索引操作 ===
       loadIndex() {
         try {
-          if (fs13.existsSync(this.indexPath)) {
-            const raw = fs13.readFileSync(this.indexPath, "utf-8");
+          if (fs14.existsSync(this.indexPath)) {
+            const raw = fs14.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 (fs13.existsSync(entry.file)) continue;
-              const basename10 = path14.basename(entry.file);
-              const localPath = path14.join(this.sessionsDir, basename10);
-              if (fs13.existsSync(localPath)) {
+              if (fs14.existsSync(entry.file)) continue;
+              const basename10 = path15.basename(entry.file);
+              const localPath = path15.join(this.sessionsDir, basename10);
+              if (fs14.existsSync(localPath)) {
                 entry.file = localPath;
                 fixed++;
               }
@@ -10738,7 +10751,7 @@ var init_session_manager = __esm({
         try {
           const obj = {};
           for (const [k, v] of this.index) obj[k] = v;
-          fs13.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
+          fs14.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
         } catch (err) {
           console.error(`[session] Failed to save index: ${err.message}`);
         }
@@ -10746,8 +10759,8 @@ var init_session_manager = __esm({
       // === 平台映射 ===
       loadPlatformMap() {
         try {
-          if (fs13.existsSync(this.platformMapPath)) {
-            const raw = fs13.readFileSync(this.platformMapPath, "utf-8");
+          if (fs14.existsSync(this.platformMapPath)) {
+            const raw = fs14.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`);
@@ -10759,7 +10772,7 @@ var init_session_manager = __esm({
         try {
           const obj = {};
           for (const [k, v] of this.platformMap) obj[k] = v;
-          fs13.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
+          fs14.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
         } catch (err) {
           console.error(`[session] Failed to save platform map: ${err.message}`);
         }
@@ -10798,17 +10811,17 @@ var init_session_manager = __esm({
        */
       getSessionFilePath(sessionId) {
         const entry = this.index.get(sessionId);
-        if (entry && fs13.existsSync(entry.file)) return entry.file;
-        const direct = path14.join(this.sessionsDir, `${sessionId}.jsonl`);
-        return fs13.existsSync(direct) ? direct : null;
+        if (entry && fs14.existsSync(entry.file)) return entry.file;
+        const direct = path15.join(this.sessionsDir, `${sessionId}.jsonl`);
+        return fs14.existsSync(direct) ? direct : null;
       }
       // === Writer 管理 ===
       getWriter(sessionId) {
         let writer = this.writers.get(sessionId);
         if (!writer) {
           const existing = this.index.get(sessionId);
-          if (existing && fs13.existsSync(existing.file)) {
-            const existingFileId = path14.basename(existing.file, ".jsonl");
+          if (existing && fs14.existsSync(existing.file)) {
+            const existingFileId = path15.basename(existing.file, ".jsonl");
             writer = new SessionWriter(this.sessionsDir, existingFileId);
             writer.open(this.config.workspace, sessionId);
           } else {
@@ -10820,7 +10833,7 @@ var init_session_manager = __esm({
           this.saveIndex();
           this.writers.set(sessionId, writer);
           this.onWriterCreated?.(writer, sessionId);
-          console.log(`[session] ${existing ? "Resumed" : "New"}: ${sessionId} \u2192 ${path14.basename(writer.path)}`);
+          console.log(`[session] ${existing ? "Resumed" : "New"}: ${sessionId} \u2192 ${path15.basename(writer.path)}`);
         }
         return writer;
       }
@@ -10839,7 +10852,7 @@ var init_session_manager = __esm({
         if (!writer) return null;
         try {
           this.lastArchiveCheck = Date.now();
-          const stat4 = fs13.statSync(writer.path);
+          const stat4 = fs14.statSync(writer.path);
           if (stat4.size < threshold) return null;
           const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
           const thresholdMB = (threshold / 1024 / 1024).toFixed(1);
@@ -10848,10 +10861,10 @@ var init_session_manager = __esm({
           if (archivedPath) {
             this.index.set(sessionId, { file: writer.path, updatedAt: Date.now() });
             this.saveIndex();
-            const newSize = fs13.statSync(writer.path).size;
+            const newSize = fs14.statSync(writer.path).size;
             const oldSizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-            console.log(`[session] Archive complete: ${path14.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
-            const fileId = path14.basename(writer.path).replace(/\.jsonl$/, "");
+            console.log(`[session] Archive complete: ${path15.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
+            const fileId = path15.basename(writer.path).replace(/\.jsonl$/, "");
             this.purgeOldArchives(fileId, 3);
             return archivedPath;
           }
@@ -10867,15 +10880,15 @@ var init_session_manager = __esm({
       purgeOldArchives(sessionId, keepCount = 3) {
         try {
           const dir = this.sessionsDir;
-          if (!fs13.existsSync(dir)) return;
-          const allFiles = fs13.readdirSync(dir);
+          if (!fs14.existsSync(dir)) return;
+          const allFiles = fs14.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: path14.join(dir, f),
-            mtime: fs13.statSync(path14.join(dir, f)).mtimeMs
+            path: path15.join(dir, f),
+            mtime: fs14.statSync(path15.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;
@@ -10885,7 +10898,7 @@ var init_session_manager = __esm({
               console.log(`[session] Skipping archived (kept for history): ${f.name}`);
               continue;
             }
-            fs13.unlinkSync(f.path);
+            fs14.unlinkSync(f.path);
             console.log(`[session] Purged old archive: ${f.name}`);
           }
           if (toDelete.length > 0) {
@@ -10934,29 +10947,29 @@ var init_session_manager = __esm({
       /** 列出 session 的所有文件（当前 + 归档），按修改时间排序 */
       findAllSessionFiles(sessionId) {
         const results = [];
-        const mainFile = path14.join(this.sessionsDir, `${sessionId}.jsonl`);
-        if (fs13.existsSync(mainFile)) {
+        const mainFile = path15.join(this.sessionsDir, `${sessionId}.jsonl`);
+        if (fs14.existsSync(mainFile)) {
           results.push(mainFile);
         }
-        if (fs13.existsSync(this.sessionsDir)) {
-          const compactionFiles = fs13.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
+        if (fs14.existsSync(this.sessionsDir)) {
+          const compactionFiles = fs14.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
             name: f,
-            path: path14.join(this.sessionsDir, f),
-            mtime: fs13.statSync(path14.join(this.sessionsDir, f)).mtimeMs
+            path: path15.join(this.sessionsDir, f),
+            mtime: fs14.statSync(path15.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 = fs13.statSync(a).mtimeMs;
-          const tb = fs13.statSync(b).mtimeMs;
+          const ta = fs14.statSync(a).mtimeMs;
+          const tb = fs14.statSync(b).mtimeMs;
           return ta - tb;
         });
         return results;
       }
       async findSessionFiles(sessionId) {
-        if (!fs13.existsSync(this.sessionsDir)) {
+        if (!fs14.existsSync(this.sessionsDir)) {
           console.log(`[session:find] SESSIONS_DIR not found: ${this.sessionsDir}`);
           return [];
         }
@@ -10968,15 +10981,15 @@ var init_session_manager = __esm({
             return mappedFiles;
           }
           const indexedEntry = this.index.get(mappedId);
-          if (indexedEntry && fs13.existsSync(indexedEntry.file)) {
-            const fileUuid = path14.basename(indexedEntry.file, ".jsonl");
+          if (indexedEntry && fs14.existsSync(indexedEntry.file)) {
+            const fileUuid = path15.basename(indexedEntry.file, ".jsonl");
             return this.findAllSessionFiles(fileUuid);
           }
         }
         const allFiles = this.findAllSessionFiles(sessionId);
         if (allFiles.length > 0) {
           const labels = allFiles.map((f) => {
-            const base = path14.basename(f);
+            const base = path15.basename(f);
             return base.endsWith(".jsonl") ? base : `${base} (archived)`;
           });
           console.log(`[session:find] Found ${allFiles.length} file(s) for ${sessionId}: ${labels.join(", ")}`);
@@ -10984,9 +10997,9 @@ var init_session_manager = __esm({
         }
         const indexed = this.index.get(sessionId);
         if (indexed) {
-          console.log(`[session:find] Index hit: ${sessionId} \u2192 ${indexed.file} (exists=${fs13.existsSync(indexed.file)})`);
-          if (fs13.existsSync(indexed.file)) {
-            return this.findAllSessionFiles(path14.basename(indexed.file, ".jsonl"));
+          console.log(`[session:find] Index hit: ${sessionId} \u2192 ${indexed.file} (exists=${fs14.existsSync(indexed.file)})`);
+          if (fs14.existsSync(indexed.file)) {
+            return this.findAllSessionFiles(path15.basename(indexed.file, ".jsonl"));
           }
         } else {
           console.log(`[session:find] Index miss: ${sessionId} (index has ${this.index.size} entries)`);
@@ -11015,8 +11028,8 @@ var init_session_manager = __esm({
           return [];
         }
         files.sort((a, b) => {
-          const ta = fs13.statSync(a).mtimeMs;
-          const tb = fs13.statSync(b).mtimeMs;
+          const ta = fs14.statSync(a).mtimeMs;
+          const tb = fs14.statSync(b).mtimeMs;
           return ta - tb;
         });
         const latestFile = files[files.length - 1];
@@ -11024,7 +11037,7 @@ var init_session_manager = __esm({
         if (!currentEntry || currentEntry.file !== latestFile) {
           this.index.set(sessionId, { file: latestFile, updatedAt: Date.now() });
           this.saveIndex();
-          console.log(`[session:restore] Synced index: ${sessionId} \u2192 ${path14.basename(latestFile)}`);
+          console.log(`[session:restore] Synced index: ${sessionId} \u2192 ${path15.basename(latestFile)}`);
         }
         const allMessages = [];
         for (const file2 of files) {
@@ -11063,7 +11076,7 @@ var init_session_manager = __esm({
           if (isAttachmentMessage(m) && m.attachment.type === "relevant_memories") {
             for (const mem of m.attachment.memories) {
               rawCount++;
-              restoredPaths.add(path14.resolve(mem.path));
+              restoredPaths.add(path15.resolve(mem.path));
             }
           }
         }
@@ -11095,15 +11108,15 @@ var init_session_manager = __esm({
        */
       rotateMainSession() {
         const entry = this.index.get("main");
-        if (!entry || !fs13.existsSync(entry.file)) return;
-        const oldFileId = path14.basename(entry.file, ".jsonl");
-        const stat4 = fs13.statSync(entry.file);
+        if (!entry || !fs14.existsSync(entry.file)) return;
+        const oldFileId = path15.basename(entry.file, ".jsonl");
+        const stat4 = fs14.statSync(entry.file);
         if (stat4.size < 1024) return;
         const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
         const archivedPath = `${entry.file}.archived.${ts}`;
-        fs13.renameSync(entry.file, archivedPath);
+        fs14.renameSync(entry.file, archivedPath);
         const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-        console.log(`[session] Archived: ${path14.basename(entry.file)} \u2192 ${path14.basename(archivedPath)} (${sizeMB}MB)`);
+        console.log(`[session] Archived: ${path15.basename(entry.file)} \u2192 ${path15.basename(archivedPath)} (${sizeMB}MB)`);
         const newWriter = new SessionWriter(this.sessionsDir);
         newWriter.open(this.config.workspace, "main");
         newWriter.writeModelChange(this.config.providerId, this.config.model);
@@ -11112,7 +11125,7 @@ var init_session_manager = __esm({
         this.index.set("main", { file: newPath, updatedAt: Date.now() });
         this.saveIndex();
         this.purgeOldArchives(oldFileId, 3);
-        console.log(`[session] Rotated main: ${oldFileId}.jsonl \u2192 ${path14.basename(newPath)}`);
+        console.log(`[session] Rotated main: ${oldFileId}.jsonl \u2192 ${path15.basename(newPath)}`);
       }
       // === 迁移 ===
       /** 迁移旧索引：session-index.json 里有 "discord:xxx" 格式的 key 时，生成 UUID 替换 */
@@ -11177,15 +11190,15 @@ var init_session_manager = __esm({
 });
 
 // src/tools/read.ts
-import * as fs14 from "node:fs";
-import * as path15 from "node:path";
+import * as fs15 from "node:fs";
+import * as path16 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 = fs14.statSync(filePath);
+  const stat4 = fs15.statSync(filePath);
   const mtimeMs = stat4.mtimeMs;
   const prev = readHistory.get(filePath);
   if (prev && prev.offset === offset && prev.limit === limit && prev.mtimeMs === mtimeMs) {
@@ -11199,19 +11212,19 @@ function checkReadLoop(filePath, offset, limit) {
   return null;
 }
 function readFileContent(filePath) {
-  const fd = fs14.openSync(filePath, "r");
+  const fd = fs15.openSync(filePath, "r");
   const bom = Buffer.alloc(2);
-  fs14.readSync(fd, bom, 0, 2, 0);
-  fs14.closeSync(fd);
+  fs15.readSync(fd, bom, 0, 2, 0);
+  fs15.closeSync(fd);
   let encoding = "utf8";
   if (bom[0] === 255 && bom[1] === 254) {
     encoding = "utf16le";
   }
-  const stat4 = fs14.statSync(filePath);
+  const stat4 = fs15.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 = fs14.readFileSync(filePath, encoding);
+  const raw = fs15.readFileSync(filePath, encoding);
   const content = raw.toString().replaceAll("\r\n", "\n");
   return { content, encoding };
 }
@@ -11353,11 +11366,11 @@ Usage:
         } catch (e) {
           return { content: e.message, isError: true };
         }
-        if (!fs14.existsSync(filePath)) {
+        if (!fs15.existsSync(filePath)) {
           return { content: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, isError: true };
         }
-        const stat4 = fs14.statSync(filePath);
-        const baseName = path15.basename(filePath).toUpperCase();
+        const stat4 = fs15.statSync(filePath);
+        const baseName = path16.basename(filePath).toUpperCase();
         if (BLOCKED_BASENAMES.has(baseName)) {
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6: ${filePath}`, isError: true };
         }
@@ -11365,11 +11378,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 = fs14.readdirSync(filePath);
+          const entries2 = fs15.readdirSync(filePath);
           const items = entries2.map((e) => {
-            const full = path15.join(filePath, e);
+            const full = path16.join(filePath, e);
             try {
-              const s = fs14.statSync(full);
+              const s = fs15.statSync(full);
               return s.isDirectory() ? `${e}/` : e;
             } catch {
               return e;
@@ -11378,7 +11391,7 @@ Usage:
           return { content: `\u76EE\u5F55 (${entries2.length} \u9879):
 ${items.join("\n")}` };
         }
-        const ext = path15.extname(filePath).toLowerCase();
+        const ext = path16.extname(filePath).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext)) {
           return { content: `\u4E8C\u8FDB\u5236\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6 (${ext}): ${filePath}`, isError: true };
         }
@@ -11425,22 +11438,22 @@ ${result}` : result };
 });
 
 // src/tools/write.ts
-import * as fs15 from "node:fs";
-import * as path16 from "node:path";
+import * as fs16 from "node:fs";
+import * as path17 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";
-  fs15.writeFileSync(tmpPath, content, "utf-8");
+  fs16.writeFileSync(tmpPath, content, "utf-8");
   try {
-    fs15.renameSync(tmpPath, filePath);
+    fs16.renameSync(tmpPath, filePath);
   } catch (e) {
     try {
-      fs15.unlinkSync(tmpPath);
+      fs16.unlinkSync(tmpPath);
     } catch {
     }
-    fs15.writeFileSync(filePath, content, "utf-8");
+    fs16.writeFileSync(filePath, content, "utf-8");
   }
 }
 function simpleDiff(oldContent, newContent) {
@@ -11534,15 +11547,15 @@ Usage:
         }
         const rawContent = args.content;
         const content = rawContent.replaceAll("\r\n", "\n");
-        if (fs15.existsSync(filePath) && fs15.statSync(filePath).isDirectory()) {
+        if (fs16.existsSync(filePath) && fs16.statSync(filePath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
         }
         let oldContent = null;
         let isCreate = true;
-        if (fs15.existsSync(filePath)) {
+        if (fs16.existsSync(filePath)) {
           isCreate = false;
           try {
-            oldContent = fs15.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            oldContent = fs16.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
           } catch {
             isCreate = true;
           }
@@ -11558,10 +11571,10 @@ Usage:
               isError: true
             };
           }
-          const currentStat = fs15.statSync(filePath);
+          const currentStat = fs16.statSync(filePath);
           const lastWriteTime = Math.floor(currentStat.mtimeMs);
           if (lastWriteTime > readState.timestamp) {
-            const currentContent = fs15.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            const currentContent = fs16.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}`,
@@ -11570,9 +11583,9 @@ Usage:
             }
           }
         }
-        const dir = path16.dirname(filePath);
+        const dir = path17.dirname(filePath);
         try {
-          fs15.mkdirSync(dir, { recursive: true });
+          fs16.mkdirSync(dir, { recursive: true });
         } catch (e) {
           return { content: `\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${dir} \u2014 ${e.message}`, isError: true };
         }
@@ -11581,11 +11594,11 @@ Usage:
         } catch (e) {
           return { content: `\u5199\u5165\u5931\u8D25: ${e.message}`, isError: true };
         }
-        readFileState.set(filePath, { timestamp: fs15.statSync(filePath).mtimeMs });
+        readFileState.set(filePath, { timestamp: fs16.statSync(filePath).mtimeMs });
         const action = isCreate ? "\u521B\u5EFA" : "\u66F4\u65B0";
         const lines = content.split("\n").length;
         const chars = content.length;
-        const stat4 = fs15.statSync(filePath);
+        const stat4 = fs16.statSync(filePath);
         let diff = "";
         if (!isCreate && oldContent !== null) {
           diff = `
@@ -11604,8 +11617,8 @@ ${simpleDiff(oldContent, content)}`;
 });
 
 // src/tools/edit.ts
-import * as fs16 from "node:fs";
-import * as path17 from "node:path";
+import * as fs17 from "node:fs";
+import * as path18 from "node:path";
 function normalizeQuotes(str) {
   return str.replaceAll(LEFT_SINGLE_CURLY, "'").replaceAll(RIGHT_SINGLE_CURLY, "'").replaceAll(LEFT_DOUBLE_CURLY, '"').replaceAll(RIGHT_DOUBLE_CURLY, '"');
 }
@@ -11758,7 +11771,7 @@ Usage:
         }
         let fileContent = null;
         try {
-          const stat4 = fs16.statSync(filePath);
+          const stat4 = fs17.statSync(filePath);
           if (stat4.isDirectory()) {
             return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
           }
@@ -11768,21 +11781,21 @@ Usage:
         } catch (e) {
           if (e.code === "ENOENT") {
             if (oldString === "") {
-              const dir = path17.dirname(filePath);
-              fs16.mkdirSync(dir, { recursive: true });
-              fs16.writeFileSync(filePath, newString, "utf-8");
-              readFileState.set(filePath, { timestamp: fs16.statSync(filePath).mtimeMs });
+              const dir = path18.dirname(filePath);
+              fs17.mkdirSync(dir, { recursive: true });
+              fs17.writeFileSync(filePath, newString, "utf-8");
+              readFileState.set(filePath, { timestamp: fs17.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 = fs16.readFileSync(filePath, "utf-8");
+        const rawContent = fs17.readFileSync(filePath, "utf-8");
         fileContent = rawContent.replaceAll("\r\n", "\n");
         if (oldString === "" && fileContent.trim() === "") {
-          fs16.writeFileSync(filePath, newString, "utf-8");
-          readFileState.set(filePath, { timestamp: fs16.statSync(filePath).mtimeMs });
+          fs17.writeFileSync(filePath, newString, "utf-8");
+          readFileState.set(filePath, { timestamp: fs17.statSync(filePath).mtimeMs });
           return { content: `\u5199\u5165\u7A7A\u6587\u4EF6: ${filePath} (${newString.split("\n").length} \u884C)` };
         }
         const readState = readFileState.get(filePath);
@@ -11792,11 +11805,11 @@ Usage:
             isError: true
           };
         }
-        const currentStat = fs16.statSync(filePath);
+        const currentStat = fs17.statSync(filePath);
         const lastWriteTime = Math.floor(currentStat.mtimeMs);
         if (lastWriteTime > readState.timestamp) {
           if (fileContent !== rawContent.replaceAll("\r\n", "\n")) {
-            if (fileContent !== fs16.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n")) {
+            if (fileContent !== fs17.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
@@ -11828,8 +11841,8 @@ ${preview}
         const actualNewString = preserveQuoteStyle(oldString, actualOldString, newString);
         const diffView = generateEditDiff(fileContent, actualOldString, actualNewString);
         const newContent = applyEditToFile(fileContent, actualOldString, actualNewString, replaceAll);
-        fs16.writeFileSync(filePath, newContent, "utf-8");
-        readFileState.set(filePath, { timestamp: fs16.statSync(filePath).mtimeMs });
+        fs17.writeFileSync(filePath, newContent, "utf-8");
+        readFileState.set(filePath, { timestamp: fs17.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`;
@@ -11846,8 +11859,8 @@ ${diffView}`
 });
 
 // src/tools/glob.ts
-import * as fs17 from "node:fs";
-import * as path18 from "node:path";
+import * as fs18 from "node:fs";
+import * as path19 from "node:path";
 function globMatch(pattern, filename) {
   const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   try {
@@ -11867,18 +11880,18 @@ function findFiles(dir, pattern, limit, baseDir) {
     }
     let entries2;
     try {
-      entries2 = fs17.readdirSync(currentDir, { withFileTypes: true });
+      entries2 = fs18.readdirSync(currentDir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries2) {
       if (truncated) return;
-      const fullPath = path18.join(currentDir, entry.name);
+      const fullPath = path19.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (VCS_DIRS.has(entry.name)) continue;
         walk(fullPath);
       } else if (entry.isFile()) {
-        const relativePath = path18.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = path19.relative(baseDir, fullPath).replace(/\\/g, "/");
         const patternsToTry = [pattern];
         if (pattern.startsWith("**/")) {
           patternsToTry.push(pattern.slice(3));
@@ -11888,7 +11901,7 @@ function findFiles(dir, pattern, limit, baseDir) {
         );
         if (matched) {
           try {
-            const stat4 = fs17.statSync(fullPath);
+            const stat4 = fs18.statSync(fullPath);
             results.push({ path: fullPath, mtimeMs: stat4.mtimeMs });
           } catch {
           }
@@ -11905,7 +11918,7 @@ function findFiles(dir, pattern, limit, baseDir) {
   };
 }
 function toRelativePath(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path18.sep)) {
+  if (absolutePath.startsWith(cwd + path19.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   return absolutePath;
@@ -11938,10 +11951,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 (!fs17.existsSync(searchPath)) {
+        if (!fs18.existsSync(searchPath)) {
           return { content: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${searchPath}`, isError: true };
         }
-        if (!fs17.statSync(searchPath).isDirectory()) {
+        if (!fs18.statSync(searchPath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${searchPath}`, isError: true };
         }
         const start = Date.now();
@@ -11965,7 +11978,7 @@ ${filenames.join("\n")}${truncatedNote}`
 
 // src/tools/grep.ts
 import { execFile } from "node:child_process";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 function ripGrep(args, searchPath, signal) {
   return new Promise((resolve12) => {
     const fullArgs = [...args, searchPath];
@@ -11997,7 +12010,7 @@ function applyHeadLimit(items, limit, offset = 0) {
   };
 }
 function toRelativePath2(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path19.sep)) {
+  if (absolutePath.startsWith(cwd + path20.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   if (absolutePath.startsWith(cwd)) {
@@ -13247,7 +13260,7 @@ async function acquireLock(inboxPath) {
   for (let i = 0; i < LOCK_RETRIES; i++) {
     if (await isLockStale(lockPath2)) {
       try {
-        await import("node:fs/promises").then((fs43) => fs43.rm(lockPath2, { force: true }));
+        await import("node:fs/promises").then((fs44) => fs44.rm(lockPath2, { force: true }));
       } catch {
       }
     }
@@ -13255,7 +13268,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((fs43) => fs43.rm(lockPath2, { force: true }));
+          await import("node:fs/promises").then((fs44) => fs44.rm(lockPath2, { force: true }));
         } catch {
         }
       };
@@ -14498,12 +14511,12 @@ Examples:
 });
 
 // src/tools/msg-husband.ts
-import fs18 from "node:fs";
-import path20 from "node:path";
+import fs19 from "node:fs";
+import path21 from "node:path";
 function getHusbandFeishuId(workspace) {
-  const contactsPath = path20.join(workspace, "prompts", "contacts.md");
+  const contactsPath = path21.join(workspace, "prompts", "contacts.md");
   try {
-    const text = fs18.readFileSync(contactsPath, "utf-8");
+    const text = fs19.readFileSync(contactsPath, "utf-8");
     const m = text.match(/\|\s*翀哥\s*\|\s*(ou_[a-f0-9]+)\s*\|/);
     return m ? m[1] : null;
   } catch {
@@ -14656,8 +14669,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 fs43 = await import("node:fs");
-        if (!fs43.existsSync(filePath)) {
+        const fs44 = await import("node:fs");
+        if (!fs44.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) : [];
@@ -14685,7 +14698,7 @@ Examples:
           md: "text/markdown"
         };
         const mimeType = mimeTypeMap[ext] || "application/octet-stream";
-        const stat4 = fs43.statSync(filePath);
+        const stat4 = fs44.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 };
@@ -14714,8 +14727,8 @@ Examples:
 });
 
 // src/tools/my-eyes.ts
-import * as fs19 from "node:fs";
-import * as path21 from "node:path";
+import * as fs20 from "node:fs";
+import * as path22 from "node:path";
 function extractUsage(data) {
   try {
     const u = data?.usage ?? data?.usageMetadata;
@@ -14730,9 +14743,9 @@ function extractUsage(data) {
   }
 }
 function resolveLatestImage(specifiedPath, mediaDir) {
-  if (specifiedPath && fs19.existsSync(specifiedPath)) return specifiedPath;
-  if (!fs19.existsSync(mediaDir)) return null;
-  const files = fs19.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp|mp4|mov)$/i.test(f)).map((f) => ({ name: f, p: path21.join(mediaDir, f), mtime: fs19.statSync(path21.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (specifiedPath && fs20.existsSync(specifiedPath)) return specifiedPath;
+  if (!fs20.existsSync(mediaDir)) return null;
+  const files = fs20.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp|mp4|mov)$/i.test(f)).map((f) => ({ name: f, p: path22.join(mediaDir, f), mtime: fs20.statSync(path22.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return files[0]?.p || null;
 }
 var MIME_MAP, VIDEO_EXT, VIDEO_MAX_BYTES;
@@ -14780,15 +14793,15 @@ var init_my_eyes = __esm({
         if (!provider?.streamChat) {
           return { content: "Error: provider \u4E0D\u53EF\u7528\u3002", isError: true };
         }
-        const mediaDir = path21.join(ctx.stateDir, "media", "inbound");
+        const mediaDir = path22.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 = path21.extname(imagePath).toLowerCase();
+        const ext = path22.extname(imagePath).toLowerCase();
         if (VIDEO_EXT.test(imagePath)) {
-          const stat4 = fs19.statSync(imagePath);
+          const stat4 = fs20.statSync(imagePath);
           if (stat4.size > VIDEO_MAX_BYTES) {
             return { content: `Error: video too large (${(stat4.size / 1e6).toFixed(1)}MB > ${(VIDEO_MAX_BYTES / 1e6).toFixed(0)}MB). Compress or trim first.`, isError: true };
           }
@@ -14802,7 +14815,7 @@ var init_my_eyes = __esm({
           }
           const explicit = liveConfig.get("tools.my_eyes.videoBaseUrl");
           const baseUrl = explicit || vProviderCfg.baseUrl.replace(/\/anthropic\/?$/, "/v1").replace(/\/$/, "");
-          const vidB64 = fs19.readFileSync(imagePath).toString("base64");
+          const vidB64 = fs20.readFileSync(imagePath).toString("base64");
           try {
             const res = await fetch(`${baseUrl}/chat/completions`, {
               method: "POST",
@@ -14833,7 +14846,7 @@ var init_my_eyes = __esm({
           }
         }
         const mime = MIME_MAP[ext] || "jpeg";
-        const imgB64 = fs19.readFileSync(imagePath).toString("base64");
+        const imgB64 = fs20.readFileSync(imagePath).toString("base64");
         const userMsg = {
           role: "user",
           content: [
@@ -14868,7 +14881,7 @@ var init_my_eyes = __esm({
 });
 
 // src/tools/opus-encoder.ts
-import * as fs20 from "node:fs";
+import * as fs21 from "node:fs";
 function oggCrc32(buf) {
   let crc = 0;
   for (let i = 0; i < buf.length; i++) {
@@ -14928,7 +14941,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(fs20.readFileSync(wavPath));
+  const wav = parseWav(fs21.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");
@@ -14964,7 +14977,7 @@ async function wavToOggOpusNative(wavPath) {
   }
   ogg.page(cur, pageGranule, false, true);
   const oggPath = wavPath.replace(/\.wav$/, ".ogg");
-  fs20.writeFileSync(oggPath, ogg.finish());
+  fs21.writeFileSync(oggPath, ogg.finish());
   return oggPath;
 }
 var FRAME_MS, PRESKIP_48K, OPUS_RATE, NATIVE_RATES, BITRATE, CRC_TABLE, OggWriter;
@@ -15072,8 +15085,8 @@ var init_voice_chat_tts_daemon = __esm({
 import { execFile as execFile2 } from "node:child_process";
 import { createInterface as createInterface2 } from "node:readline";
 import { promisify } from "node:util";
-import * as fs21 from "node:fs";
-import * as path22 from "node:path";
+import * as fs22 from "node:fs";
+import * as path23 from "node:path";
 import * as os4 from "node:os";
 function wavDurationSec(buf) {
   if (buf.length < 12 || buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WAVE") {
@@ -15128,8 +15141,8 @@ function resolvePython(configuredPath) {
     // LOCALAPPDATA 缺席（非 Windows / 精简环境）时**不加这两个候选**：
     // 拼出来会是相对路径 'Microsoft/WindowsApps/python.exe'，那可能撞上 cwd 里的东西。
     ...localAppData ? [
-      path22.join(localAppData, "Microsoft", "WindowsApps", "python3.exe"),
-      path22.join(localAppData, "Microsoft", "WindowsApps", "python.exe")
+      path23.join(localAppData, "Microsoft", "WindowsApps", "python3.exe"),
+      path23.join(localAppData, "Microsoft", "WindowsApps", "python.exe")
     ] : []
   ];
   for (const c of candidates) {
@@ -15149,8 +15162,8 @@ async function ttsCosyvoice(text, apiKey, model, voice, workspaceId, instruction
 }
 async function ttsCosyvoiceStream(text, cfg, onChunk) {
   const { apiKey, model, voice, workspaceId, instruction } = cfg;
-  fs21.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path22.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs22.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path23.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const script = `
 import sys, json, base64, threading
 import dashscope
@@ -15235,7 +15248,7 @@ print('EOS')
   header.writeUInt16LE(16, 34);
   header.write("data", 36);
   header.writeUInt32LE(pcm.length, 40);
-  fs21.writeFileSync(output, Buffer.concat([header, pcm]));
+  fs22.writeFileSync(output, Buffer.concat([header, pcm]));
   return output;
 }
 async function ttsQwen3Local(text, cfg, onChunk) {
@@ -15287,9 +15300,9 @@ async function ttsQwen3Opus(text, cfg) {
   const ogg = Buffer.from(await res.arrayBuffer());
   if (ogg.length < 20) throw new Error("qwen3-3060 opus: empty output");
   const durationMs = parseInt(res.headers.get("x-duration-ms") || "0", 10);
-  fs21.mkdirSync(VOICE_DIR, { recursive: true });
-  const oggPath = path22.join(VOICE_DIR, `tts_${Date.now()}.ogg`);
-  fs21.writeFileSync(oggPath, ogg);
+  fs22.mkdirSync(VOICE_DIR, { recursive: true });
+  const oggPath = path23.join(VOICE_DIR, `tts_${Date.now()}.ogg`);
+  fs22.writeFileSync(oggPath, ogg);
   return { oggPath, durationMs };
 }
 async function ttsGptsovits(text, c) {
@@ -15301,8 +15314,8 @@ async function ttsGptsovits(text, c) {
       "gptsovits \u672A\u914D\u7F6E\uFF1A\u9700\u8981 tools.my_voice \u91CC\u7684 gptsovitsUrl / gptsovitsRefWav / gptsovitsRefText\u3002\u53C2\u8003\u97F3\u9891\u4E0E\u53C2\u8003\u6587\u672C**\u5FC5\u987B\u9010\u5B57\u5BF9\u5E94**\uFF0C\u5426\u5219\u5408\u6210\u51FA\u6765\u7684\u58F0\u97F3\u4F1A\u5E26\u6742\u97F3\uFF080925 \u8E29\u8FC7\u88C1\u574F ref.wav \u7684\u5751\uFF09\u3002"
     );
   }
-  fs21.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path22.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs22.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path23.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const params = new URLSearchParams({
     text,
     text_language: "zh",
@@ -15313,12 +15326,12 @@ async function ttsGptsovits(text, c) {
   const res = await fetch(`${url}/?${params}`);
   if (!res.ok) throw new Error(`GPT-SoVITS API ${res.status}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs21.writeFileSync(output, buf);
+  fs22.writeFileSync(output, buf);
   return output;
 }
 async function ttsEdge(text) {
-  fs21.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path22.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
+  fs22.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path23.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
   const script = `
 import asyncio, edge_tts, sys
 async def main():
@@ -15356,8 +15369,8 @@ async function synthQwen3(text, _sink) {
     const pcmChunks = [];
     await ttsQwen3Local(text, { url: c.url, voice: c.voice, lang: c.lang }, (pcm2) => pcmChunks.push(pcm2));
     const pcm = Buffer.concat(pcmChunks);
-    fs21.mkdirSync(VOICE_DIR, { recursive: true });
-    const wavPath = path22.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+    fs22.mkdirSync(VOICE_DIR, { recursive: true });
+    const wavPath = path23.join(VOICE_DIR, `tts_${Date.now()}.wav`);
     const header = Buffer.alloc(44);
     header.write("RIFF", 0);
     header.writeUInt32LE(36 + pcm.length, 4);
@@ -15372,7 +15385,7 @@ async function synthQwen3(text, _sink) {
     header.writeUInt16LE(16, 34);
     header.write("data", 36);
     header.writeUInt32LE(pcm.length, 40);
-    fs21.writeFileSync(wavPath, Buffer.concat([header, pcm]));
+    fs22.writeFileSync(wavPath, Buffer.concat([header, pcm]));
     return { path: wavPath, format: "wav", unit: unit(text), voice: c.voice };
   }
 }
@@ -15388,7 +15401,7 @@ var init_impl = __esm({
     init_well_formed();
     init_voice_chat_tts_daemon();
     execFileAsync = promisify(execFile2);
-    VOICE_DIR = path22.join(os4.tmpdir(), "engine-voice");
+    VOICE_DIR = path23.join(os4.tmpdir(), "engine-voice");
     _pyCache = null;
     EDGE_VOICE = "zh-CN-XiaoxiaoNeural";
     unit = (text) => ({ kind: "chars", amount: [...text].length });
@@ -15402,9 +15415,9 @@ var init_impl = __esm({
 });
 
 // src/tools/tts/relay.ts
-import * as fs22 from "node:fs";
+import * as fs23 from "node:fs";
 import * as os5 from "node:os";
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 async function synthRelay(text, cfg) {
   const res = await fetchFn(`${cfg.baseUrl}/audio/speech`, {
     method: "POST",
@@ -15422,9 +15435,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`);
-  fs22.mkdirSync(VOICE_DIR2, { recursive: true });
-  const out = path23.join(VOICE_DIR2, `tts_relay_${Date.now()}.mp3`);
-  fs22.writeFileSync(out, buf);
+  fs23.mkdirSync(VOICE_DIR2, { recursive: true });
+  const out = path24.join(VOICE_DIR2, `tts_relay_${Date.now()}.mp3`);
+  fs23.writeFileSync(out, buf);
   return {
     path: out,
     format: "mp3",
@@ -15437,7 +15450,7 @@ var VOICE_DIR2, fetchFn;
 var init_relay = __esm({
   "src/tools/tts/relay.ts"() {
     "use strict";
-    VOICE_DIR2 = path23.join(os5.tmpdir(), "engine-voice");
+    VOICE_DIR2 = path24.join(os5.tmpdir(), "engine-voice");
     fetchFn = fetch;
   }
 });
@@ -15608,13 +15621,13 @@ var init_providers = __esm({
 });
 
 // src/utils/ffmpeg-path.ts
-import * as fs23 from "node:fs";
+import * as fs24 from "node:fs";
 function resolveFfmpegPath() {
   const env = (process.env.E7_FFMPEG_PATH || "").trim();
-  if (env && fs23.existsSync(env)) return env;
+  if (env && fs24.existsSync(env)) return env;
   try {
     const p = __require("@ffmpeg-installer/ffmpeg")?.path;
-    if (p && fs23.existsSync(p)) return p;
+    if (p && fs24.existsSync(p)) return p;
   } catch {
   }
   return "ffmpeg";
@@ -15628,8 +15641,8 @@ var init_ffmpeg_path = __esm({
 // src/tools/my-voice.ts
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-import * as fs24 from "node:fs";
-import * as path24 from "node:path";
+import * as fs25 from "node:fs";
+import * as path25 from "node:path";
 async function toWav24kWithDuration(audioPath) {
   let wavPath = audioPath;
   if (!audioPath.endsWith(".wav")) {
@@ -15646,15 +15659,15 @@ async function toWav24kWithDuration(audioPath) {
       "pcm_s16le",
       wavPath
     ], { timeout: 3e4 });
-    if (!fs24.existsSync(wavPath) || fs24.statSync(wavPath).size < 44) {
+    if (!fs25.existsSync(wavPath) || fs25.statSync(wavPath).size < 44) {
       throw new Error("toWav24k produced empty output");
     }
     try {
-      fs24.unlinkSync(audioPath);
+      fs25.unlinkSync(audioPath);
     } catch {
     }
   }
-  const durationSec = wavDurationSec(fs24.readFileSync(wavPath));
+  const durationSec = wavDurationSec(fs25.readFileSync(wavPath));
   return { wavPath, durationSec };
 }
 async function compressWav(wavPath) {
@@ -15672,7 +15685,7 @@ async function compressWav(wavPath) {
       "+faststart",
       m4aPath
     ], { timeout: 3e4 });
-    fs24.unlinkSync(wavPath);
+    fs25.unlinkSync(wavPath);
     return m4aPath;
   } catch {
     return wavPath;
@@ -15699,10 +15712,10 @@ async function wavToOggOpus(wavPath) {
       oggPath
     ], { timeout: 3e4 });
   }
-  if (!fs24.existsSync(oggPath) || fs24.statSync(oggPath).size < 20) {
+  if (!fs25.existsSync(oggPath) || fs25.statSync(oggPath).size < 20) {
     throw new Error("ogg/opus encode produced empty output");
   }
-  fs24.unlinkSync(wavPath);
+  fs25.unlinkSync(wavPath);
   return oggPath;
 }
 async function sendVoiceToMulticaIssue(text, issueId, opts) {
@@ -15717,7 +15730,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 || !fs24.existsSync(audioPath)) {
+  if (!audioPath || !fs25.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")) {
@@ -15727,21 +15740,21 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
       console.warn(`[my-voice:multaca] opus encode failed (${e.message}), attaching wav`);
     }
   }
-  const ext = path24.extname(audioPath).toLowerCase();
-  const sizeKB = fs24.statSync(audioPath).size / 1024;
+  const ext = path25.extname(audioPath).toLowerCase();
+  const sizeKB = fs25.statSync(audioPath).size / 1024;
   const voiceFile = `voice_${Date.now()}${ext}`;
-  const cwdCopy = path24.join(process.cwd(), voiceFile);
+  const cwdCopy = path25.join(process.cwd(), voiceFile);
   try {
-    fs24.copyFileSync(audioPath, cwdCopy);
+    fs25.copyFileSync(audioPath, cwdCopy);
   } catch (e) {
     try {
-      fs24.unlinkSync(audioPath);
+      fs25.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 {
-    fs24.unlinkSync(audioPath);
+    fs25.unlinkSync(audioPath);
   } catch {
   }
   const content = opts.caption || `\u{1F399}\uFE0F \u8BED\u97F3\u6D88\u606F\uFF08${text.length} \u5B57\uFF09`;
@@ -15770,13 +15783,13 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
     }
     if (!ok) throw new Error(`unexpected CLI output: ${String(stdout).slice(0, 200)}`);
     try {
-      fs24.unlinkSync(cwdCopy);
+      fs25.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 {
-      fs24.unlinkSync(cwdCopy);
+      fs25.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 };
@@ -15906,10 +15919,10 @@ var init_my_voice = __esm({
             audioPath = await compressWav(audioPath);
           }
         }
-        const ext = path24.extname(audioPath).toLowerCase();
+        const ext = path25.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 = fs24.statSync(audioPath).size / 1024;
+        const sizeKB = fs25.statSync(audioPath).size / 1024;
         try {
           await mgr.sendFile(resolvedChannel, target, caption, {
             path: audioPath,
@@ -15918,7 +15931,7 @@ var init_my_voice = __esm({
             ...voiceDurationSec !== void 0 ? { voiceDurationSec } : {}
           });
           try {
-            fs24.unlinkSync(audioPath);
+            fs25.unlinkSync(audioPath);
           } catch {
           }
           return { content: `Voice sent! (${actualEngine}, ${sizeKB.toFixed(0)}KB, ${resolvedChannel})` };
@@ -15940,8 +15953,8 @@ __export(my_selfie_exports, {
   dimsOf: () => dimsOf,
   resolvePortraitDesc: () => resolvePortraitDesc
 });
-import * as fs25 from "node:fs";
-import * as path25 from "node:path";
+import * as fs26 from "node:fs";
+import * as path26 from "node:path";
 function getProxyDispatcher2() {
   const cfg = liveConfig.all();
   const proxy = cfg.providers?.xai?.proxy;
@@ -15955,7 +15968,7 @@ function getProxyDispatcher2() {
 }
 function dimsOf(p) {
   try {
-    const b = fs25.readFileSync(p);
+    const b = fs26.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);
@@ -16068,9 +16081,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 path43 = cfg?.tools?.my_selfie ? "tools.my_selfie.references" : "my_selfie.references";
-    void liveConfig.set(path43, next);
-    console.log(`[my-selfie] \u5F62\u8C61\u5DF2\u767B\u8BB0\uFF1A${path43}[0] = ${relPath}`);
+    const path44 = cfg?.tools?.my_selfie ? "tools.my_selfie.references" : "my_selfie.references";
+    void liveConfig.set(path44, next);
+    console.log(`[my-selfie] \u5F62\u8C61\u5DF2\u767B\u8BB0\uFF1A${path44}[0] = ${relPath}`);
   } catch (e) {
     console.warn(`[my-selfie] \u5199\u5165 references \u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u672C\u6B21\u51FA\u56FE\uFF09: ${e.message}`);
   }
@@ -16368,10 +16381,10 @@ var init_my_selfie = __esm({
         const REFERENCES = getReferences(ctx);
         const refName = args.reference || "default";
         const refEntry = REFERENCES.find((r) => r.name === refName) || REFERENCES[0];
-        let refPath = path25.join(ctx.workspace, refEntry.p);
+        let refPath = path26.join(ctx.workspace, refEntry.p);
         const adoptImg = args.referenceImage?.trim();
         if (adoptImg) {
-          if (!fs25.existsSync(adoptImg)) {
+          if (!fs26.existsSync(adoptImg)) {
             return { content: `\u627E\u4E0D\u5230\u90A3\u5F20\u56FE\uFF1A${adoptImg}`, isError: true };
           }
           const acheck = dimsOf(adoptImg);
@@ -16382,16 +16395,16 @@ var init_my_selfie = __esm({
               isError: true
             };
           }
-          const adir = path25.join(ctx.workspace, "images");
-          if (!fs25.existsSync(adir)) fs25.mkdirSync(adir, { recursive: true });
-          const aext = (path25.extname(adoptImg) || ".png").toLowerCase();
+          const adir = path26.join(ctx.workspace, "images");
+          if (!fs26.existsSync(adir)) fs26.mkdirSync(adir, { recursive: true });
+          const aext = (path26.extname(adoptImg) || ".png").toLowerCase();
           const afname = `portrait_${Date.now()}${aext}`;
-          fs25.copyFileSync(adoptImg, path25.join(adir, afname));
+          fs26.copyFileSync(adoptImg, path26.join(adir, afname));
           registerPortrait(`images/${afname}`, refName);
-          refPath = path25.join(adir, afname);
+          refPath = path26.join(adir, afname);
           console.log(`[my-selfie] \u91C7\u7EB3\u73B0\u6210\u56FE\u5F53\u5F62\u8C61\uFF1Aimages/${afname}${acheck ? ` (${acheck})` : ""}`);
         }
-        if (provider !== "autodl" && !fs25.existsSync(refPath)) {
+        if (provider !== "autodl" && !fs26.existsSync(refPath)) {
           const cfgAll = liveConfig.all();
           const portraitDesc = resolvePortraitDesc(
             args.portrait,
@@ -16416,16 +16429,16 @@ var init_my_selfie = __esm({
           } catch (e) {
             return { content: `\u5851\u9020\u5F62\u8C61\u5931\u8D25\uFF1A${e.message}`, isError: true };
           }
-          const pdir = path25.join(ctx.workspace, "images");
-          if (!fs25.existsSync(pdir)) fs25.mkdirSync(pdir, { recursive: true });
+          const pdir = path26.join(ctx.workspace, "images");
+          if (!fs26.existsSync(pdir)) fs26.mkdirSync(pdir, { recursive: true });
           const pfname = `portrait_${Date.now()}.png`;
-          fs25.writeFileSync(path25.join(pdir, pfname), portraitBuf);
+          fs26.writeFileSync(path26.join(pdir, pfname), portraitBuf);
           registerPortrait(`images/${pfname}`, refName);
-          refPath = path25.join(pdir, pfname);
+          refPath = path26.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 = fs25.existsSync(refPath) ? fs25.readFileSync(refPath).toString("base64") : "";
+        const refB64 = fs26.existsSync(refPath) ? fs26.readFileSync(refPath).toString("base64") : "";
         let imageBuffer;
         try {
           if (provider === "autodl") {
@@ -16441,7 +16454,7 @@ var init_my_selfie = __esm({
               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 = path25.extname(refPath).toLowerCase();
+            const ext = path26.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 {
@@ -16450,11 +16463,11 @@ var init_my_selfie = __esm({
         } catch (err) {
           return { content: `Selfie generation failed: ${err.message}`, isError: true };
         }
-        const imagesDir = path25.join(ctx.workspace, "images");
-        if (!fs25.existsSync(imagesDir)) fs25.mkdirSync(imagesDir, { recursive: true });
+        const imagesDir = path26.join(ctx.workspace, "images");
+        if (!fs26.existsSync(imagesDir)) fs26.mkdirSync(imagesDir, { recursive: true });
         const filename = `selfie_${Date.now()}.jpg`;
-        const outputPath = path25.join(imagesDir, filename);
-        fs25.writeFileSync(outputPath, imageBuffer);
+        const outputPath = path26.join(imagesDir, filename);
+        fs26.writeFileSync(outputPath, imageBuffer);
         const mgr = ctx.channelManager;
         if (mgr) {
           const resolvedChannel = ctx.channel || "feishu";
@@ -16465,11 +16478,11 @@ var init_my_selfie = __esm({
               mimeType: "image/jpeg"
             });
           } catch (err) {
-            return { content: `Selfie generated but send failed: ${err.message}. Image: ${path25.resolve(outputPath)}`, isError: false };
+            return { content: `Selfie generated but send failed: ${err.message}. Image: ${path26.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: ${path25.resolve(outputPath)}` };
+        return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path26.resolve(outputPath)}` };
       },
       isConcurrencySafe: () => false,
       interruptBehavior: () => "block",
@@ -17299,8 +17312,8 @@ var init_calendar = __esm({
 });
 
 // src/tools/service.ts
-import * as fs26 from "node:fs";
-import * as path26 from "node:path";
+import * as fs27 from "node:fs";
+import * as path27 from "node:path";
 import { exec, spawn as spawn4 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 function getServices() {
@@ -17308,9 +17321,9 @@ function getServices() {
 }
 function serviceLogPath(fileName) {
   const stateDir = String(liveConfig.get("stateDir") ?? "");
-  const logDir = path26.join(stateDir, "logs");
-  if (!fs26.existsSync(logDir)) fs26.mkdirSync(logDir, { recursive: true });
-  return path26.join(logDir, fileName);
+  const logDir = path27.join(stateDir, "logs");
+  if (!fs27.existsSync(logDir)) fs27.mkdirSync(logDir, { recursive: true });
+  return path27.join(logDir, fileName);
 }
 async function runCmd(cmd, timeoutMs = 15e3) {
   try {
@@ -17525,24 +17538,24 @@ var init_constants5 = __esm({
 });
 
 // src/tools/TodoWriteTool/TodoWriteTool.ts
-import fs27 from "node:fs";
-import path27 from "node:path";
+import fs28 from "node:fs";
+import path28 from "node:path";
 function todoFilePath(sessionId) {
-  return path27.join(todosDir, `${sessionId}.json`);
+  return path28.join(todosDir, `${sessionId}.json`);
 }
 function loadTodos(sessionId) {
   if (!todosDir) return [];
   try {
     const filePath = todoFilePath(sessionId);
-    if (!fs27.existsSync(filePath)) return [];
-    return JSON.parse(fs27.readFileSync(filePath, "utf-8"));
+    if (!fs28.existsSync(filePath)) return [];
+    return JSON.parse(fs28.readFileSync(filePath, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveTodos(sessionId, todos) {
   if (!todosDir) return;
-  fs27.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
+  fs28.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
 }
 var todosDir;
 var init_TodoWriteTool = __esm({
@@ -17799,15 +17812,15 @@ var init_constants7 = __esm({
 });
 
 // src/utils/plans.ts
-import * as fs28 from "node:fs";
-import * as path28 from "node:path";
+import * as fs29 from "node:fs";
+import * as path29 from "node:path";
 import * as crypto4 from "node:crypto";
 function generateSlug() {
   return crypto4.randomBytes(4).toString("hex");
 }
 function getPlansDirectory(stateDir) {
-  const plansDir = path28.join(stateDir, "plans");
-  fs28.mkdirSync(plansDir, { recursive: true });
+  const plansDir = path29.join(stateDir, "plans");
+  fs29.mkdirSync(plansDir, { recursive: true });
   return plansDir;
 }
 function getPlanSlug(sessionId, stateDir) {
@@ -17816,8 +17829,8 @@ function getPlanSlug(sessionId, stateDir) {
     const plansDir = getPlansDirectory(stateDir);
     for (let i = 0; i < MAX_SLUG_RETRIES; i++) {
       slug = generateSlug();
-      const filePath = path28.join(plansDir, `${slug}.md`);
-      if (!fs28.existsSync(filePath)) {
+      const filePath = path29.join(plansDir, `${slug}.md`);
+      if (!fs29.existsSync(filePath)) {
         break;
       }
     }
@@ -17828,21 +17841,21 @@ function getPlanSlug(sessionId, stateDir) {
 function getPlanFilePath(sessionId, stateDir, agentId) {
   const slug = getPlanSlug(sessionId, stateDir);
   if (!agentId) {
-    return path28.join(getPlansDirectory(stateDir), `${slug}.md`);
+    return path29.join(getPlansDirectory(stateDir), `${slug}.md`);
   }
-  return path28.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
+  return path29.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
 }
 function getPlan(sessionId, stateDir, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
   try {
-    return fs28.readFileSync(filePath, "utf-8");
+    return fs29.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writePlan(sessionId, stateDir, content, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
-  fs28.writeFileSync(filePath, content, "utf-8");
+  fs29.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 var MAX_SLUG_RETRIES, planSlugCache;
@@ -17990,28 +18003,28 @@ var init_constants8 = __esm({
 });
 
 // src/utils/tasks.ts
-import * as fs29 from "node:fs";
-import * as path29 from "node:path";
+import * as fs30 from "node:fs";
+import * as path30 from "node:path";
 function sanitizePathComponent2(input) {
   return input.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
 function getTasksDir2(stateDir, listId) {
-  return path29.join(stateDir, "tasks", sanitizePathComponent2(listId));
+  return path30.join(stateDir, "tasks", sanitizePathComponent2(listId));
 }
 function getTaskPath(stateDir, listId, taskId) {
-  return path29.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
+  return path30.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
 }
 function ensureTasksDir2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
-  fs29.mkdirSync(dir, { recursive: true });
+  fs30.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function getHighWaterMarkPath(stateDir, listId) {
-  return path29.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
+  return path30.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
 }
 function readHighWaterMark(stateDir, listId) {
   try {
-    const content = fs29.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
+    const content = fs30.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
     const value = parseInt(content, 10);
     return isNaN(value) ? 0 : value;
   } catch {
@@ -18019,13 +18032,13 @@ function readHighWaterMark(stateDir, listId) {
   }
 }
 function writeHighWaterMark(stateDir, listId, value) {
-  fs29.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
+  fs30.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
 }
 function findHighestTaskIdFromFiles(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs29.readdirSync(dir);
+    files = fs30.readdirSync(dir);
   } catch {
     return 0;
   }
@@ -18051,14 +18064,14 @@ function createTask(stateDir, listId, taskData) {
     const id = String(highestId + 1);
     const task = { id, ...taskData };
     const filePath = getTaskPath(stateDir, listId, id);
-    fs29.writeFileSync(filePath, JSON.stringify(task, null, 2));
+    fs30.writeFileSync(filePath, JSON.stringify(task, null, 2));
     return id;
   });
 }
 function getTask2(stateDir, listId, taskId) {
   const filePath = getTaskPath(stateDir, listId, taskId);
   try {
-    const content = fs29.readFileSync(filePath, "utf-8");
+    const content = fs30.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -18068,7 +18081,7 @@ function listTasks2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs29.readdirSync(dir);
+    files = fs30.readdirSync(dir);
   } catch {
     return [];
   }
@@ -18080,7 +18093,7 @@ function updateTask(stateDir, listId, taskId, updates) {
   if (!existing) return null;
   const updated = { ...existing, ...updates, id: taskId };
   const filePath = getTaskPath(stateDir, listId, taskId);
-  fs29.writeFileSync(filePath, JSON.stringify(updated, null, 2));
+  fs30.writeFileSync(filePath, JSON.stringify(updated, null, 2));
   return updated;
 }
 function deleteTask(stateDir, listId, taskId) {
@@ -18094,7 +18107,7 @@ function deleteTask(stateDir, listId, taskId) {
     }
   }
   try {
-    fs29.unlinkSync(filePath);
+    fs30.unlinkSync(filePath);
   } catch {
     return false;
   }
@@ -19527,10 +19540,10 @@ function ensureLoaded(workspace, configIds) {
       if (!state.blockedUserIds.includes(id)) state.blockedUserIds.push(id);
     }
   }
-  const path43 = join28(workspace, ".reply-blocklist.json");
+  const path44 = join28(workspace, ".reply-blocklist.json");
   try {
-    if (existsSync22(path43)) {
-      const raw = readFileSync21(path43, "utf-8");
+    if (existsSync22(path44)) {
+      const raw = readFileSync21(path44, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.blockedUserIds) {
         for (const id of parsed.blockedUserIds) {
@@ -19546,9 +19559,9 @@ function ensureLoaded(workspace, configIds) {
   loaded = true;
 }
 function save(workspace) {
-  const path43 = join28(workspace, ".reply-blocklist.json");
+  const path44 = join28(workspace, ".reply-blocklist.json");
   try {
-    writeFileSync16(path43, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync16(path44, JSON.stringify(state, null, 2), "utf-8");
   } catch (err) {
     console.warn(`[reply-blocklist] Failed to save: ${err.message}`);
   }
@@ -20744,8 +20757,8 @@ var extractMemories_exports = {};
 __export(extractMemories_exports, {
   createMemoryExtractor: () => createMemoryExtractor
 });
-import * as fs30 from "fs";
-import * as path30 from "path";
+import * as fs31 from "fs";
+import * as path31 from "path";
 function isModelVisibleMessage(message) {
   return message.role === "user" || message.role === "assistant";
 }
@@ -20768,13 +20781,13 @@ function getMemoryTools() {
   return allDefs.filter((d) => MEMORY_TOOL_NAMES.includes(d.function.name));
 }
 function getStatePath(workspace) {
-  return path30.join(workspace, STATE_FILE);
+  return path31.join(workspace, STATE_FILE);
 }
 function loadPersistedState(workspace) {
   try {
     const p = getStatePath(workspace);
-    if (fs30.existsSync(p)) {
-      const data = JSON.parse(fs30.readFileSync(p, "utf-8"));
+    if (fs31.existsSync(p)) {
+      const data = JSON.parse(fs31.readFileSync(p, "utf-8"));
       for (const [sid, ts] of Object.entries(data.lastTs ?? {})) {
         lastTsMap.set(sid, ts);
       }
@@ -20794,7 +20807,7 @@ function persistState(workspace) {
     for (const [sid, ts] of lastTsMap.entries()) lastTs[sid] = ts;
     for (const [sid, ts] of lastExtractTimeMap.entries()) timestamps[sid] = ts;
     const data = JSON.stringify({ lastTs, timestamps }, null, 2);
-    fs30.writeFileSync(getStatePath(workspace), data, "utf-8");
+    fs31.writeFileSync(getStatePath(workspace), data, "utf-8");
   } catch (e) {
     console.warn(`[memory] failed to persist extract state: ${e?.message ?? e}`);
   }
@@ -20835,11 +20848,11 @@ function createMemoryExtractor(workspace, enabled) {
         const existingMemories = formatMemoryManifest(
           await scanMemoryFiles2(memoryDir, new AbortController().signal)
         );
-        const extractOverridePath = path30.join(workspace, "prompts", "extract.md");
+        const extractOverridePath = path31.join(workspace, "prompts", "extract.md");
         let systemPrompt;
         try {
-          if (fs30.existsSync(extractOverridePath)) {
-            systemPrompt = fs30.readFileSync(extractOverridePath, { encoding: "utf-8" });
+          if (fs31.existsSync(extractOverridePath)) {
+            systemPrompt = fs31.readFileSync(extractOverridePath, { encoding: "utf-8" });
             if (existingMemories.length > 0) {
               systemPrompt += `
 
@@ -20965,8 +20978,8 @@ __export(ingest_exports, {
   pushConversation: () => pushConversation,
   toPayload: () => toPayload
 });
-import fs31 from "node:fs";
-import path31 from "node:path";
+import fs32 from "node:fs";
+import path32 from "node:path";
 async function readConfig() {
   const defaults = {
     url: "http://127.0.0.1:8100",
@@ -20996,9 +21009,9 @@ async function readConfig() {
 }
 function loadPushTs(workspace, sessionId) {
   try {
-    const p = path31.join(workspace, PUSH_STATE_FILE);
-    if (fs31.existsSync(p)) {
-      const data = JSON.parse(fs31.readFileSync(p, "utf-8"));
+    const p = path32.join(workspace, PUSH_STATE_FILE);
+    if (fs32.existsSync(p)) {
+      const data = JSON.parse(fs32.readFileSync(p, "utf-8"));
       return typeof data[sessionId] === "number" ? data[sessionId] : 0;
     }
   } catch (e) {
@@ -21008,14 +21021,14 @@ function loadPushTs(workspace, sessionId) {
 }
 function savePushTs(workspace, sessionId, ts) {
   try {
-    const p = path31.join(workspace, PUSH_STATE_FILE);
+    const p = path32.join(workspace, PUSH_STATE_FILE);
     let data = {};
     try {
-      if (fs31.existsSync(p)) data = JSON.parse(fs31.readFileSync(p, "utf-8"));
+      if (fs32.existsSync(p)) data = JSON.parse(fs32.readFileSync(p, "utf-8"));
     } catch {
     }
     data[sessionId] = ts;
-    fs31.writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
+    fs32.writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
   } catch (e) {
     console.warn(`[everos-ingest] save pushTs failed: ${e?.message ?? e}`);
   }
@@ -27940,11 +27953,11 @@ async function readLastConsolidatedAt(memoryDir) {
   }
 }
 async function tryAcquireConsolidationLock(memoryDir) {
-  const path43 = lockPath(memoryDir);
+  const path44 = lockPath(memoryDir);
   let mtimeMs;
   let holderPid;
   try {
-    const [s, raw] = await Promise.all([stat3(path43), readFile5(path43, "utf8")]);
+    const [s, raw] = await Promise.all([stat3(path44), readFile5(path44, "utf8")]);
     mtimeMs = s.mtimeMs;
     const parsed = parseInt(raw.trim(), 10);
     holderPid = Number.isFinite(parsed) ? parsed : void 0;
@@ -27957,10 +27970,10 @@ async function tryAcquireConsolidationLock(memoryDir) {
     }
   }
   await mkdir3(memoryDir, { recursive: true });
-  await writeFile4(path43, String(process.pid));
+  await writeFile4(path44, String(process.pid));
   let verify2;
   try {
-    verify2 = await readFile5(path43, "utf8");
+    verify2 = await readFile5(path44, "utf8");
   } catch {
     return null;
   }
@@ -27968,15 +27981,15 @@ async function tryAcquireConsolidationLock(memoryDir) {
   return mtimeMs ?? 0;
 }
 async function rollbackConsolidationLock(memoryDir, priorMtime) {
-  const path43 = lockPath(memoryDir);
+  const path44 = lockPath(memoryDir);
   try {
     if (priorMtime === 0) {
-      await unlink(path43);
+      await unlink(path44);
       return;
     }
-    await writeFile4(path43, "");
+    await writeFile4(path44, "");
     const t = priorMtime / 1e3;
-    await utimes(path43, t, t);
+    await utimes(path44, t, t);
   } catch (e) {
     console.log(`[autoDream] rollback failed: ${e.message} \u2014 next trigger delayed to minHours`);
   }
@@ -28263,7 +28276,7 @@ __export(handle_query_exports, {
 });
 import { readFileSync as readFileSync37, existsSync as existsSync31, statSync as statSync13 } from "node:fs";
 import { join as join48, resolve as resolve8 } from "node:path";
-import * as path32 from "node:path";
+import * as path33 from "node:path";
 function resolveSystemPrompt(v) {
   return typeof v === "function" ? v() : v || "";
 }
@@ -28271,18 +28284,18 @@ function resetSessionStartInjection(sessionId) {
   sessionStartDone.delete(sessionId);
 }
 function loadExternalChanRules(workspace) {
-  const path43 = join48(workspace, "prompts", "external-chan-rules.md");
-  if (externalChanRulesCache && externalChanRulesCache.path === path43) return externalChanRulesCache;
+  const path44 = join48(workspace, "prompts", "external-chan-rules.md");
+  if (externalChanRulesCache && externalChanRulesCache.path === path44) return externalChanRulesCache;
   let content = "";
-  if (existsSync31(path43)) {
+  if (existsSync31(path44)) {
     try {
-      content = readFileSync37(path43, "utf-8").trim();
+      content = readFileSync37(path44, "utf-8").trim();
     } catch (e) {
       console.warn(`[external-chan-rules] Failed to load: ${e}`);
     }
   }
-  externalChanRulesCache = { path: path43, content };
-  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path43}`);
+  externalChanRulesCache = { path: path44, content };
+  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path44}`);
   return externalChanRulesCache;
 }
 function getExternalChanRulesBlock(inboundMeta, workspace) {
@@ -29097,7 +29110,7 @@ stack: ${err.stack ?? "(none)"}`);
     }
   } catch (err) {
     try {
-      (await import("node:fs")).appendFileSync(join48(process.env.ENGINE7_STATE_DIR || path32.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7"), "logs", "autoDream-debug.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] [handle-query] autoDream trigger TRY-CATCH: ${err.message}
+      (await import("node:fs")).appendFileSync(join48(process.env.ENGINE7_STATE_DIR || path33.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7"), "logs", "autoDream-debug.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] [handle-query] autoDream trigger TRY-CATCH: ${err.message}
 stack: ${err.stack ?? "(none)"}
 `);
     } catch {
@@ -29785,8 +29798,8 @@ __export(free_tier_apply_exports, {
   isFreeTierConfig: () => isFreeTierConfig,
   resolveConfigPath: () => resolveConfigPath
 });
-import * as fs32 from "node:fs";
-import * as path33 from "node:path";
+import * as fs33 from "node:fs";
+import * as path34 from "node:path";
 function isFreeTierConfig(cfg) {
   const hasProvider = !!cfg?.models?.providers?.[FREE_TIER_PROVIDER_ID];
   const primary = String(cfg?.agents?.defaults?.model?.primary || "");
@@ -29835,18 +29848,18 @@ function applyFreeTier(cfg, opts = {}) {
   return cfg;
 }
 function resolveConfigPath(stateDir, configName) {
-  const configsDir = path33.join(stateDir, "configs");
+  const configsDir = path34.join(stateDir, "configs");
   if (configName) {
-    const p = path33.join(configsDir, configName);
-    return fs32.existsSync(p) ? p : "";
-  }
-  const main2 = path33.join(configsDir, "main7.json");
-  if (fs32.existsSync(main2)) return main2;
-  if (!fs32.existsSync(configsDir)) return "";
-  for (const f of fs32.readdirSync(configsDir).filter((x) => x.endsWith(".json"))) {
-    const full = path33.join(configsDir, f);
+    const p = path34.join(configsDir, configName);
+    return fs33.existsSync(p) ? p : "";
+  }
+  const main2 = path34.join(configsDir, "main7.json");
+  if (fs33.existsSync(main2)) return main2;
+  if (!fs33.existsSync(configsDir)) return "";
+  for (const f of fs33.readdirSync(configsDir).filter((x) => x.endsWith(".json"))) {
+    const full = path34.join(configsDir, f);
     try {
-      if (JSON.parse(fs32.readFileSync(full, "utf8")).models?.providers) return full;
+      if (JSON.parse(fs33.readFileSync(full, "utf8")).models?.providers) return full;
     } catch {
     }
   }
@@ -29855,16 +29868,16 @@ function resolveConfigPath(stateDir, configName) {
 function applyFreeTierToConfig(configPath, opts = {}) {
   let cfg;
   try {
-    cfg = JSON.parse(fs32.readFileSync(configPath, "utf8"));
+    cfg = JSON.parse(fs33.readFileSync(configPath, "utf8"));
   } catch (e) {
     throw new Error(`\u8BFB\u53D6 config \u5931\u8D25: ${configPath}\uFF08${e?.message || e}\uFF09`);
   }
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.bak-${stamp}`;
-  fs32.copyFileSync(configPath, backupPath);
+  fs33.copyFileSync(configPath, backupPath);
   applyFreeTier(cfg, opts);
   try {
-    fs32.writeFileSync(configPath, JSON.stringify(cfg, null, 2), "utf8");
+    fs33.writeFileSync(configPath, JSON.stringify(cfg, null, 2), "utf8");
   } catch (e) {
     throw new Error(`\u5199\u5165 config \u5931\u8D25: ${configPath}\uFF08${e?.message || e}\uFF09\uFF1B\u539F\u6587\u4EF6\u672A\u6539\u52A8\uFF0C\u5907\u4EFD\u5728 ${backupPath}`);
   }
@@ -29894,15 +29907,15 @@ __export(cli_doctor_exports, {
   resolveStateDirFromArgs: () => resolveStateDirFromArgs,
   runDoctor: () => runDoctor
 });
-import * as fs33 from "node:fs";
-import * as path34 from "node:path";
+import * as fs34 from "node:fs";
+import * as path35 from "node:path";
 import * as net from "node:net";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function readVersion() {
-  const here = path34.dirname(fileURLToPath6(import.meta.url));
-  for (const p of [path34.join(here, "..", "package.json"), path34.join(here, "..", "..", "package.json")]) {
+  const here = path35.dirname(fileURLToPath6(import.meta.url));
+  for (const p of [path35.join(here, "..", "package.json"), path35.join(here, "..", "..", "package.json")]) {
     try {
-      return JSON.parse(fs33.readFileSync(p, "utf8")).version || "unknown";
+      return JSON.parse(fs34.readFileSync(p, "utf8")).version || "unknown";
     } catch {
     }
   }
@@ -29932,7 +29945,7 @@ function probePort(port, timeoutMs) {
   });
 }
 async function runDoctor(stateDir, opts) {
-  const configPath = path34.join(stateDir, "configs", "main7.json");
+  const configPath = path35.join(stateDir, "configs", "main7.json");
   const report = {
     version: readVersion(),
     stateDir,
@@ -29948,10 +29961,10 @@ async function runDoctor(stateDir, opts) {
   };
   let config = null;
   try {
-    config = JSON.parse(fs33.readFileSync(configPath, "utf8"));
+    config = JSON.parse(fs34.readFileSync(configPath, "utf8"));
     report.configValid = true;
   } catch (e) {
-    report.configError = fs33.existsSync(configPath) ? `\u89E3\u6790\u5931\u8D25: ${e.message}` : "config \u4E0D\u5B58\u5728\uFF08\u5148 engine7 init\uFF09";
+    report.configError = fs34.existsSync(configPath) ? `\u89E3\u6790\u5931\u8D25: ${e.message}` : "config \u4E0D\u5B58\u5728\uFF08\u5148 engine7 init\uFF09";
   }
   if (config?.channels) {
     for (const [name, conf] of Object.entries(config.channels)) {
@@ -29959,13 +29972,13 @@ async function runDoctor(stateDir, opts) {
       report.channels.push({ name, enabled: !!c.enabled, hasCredentials: channelHasCredentials(name, c) });
     }
   }
-  const cfgBase = path34.basename(report.configPath, ".json") || "main7";
+  const cfgBase = path35.basename(report.configPath, ".json") || "main7";
   const candidates = secretsCandidates(stateDir, cfgBase);
-  const secretsFile = candidates.find((p) => fs33.existsSync(p)) || candidates[0];
+  const secretsFile = candidates.find((p) => fs34.existsSync(p)) || candidates[0];
   report.secrets.file = secretsFile;
-  if (fs33.existsSync(secretsFile)) {
+  if (fs34.existsSync(secretsFile)) {
     report.secrets.exists = true;
-    for (const line of fs33.readFileSync(secretsFile, "utf8").split("\n")) {
+    for (const line of fs34.readFileSync(secretsFile, "utf8").split("\n")) {
       const eq = line.indexOf("=");
       if (eq > 0 && !line.startsWith("#")) report.secrets.keys.push(line.slice(0, eq).trim());
     }
@@ -30005,10 +30018,10 @@ async function runDoctor(stateDir, opts) {
   report.missingEnvKeys = [...missing].sort();
   const stale = [];
   for (const rel of ["workspace/SESSION-STATE.md", "SESSION-STATE.md"]) {
-    const p = path34.join(stateDir, rel);
+    const p = path35.join(stateDir, rel);
     try {
-      if (!fs33.existsSync(p)) continue;
-      const head = fs33.readFileSync(p, "utf8").split("\n").slice(0, 10).join("\n");
+      if (!fs34.existsSync(p)) continue;
+      const head = fs34.readFileSync(p, "utf8").split("\n").slice(0, 10).join("\n");
       const m = head.match(/^#{1,3}\s*当前时间\s*$\n+\s*(\d{4}-\d{2}-\d{2})/m);
       if (!m) continue;
       const ageH = (Date.now() - (/* @__PURE__ */ new Date(`${m[1]}T00:00:00Z`)).getTime()) / 36e5;
@@ -30026,19 +30039,19 @@ function resolveStateDirFromArgs(args) {
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--state-dir" && args[i + 1]) stateDir = args[++i].trim();
   }
-  if (stateDir) return path34.resolve(stateDir);
+  if (stateDir) return path35.resolve(stateDir);
   const home = process.env.HOME || process.env.USERPROFILE || ".";
-  const cwd = path34.resolve(process.cwd());
-  if (fs33.existsSync(path34.join(cwd, "configs"))) return cwd;
-  const pointer = path34.join(home, ".engine7.json");
-  if (fs33.existsSync(pointer)) {
+  const cwd = path35.resolve(process.cwd());
+  if (fs34.existsSync(path35.join(cwd, "configs"))) return cwd;
+  const pointer = path35.join(home, ".engine7.json");
+  if (fs34.existsSync(pointer)) {
     try {
-      const ptrStateDir = JSON.parse(fs33.readFileSync(pointer, "utf8")).stateDir;
-      if (typeof ptrStateDir === "string" && ptrStateDir.trim()) return path34.resolve(ptrStateDir);
+      const ptrStateDir = JSON.parse(fs34.readFileSync(pointer, "utf8")).stateDir;
+      if (typeof ptrStateDir === "string" && ptrStateDir.trim()) return path35.resolve(ptrStateDir);
     } catch {
     }
   }
-  return path34.join(home, ".engine7");
+  return path35.join(home, ".engine7");
 }
 var init_cli_doctor = __esm({
   "src/cli-doctor.ts"() {
@@ -30051,8 +30064,8 @@ var init_cli_doctor = __esm({
 });
 
 // src/config/writer.ts
-import fs34 from "node:fs";
-import path35 from "node:path";
+import fs35 from "node:fs";
+import path36 from "node:path";
 function isNormalized(text) {
   if (text === "") return true;
   if (text.includes("\r")) return false;
@@ -30067,13 +30080,13 @@ function isNormalized(text) {
   return minIndent === 2 || minIndent === Infinity;
 }
 function rotateBaks(filePath) {
-  const dir = path35.dirname(filePath);
-  const base = path35.basename(filePath);
-  const baks = fs34.readdirSync(dir).filter((n) => n.startsWith(base + ".bak-")).sort();
+  const dir = path36.dirname(filePath);
+  const base = path36.basename(filePath);
+  const baks = fs35.readdirSync(dir).filter((n) => n.startsWith(base + ".bak-")).sort();
   while (baks.length >= KEEP_BAKS) {
     const victim = baks.shift();
     try {
-      fs34.unlinkSync(path35.join(dir, victim));
+      fs35.unlinkSync(path36.join(dir, victim));
     } catch {
     }
   }
@@ -30092,7 +30105,7 @@ function writeFailure(filePath, primary, extra) {
 function renameWithRetry(from, to) {
   for (let attempt = 1; ; attempt++) {
     try {
-      fs34.renameSync(from, to);
+      fs35.renameSync(from, to);
       return;
     } catch (err) {
       if (attempt >= RENAME_ATTEMPTS || !RETRYABLE_CODES.has(errCode(err))) throw err;
@@ -30107,32 +30120,32 @@ function commitFile(tmp, filePath) {
   } catch (primaryErr) {
     const old = `${filePath}.old`;
     try {
-      fs34.renameSync(filePath, old);
+      fs35.renameSync(filePath, old);
     } catch (err) {
       throw writeFailure(filePath, primaryErr, `\u6539\u540D .old \u5907\u4EFD\u4E5F\u5931\u8D25\uFF08${errCode(err) || "\u672A\u77E5"}\uFF09`);
     }
     try {
-      fs34.renameSync(tmp, filePath);
+      fs35.renameSync(tmp, filePath);
     } catch (err) {
       try {
-        fs34.renameSync(old, filePath);
+        fs35.renameSync(old, filePath);
       } catch {
         throw writeFailure(filePath, primaryErr, `\u65B0\u5185\u5BB9\u843D\u76D8\u4E0E\u56DE\u6EDA\u90FD\u5931\u8D25\uFF0C\u65E7\u5185\u5BB9\u7559\u5728 ${old}`);
       }
       throw writeFailure(filePath, primaryErr, `\u6362\u540D\u843D\u76D8\u5931\u8D25\uFF08${errCode(err) || "\u672A\u77E5"}\uFF09`);
     }
     try {
-      fs34.unlinkSync(old);
+      fs35.unlinkSync(old);
     } catch {
     }
   }
 }
 function writeConfigAtomic(filePath, obj) {
-  const existed = fs34.existsSync(filePath);
+  const existed = fs35.existsSync(filePath);
   let prevText = "";
   if (existed) {
     try {
-      prevText = fs34.readFileSync(filePath, "utf-8");
+      prevText = fs35.readFileSync(filePath, "utf-8");
     } catch (err) {
       throw writeFailure(filePath, err);
     }
@@ -30140,27 +30153,27 @@ function writeConfigAtomic(filePath, obj) {
   const normalized = !existed || !isNormalized(prevText);
   if (prevText) {
     try {
-      fs34.copyFileSync(filePath, `${filePath}.bak-${Date.now()}`);
+      fs35.copyFileSync(filePath, `${filePath}.bak-${Date.now()}`);
     } catch {
     }
     rotateBaks(filePath);
   }
   const content = JSON.stringify(obj, null, 2) + "\n";
-  const tmp = path35.join(path35.dirname(filePath), `.${path35.basename(filePath)}.tmp-${process.pid}`);
+  const tmp = path36.join(path36.dirname(filePath), `.${path36.basename(filePath)}.tmp-${process.pid}`);
   try {
-    const fd = fs34.openSync(tmp, "w");
+    const fd = fs35.openSync(tmp, "w");
     try {
-      fs34.writeFileSync(fd, content, "utf-8");
-      fs34.fsyncSync(fd);
+      fs35.writeFileSync(fd, content, "utf-8");
+      fs35.fsyncSync(fd);
     } finally {
-      fs34.closeSync(fd);
+      fs35.closeSync(fd);
     }
     commitFile(tmp, filePath);
   } catch (err) {
     throw err instanceof ConfigWriteError ? err : writeFailure(filePath, err);
   } finally {
     try {
-      fs34.unlinkSync(tmp);
+      fs35.unlinkSync(tmp);
     } catch {
     }
   }
@@ -30186,18 +30199,18 @@ var init_writer2 = __esm({
 });
 
 // src/config/secrets-io.ts
-import fs35 from "node:fs";
-import path36 from "node:path";
+import fs36 from "node:fs";
+import path37 from "node:path";
 function resolveSecretPath(stateDir, configName) {
   return secretsCandidates(stateDir, configName)[0];
 }
 function resolveSecretReadPath(stateDir, configName) {
-  return secretsCandidates(stateDir, configName).find((c) => fs35.existsSync(c)) ?? null;
+  return secretsCandidates(stateDir, configName).find((c) => fs36.existsSync(c)) ?? null;
 }
 function readSecretStatus(stateDir, configName, names) {
   const p = resolveSecretReadPath(stateDir, configName);
   const out = {};
-  const text = p ? fs35.readFileSync(p, "utf-8") : "";
+  const text = p ? fs36.readFileSync(p, "utf-8") : "";
   const present = /* @__PURE__ */ new Set();
   for (const line of text.split("\n")) {
     const t = line.trim();
@@ -30210,7 +30223,7 @@ function readSecretStatus(stateDir, configName, names) {
   return out;
 }
 function writeSecret(stateDir, configName, name, value) {
-  writeSecretsValue(path36.join(stateDir, "configs", `${configName}.json`), name, value);
+  writeSecretsValue(path37.join(stateDir, "configs", `${configName}.json`), name, value);
 }
 var init_secrets_io = __esm({
   "src/config/secrets-io.ts"() {
@@ -30220,8 +30233,8 @@ var init_secrets_io = __esm({
 });
 
 // src/config/migrations/index.ts
-import fs36 from "node:fs";
-import path37 from "node:path";
+import fs37 from "node:fs";
+import path38 from "node:path";
 function registerMigration(m) {
   if (REGISTRY.has(m.name)) {
     throw new Error(`[migrations] \u8FC1\u79FB "${m.name}" \u91CD\u590D\u6CE8\u518C\u2014\u2014\u540C\u540D\u4F1A\u6309 import \u987A\u5E8F\u9759\u9ED8\u8986\u76D6`);
@@ -30237,21 +30250,21 @@ async function runMigration(name, ctx) {
   return await m.run(ctx);
 }
 function rotateBaks2(filePath) {
-  const dir = path37.dirname(filePath);
-  const base = path37.basename(filePath);
-  const baks = fs36.readdirSync(dir).filter((n) => n.startsWith(base + ".bak-")).sort();
+  const dir = path38.dirname(filePath);
+  const base = path38.basename(filePath);
+  const baks = fs37.readdirSync(dir).filter((n) => n.startsWith(base + ".bak-")).sort();
   while (baks.length > KEEP_BAKS2) {
     const victim = baks.shift();
     try {
-      fs36.unlinkSync(path37.join(dir, victim));
+      fs37.unlinkSync(path38.join(dir, victim));
     } catch {
     }
   }
 }
 function backupFile(filePath) {
-  if (!fs36.existsSync(filePath)) return null;
+  if (!fs37.existsSync(filePath)) return null;
   const bak = `${filePath}.bak-${Date.now()}`;
-  fs36.copyFileSync(filePath, bak);
+  fs37.copyFileSync(filePath, bak);
   rotateBaks2(filePath);
   return bak;
 }
@@ -30265,11 +30278,11 @@ var init_migrations = __esm({
 });
 
 // src/config/migrations/persona.ts
-import fs37 from "node:fs";
-import path38 from "node:path";
+import fs38 from "node:fs";
+import path39 from "node:path";
 function readFileOrNull(p) {
   try {
-    return fs37.readFileSync(p, "utf-8");
+    return fs38.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -30289,22 +30302,22 @@ var init_persona = __esm({
       run(ctx) {
         const persona = ctx.values?.agents?.defaults?.persona;
         if (typeof persona !== "string" || !persona) return { changed: [] };
-        const dir = path38.join(ctx.workspace, "personas", persona);
-        if (!fs37.existsSync(dir)) {
+        const dir = path39.join(ctx.workspace, "personas", persona);
+        if (!fs38.existsSync(dir)) {
           return { changed: [] };
         }
         const changed = [];
         for (const name of POINTER_FILES) {
-          const src = path38.join(dir, name);
+          const src = path39.join(dir, name);
           const content = readFileOrNull(src);
           if (content === null) continue;
-          const legacy = path38.join(ctx.workspace, LEGACY_PATHS[name]);
+          const legacy = path39.join(ctx.workspace, LEGACY_PATHS[name]);
           const legacyContent = readFileOrNull(legacy);
           if (legacyContent !== null && legacyContent === content) {
-            fs37.renameSync(legacy, `${legacy}.migrated-${Date.now()}`);
+            fs38.renameSync(legacy, `${legacy}.migrated-${Date.now()}`);
             changed.push(`${LEGACY_PATHS[name]} \u2192 personas/${persona}/${name}`);
           } else if (legacyContent !== null) {
-            fs37.renameSync(legacy, `${legacy}.bak-${Date.now()}`);
+            fs38.renameSync(legacy, `${legacy}.bak-${Date.now()}`);
             changed.push(`${LEGACY_PATHS[name]} \u2192 .bak\uFF08\u5185\u5BB9\u4E0E\u6A21\u677F\u4E0D\u540C\uFF0C\u4FDD\u5B88\u4FDD\u7559\uFF09`);
           }
         }
@@ -30316,7 +30329,7 @@ var init_persona = __esm({
 });
 
 // src/config/migrations/channel-secrets.ts
-import fs38 from "node:fs";
+import fs39 from "node:fs";
 function envNameFor(dotPath) {
   const declared = getField(dotPath)?.envKey;
   if (declared) return declared;
@@ -30358,15 +30371,15 @@ function planChannelSecretMoves(config) {
 }
 function restoreEnv(envPath, before) {
   try {
-    if (before === null) fs38.unlinkSync(envPath);
-    else fs38.writeFileSync(envPath, before, "utf8");
+    if (before === null) fs39.unlinkSync(envPath);
+    else fs39.writeFileSync(envPath, before, "utf8");
   } catch {
   }
 }
 function dropBackup(backup) {
   if (backup) {
     try {
-      fs38.unlinkSync(backup);
+      fs39.unlinkSync(backup);
     } catch {
     }
   }
@@ -30375,7 +30388,7 @@ function migrateChannelSecrets(configPath, deps = {}) {
   const writeConfig = deps.writeConfig ?? ((p, obj) => writeConfigAtomic(p, obj));
   let text;
   try {
-    text = fs38.readFileSync(configPath, "utf-8");
+    text = fs39.readFileSync(configPath, "utf-8");
   } catch {
     return { changed: [], backup: null, secretsFile: null };
   }
@@ -30392,7 +30405,7 @@ function migrateChannelSecrets(configPath, deps = {}) {
   if (moves.length === 0) return { changed: [], backup: null, secretsFile: null };
   const { stateDir, configName } = resolveConfigIdentity(configPath);
   const envPath = secretsCandidates(stateDir, configName)[0];
-  const envBefore = fs38.existsSync(envPath) ? fs38.readFileSync(envPath, "utf-8") : null;
+  const envBefore = fs39.existsSync(envPath) ? fs39.readFileSync(envPath, "utf-8") : null;
   const backup = backupFile(configPath);
   try {
     for (const m of moves) writeSecret(stateDir, configName, m.envName, m.value);
@@ -30413,7 +30426,7 @@ function migrateChannelSecrets(configPath, deps = {}) {
   const problem = verify(configPath, envPath, moves);
   if (problem) {
     try {
-      if (backup) fs38.copyFileSync(backup, configPath);
+      if (backup) fs39.copyFileSync(backup, configPath);
     } catch {
     }
     restoreEnv(envPath, envBefore);
@@ -30425,7 +30438,7 @@ function migrateChannelSecrets(configPath, deps = {}) {
 function verify(configPath, envPath, moves) {
   let cfg;
   try {
-    cfg = JSON.parse(fs38.readFileSync(configPath, "utf-8"));
+    cfg = JSON.parse(fs39.readFileSync(configPath, "utf-8"));
   } catch (e) {
     return `config \u8BFB\u4E0D\u56DE\u6765\u4E86\uFF08${e?.message || String(e)}\uFF09`;
   }
@@ -30435,7 +30448,7 @@ function verify(configPath, envPath, moves) {
   }
   let env = "";
   try {
-    env = fs38.readFileSync(envPath, "utf-8");
+    env = fs39.readFileSync(envPath, "utf-8");
   } catch (e) {
     return `secrets \u6587\u4EF6\u8BFB\u4E0D\u56DE\u6765\uFF08${e?.message || String(e)}\uFF09`;
   }
@@ -30473,14 +30486,14 @@ __export(cli_config_exports, {
   isSafeConfigName: () => isSafeConfigName,
   runConfigCommand: () => runConfigCommand
 });
-import fs39 from "node:fs";
-import path39 from "node:path";
+import fs40 from "node:fs";
+import path40 from "node:path";
 function isSafeConfigName(name) {
   return /^[\w.-]+$/.test(name);
 }
 function sameDir(a, b) {
   const norm = (s) => {
-    const r = path39.resolve(s);
+    const r = path40.resolve(s);
     return process.platform === "win32" ? r.toLowerCase() : r;
   };
   return norm(a) === norm(b);
@@ -30508,7 +30521,7 @@ function parseArgs(args) {
     badArgs.push(a);
   }
   if (config) {
-    const configPath = path39.resolve(config);
+    const configPath = path40.resolve(config);
     if (!/\.json$/i.test(configPath)) {
       return {
         stateDir,
@@ -30532,9 +30545,9 @@ function parseArgs(args) {
     }
     return { stateDir: ident.stateDir, configPath, configName: ident.configName, file: file2, badArgs };
   }
-  if (!stateDir) stateDir = process.env.ENGINE_STATE_DIR || path39.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+  if (!stateDir) stateDir = process.env.ENGINE_STATE_DIR || path40.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
   const configName = CONFIG_NAME;
-  return { stateDir, configPath: path39.join(stateDir, "configs", `${configName}.json`), configName, file: file2, badArgs };
+  return { stateDir, configPath: path40.join(stateDir, "configs", `${configName}.json`), configName, file: file2, badArgs };
 }
 function emit2(obj) {
   process.stdout.write(JSON.stringify(obj) + "\n");
@@ -30572,7 +30585,7 @@ function shapeOf(v) {
 function readConfigObject(configPath) {
   let text;
   try {
-    text = fs39.readFileSync(configPath, "utf-8");
+    text = fs40.readFileSync(configPath, "utf-8");
   } catch {
     return { obj: {}, corrupt: false };
   }
@@ -30630,7 +30643,7 @@ function findMaskedCredentials(value, prefix, out) {
 function readEnvKeys(file2) {
   const out = [];
   try {
-    for (const line of fs39.readFileSync(file2, "utf-8").split("\n")) {
+    for (const line of fs40.readFileSync(file2, "utf-8").split("\n")) {
       const t = line.trim();
       if (!t || t.startsWith("#")) continue;
       const eq = t.indexOf("=");
@@ -30686,7 +30699,7 @@ async function runConfigCommand(args) {
     }
     let parsedPayload;
     try {
-      parsedPayload = JSON.parse(fs39.readFileSync(p.file, "utf-8"));
+      parsedPayload = JSON.parse(fs40.readFileSync(p.file, "utf-8"));
     } catch (e) {
       process.stderr.write(`[config] \u8BFB\u4E0D\u4E86 payload: ${e.message}
 `);
@@ -30792,7 +30805,7 @@ async function runConfigCommand(args) {
     }
     if (secretWrites.length > 0) {
       const writePath2 = resolveSecretPath(p.stateDir, p.configName);
-      const fallback = fs39.existsSync(writePath2) ? void 0 : secretsCandidates(p.stateDir, p.configName).find((c) => fs39.existsSync(c));
+      const fallback = fs40.existsSync(writePath2) ? void 0 : secretsCandidates(p.stateDir, p.configName).find((c) => fs40.existsSync(c));
       if (fallback) {
         const writing = new Set(secretWrites.map((s) => s.name));
         const others = readEnvKeys(fallback).filter((k) => !writing.has(k));
@@ -30801,11 +30814,11 @@ async function runConfigCommand(args) {
         }
       }
     }
-    if (fs39.existsSync(p.configPath) && !isNormalized(fs39.readFileSync(p.configPath, "utf-8"))) {
+    if (fs40.existsSync(p.configPath) && !isNormalized(fs40.readFileSync(p.configPath, "utf-8"))) {
       warnings.push("config \u9996\u6B21\u89C4\u8303\u5316\uFF1A\u884C\u5C3E\u7EDF\u4E00\u4E3A LF\u3001\u7F29\u8FDB\u7EDF\u4E00\u4E3A 2 \u7A7A\u683C\uFF08\u4E00\u6B21\u6027\u5927 diff\uFF09");
     }
-    const configDir = path39.dirname(p.configPath);
-    if (!fs39.existsSync(configDir)) fs39.mkdirSync(configDir, { recursive: true });
+    const configDir = path40.dirname(p.configPath);
+    if (!fs40.existsSync(configDir)) fs40.mkdirSync(configDir, { recursive: true });
     try {
       writeConfigAtomic(p.configPath, merged);
     } catch (e) {
@@ -30820,7 +30833,7 @@ async function runConfigCommand(args) {
         warnings.push(`secrets \u5199\u5165\u5931\u8D25\uFF08${s.name}\uFF09\uFF1A${e?.message || String(e)}\u2014\u2014config \u5DF2\u5199\u5165`);
       }
     }
-    const workspace = path39.join(p.stateDir, "workspace");
+    const workspace = path40.join(p.stateDir, "workspace");
     const ctx = { workspace, stateDir: p.stateDir, values: nested, all: merged, configPath: p.configPath };
     for (const dotPath of [...new Set(changed)]) {
       const migrationName = getField(dotPath)?.migration;
@@ -30909,41 +30922,41 @@ __export(cli_reconfig_exports, {
   doReconfigFeishu: () => doReconfigFeishu,
   doReconfigWechat: () => doReconfigWechat
 });
-import * as fs40 from "node:fs";
-import * as path40 from "node:path";
+import * as fs41 from "node:fs";
+import * as path41 from "node:path";
 function scanForChannelsConfig(configsDir) {
-  if (!fs40.existsSync(configsDir)) return "";
-  for (const f of fs40.readdirSync(configsDir).filter((x) => x.endsWith(".json"))) {
-    const full = path40.join(configsDir, f);
+  if (!fs41.existsSync(configsDir)) return "";
+  for (const f of fs41.readdirSync(configsDir).filter((x) => x.endsWith(".json"))) {
+    const full = path41.join(configsDir, f);
     try {
-      if (JSON.parse(fs40.readFileSync(full, "utf8")).channels) return full;
+      if (JSON.parse(fs41.readFileSync(full, "utf8")).channels) return full;
     } catch {
     }
   }
   return "";
 }
 function findFeishuConfigFile(stateDir, configName) {
-  const configsDir = path40.join(stateDir, "configs");
+  const configsDir = path41.join(stateDir, "configs");
   if (configName) {
-    const p = path40.join(configsDir, configName);
-    if (fs40.existsSync(p)) return p;
+    const p = path41.join(configsDir, configName);
+    if (fs41.existsSync(p)) return p;
   }
   return scanForChannelsConfig(configsDir);
 }
 function findWechatConfigFile(stateDir, configName) {
-  const configsDir = path40.join(stateDir, "configs");
+  const configsDir = path41.join(stateDir, "configs");
   if (configName) {
-    const p = path40.join(configsDir, configName);
-    return fs40.existsSync(p) ? p : "";
+    const p = path41.join(configsDir, configName);
+    return fs41.existsSync(p) ? p : "";
   }
   const scanned = scanForChannelsConfig(configsDir);
   if (scanned) return scanned;
-  if (fs40.existsSync(configsDir)) {
-    const candidates = fs40.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
+  if (fs41.existsSync(configsDir)) {
+    const candidates = fs41.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
     if (candidates.length) {
-      const first = path40.join(configsDir, candidates[0]);
+      const first = path41.join(configsDir, candidates[0]);
       try {
-        JSON.parse(fs40.readFileSync(first, "utf8"));
+        JSON.parse(fs41.readFileSync(first, "utf8"));
         return first;
       } catch {
       }
@@ -30982,11 +30995,11 @@ async function doReconfigFeishu(opts) {
     return 2;
   }
   const configFile = findFeishuConfigFile(stateDir, configName);
-  if (configFile && fs40.existsSync(configFile)) {
+  if (configFile && fs41.existsSync(configFile)) {
     if (events) emit3?.({ event: "progress", step: "write_config" });
     let j;
     try {
-      j = JSON.parse(fs40.readFileSync(configFile, "utf8"));
+      j = JSON.parse(fs41.readFileSync(configFile, "utf8"));
     } catch (err) {
       if (events) emit3?.({ event: "error", message: `\u8BFB\u53D6 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09` });
       else console.error(`\u274C \u8BFB\u53D6 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09`);
@@ -31004,7 +31017,7 @@ async function doReconfigFeishu(opts) {
     }
     j.channels.feishu = { enabled: true, appId: result.appId, appSecret: secretRef(feishuSecretEnv, result.appSecret), connectionMode: "websocket", dmPolicy: "pairing", groupPolicy: "open" };
     try {
-      fs40.writeFileSync(configFile, JSON.stringify(j, null, 2), "utf8");
+      fs41.writeFileSync(configFile, JSON.stringify(j, null, 2), "utf8");
     } catch (err) {
       if (events) emit3?.({ event: "error", message: `\u5199\u5165 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09` });
       else console.error(`\u274C \u5199\u5165 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09`);
@@ -31037,7 +31050,7 @@ async function doReconfigWechat(opts) {
     return 2;
   }
   const configFile = findWechatConfigFile(stateDir, configName);
-  if (!configFile || !fs40.existsSync(configFile)) {
+  if (!configFile || !fs41.existsSync(configFile)) {
     console.log("\n\u26A0\uFE0F \u6CA1\u627E\u5230 config \u6587\u4EF6\uFF0C\u8BF7\u624B\u52A8\u628A\u4EE5\u4E0B\u6BB5\u52A0\u8FDB\u4F60\u7684 config \u7684 channels \u91CC\uFF1A");
     console.log(JSON.stringify({ wechat: { enabled: true, token: cred.token, accountId: cred.accountId, dmPolicy: "pairing", group: { policy: "disabled" } } }, null, 2));
     if (events) emit3?.({ event: "done", channel: "wechat", detail: cred.accountId, restart_required: true });
@@ -31046,7 +31059,7 @@ async function doReconfigWechat(opts) {
   if (events) emit3?.({ event: "progress", step: "write_config" });
   let j;
   try {
-    j = JSON.parse(fs40.readFileSync(configFile, "utf8"));
+    j = JSON.parse(fs41.readFileSync(configFile, "utf8"));
   } catch (err) {
     if (events) emit3?.({ event: "error", message: `\u8BFB\u53D6 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09` });
     else console.error(`\u274C \u8BFB\u53D6 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09`);
@@ -31064,7 +31077,7 @@ async function doReconfigWechat(opts) {
   }
   j.channels.wechat = { enabled: true, token: secretRef(wechatSecretEnv, cred.token), accountId: cred.accountId, dmPolicy: "pairing", group: { policy: "disabled" } };
   try {
-    fs40.writeFileSync(configFile, JSON.stringify(j, null, 2), "utf8");
+    fs41.writeFileSync(configFile, JSON.stringify(j, null, 2), "utf8");
   } catch (err) {
     if (events) emit3?.({ event: "error", message: `\u5199\u5165 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09` });
     else console.error(`\u274C \u5199\u5165 config \u5931\u8D25: ${configFile}\uFF08${err?.message || err}\uFF09`);
@@ -31101,20 +31114,20 @@ __export(cli_travel_exports, {
   resolveArchiveForTest: () => resolveArchiveForTest,
   saveTravelConfig: () => saveTravelConfig
 });
-import * as path41 from "node:path";
-import * as fs41 from "node:fs";
+import * as path42 from "node:path";
+import * as fs42 from "node:fs";
 import * as os6 from "node:os";
-import { execSync as execSync2 } from "node:child_process";
+import { execSync as execSync3 } from "node:child_process";
 function loadTravelConfig() {
   try {
-    if (!fs41.existsSync(CONFIG_PATH)) return null;
-    return JSON.parse(fs41.readFileSync(CONFIG_PATH, "utf-8"));
+    if (!fs42.existsSync(CONFIG_PATH)) return null;
+    return JSON.parse(fs42.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveTravelConfig(cfg) {
-  fs41.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+  fs42.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
 }
 function sanitizeContent(content, dirs) {
   let result = content;
@@ -31139,7 +31152,7 @@ function restoreContent(content, dirs) {
   return result;
 }
 function isTextFile(filePath) {
-  const ext = path41.extname(filePath).toLowerCase();
+  const ext = path42.extname(filePath).toLowerCase();
   return TEXT_EXTENSIONS.has(ext);
 }
 function shouldExclude(name) {
@@ -31154,14 +31167,14 @@ function shouldExclude(name) {
 }
 function collectFiles(rootDir, includeSet, optionalSet) {
   const files = [];
-  const entries2 = fs41.readdirSync(rootDir, { withFileTypes: true });
+  const entries2 = fs42.readdirSync(rootDir, { withFileTypes: true });
   for (const entry of entries2) {
     if (shouldExclude(entry.name)) continue;
-    const fullPath = path41.join(rootDir, entry.name);
-    const realPath = fs41.realpathSync(fullPath);
+    const fullPath = path42.join(rootDir, entry.name);
+    const realPath = fs42.realpathSync(fullPath);
     if (realPath !== fullPath) {
       try {
-        const lstat = fs41.lstatSync(fullPath);
+        const lstat = fs42.lstatSync(fullPath);
         if (lstat.isSymbolicLink()) {
           continue;
         }
@@ -31182,12 +31195,12 @@ function collectFiles(rootDir, includeSet, optionalSet) {
 function collectAllFiles(dir) {
   const files = [];
   try {
-    const entries2 = fs41.readdirSync(dir, { withFileTypes: true });
+    const entries2 = fs42.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries2) {
       if (shouldExclude(entry.name)) continue;
-      const fullPath = path41.join(dir, entry.name);
+      const fullPath = path42.join(dir, entry.name);
       try {
-        if (fs41.lstatSync(fullPath).isSymbolicLink()) continue;
+        if (fs42.lstatSync(fullPath).isSymbolicLink()) continue;
       } catch {
       }
       if (entry.isDirectory()) {
@@ -31202,16 +31215,16 @@ function collectAllFiles(dir) {
 }
 function readMainEngineUuid(agentsDir) {
   try {
-    const platformMapPath = path41.join(agentsDir, "main", "sessions", "platform-map.json");
-    const indexMapPath = path41.join(agentsDir, "main", "sessions", "session-index.json");
-    if (!fs41.existsSync(platformMapPath) || !fs41.existsSync(indexMapPath)) return null;
-    const platformMap = JSON.parse(fs41.readFileSync(platformMapPath, "utf-8"));
+    const platformMapPath = path42.join(agentsDir, "main", "sessions", "platform-map.json");
+    const indexMapPath = path42.join(agentsDir, "main", "sessions", "session-index.json");
+    if (!fs42.existsSync(platformMapPath) || !fs42.existsSync(indexMapPath)) return null;
+    const platformMap = JSON.parse(fs42.readFileSync(platformMapPath, "utf-8"));
     const mainPlatformId = platformMap["scope:main"] || platformMap["main"];
     if (!mainPlatformId) return null;
-    const indexMap = JSON.parse(fs41.readFileSync(indexMapPath, "utf-8"));
+    const indexMap = JSON.parse(fs42.readFileSync(indexMapPath, "utf-8"));
     const entry = indexMap[mainPlatformId];
     if (!entry || !entry.file) return null;
-    const basename10 = path41.basename(entry.file).replace(/\.jsonl$/, "");
+    const basename10 = path42.basename(entry.file).replace(/\.jsonl$/, "");
     return basename10;
   } catch {
     return null;
@@ -31219,13 +31232,13 @@ function readMainEngineUuid(agentsDir) {
 }
 function collectRecentSessions(agentsDir, _days = 7) {
   const files = [];
-  if (!fs41.existsSync(agentsDir)) return files;
+  if (!fs42.existsSync(agentsDir)) return files;
   const sessionGroups = /* @__PURE__ */ new Map();
   function scanSessionsDir(dir) {
     try {
-      const entries2 = fs41.readdirSync(dir, { withFileTypes: true });
+      const entries2 = fs42.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries2) {
-        const fullPath = path41.join(dir, entry.name);
+        const fullPath = path42.join(dir, entry.name);
         if (entry.isDirectory()) {
           scanSessionsDir(fullPath);
           continue;
@@ -31249,7 +31262,7 @@ function collectRecentSessions(agentsDir, _days = 7) {
         if (entry.name.endsWith(".jsonl")) {
           group.jsonl = fullPath;
         } else {
-          const stat4 = fs41.statSync(fullPath);
+          const stat4 = fs42.statSync(fullPath);
           group.archived.push({ file: fullPath, mtime: stat4.mtimeMs });
         }
       }
@@ -31268,21 +31281,21 @@ function collectRecentSessions(agentsDir, _days = 7) {
 }
 function collectExportFileSet(stateDir, workspace) {
   const wsFiles = collectFiles(workspace, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL);
-  const sessionFiles = collectRecentSessions(path41.join(stateDir, "agents"), 7);
-  const configsDir = path41.join(stateDir, "configs");
+  const sessionFiles = collectRecentSessions(path42.join(stateDir, "agents"), 7);
+  const configsDir = path42.join(stateDir, "configs");
   const configFiles = [];
-  if (fs41.existsSync(configsDir)) {
+  if (fs42.existsSync(configsDir)) {
     for (const f of collectAllFiles(configsDir)) {
-      if (shouldExclude(path41.basename(f))) continue;
+      if (shouldExclude(path42.basename(f))) continue;
       configFiles.push(f);
     }
   }
   const EVEROS_SKIP = /* @__PURE__ */ new Set([".tmp", ".lock", "import.log", "import_progress.json"]);
-  const everosDir = path41.join(stateDir, ".everos");
+  const everosDir = path42.join(stateDir, ".everos");
   const everosFiles = [];
-  if (fs41.existsSync(everosDir)) {
+  if (fs42.existsSync(everosDir)) {
     for (const f of collectAllFiles(everosDir)) {
-      if (EVEROS_SKIP.has(path41.basename(f))) continue;
+      if (EVEROS_SKIP.has(path42.basename(f))) continue;
       everosFiles.push(f);
     }
   }
@@ -31290,13 +31303,13 @@ function collectExportFileSet(stateDir, workspace) {
 }
 async function doExport(opts) {
   const { agentName, stateDir, note, dryRun: dryRun2 } = opts;
-  const workspace = (opts.workspace || path41.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
-  const engineHome = path41.join(os6.homedir(), ".engine7").replace(/[/\\]+$/, "");
+  const workspace = (opts.workspace || path42.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
+  const engineHome = path42.join(os6.homedir(), ".engine7").replace(/[/\\]+$/, "");
   console.log(`\u{1F4E6} engine7 export`);
   console.log(`   agent: ${agentName}`);
   console.log(`   state: ${stateDir}`);
   console.log(`   workspace: ${workspace}`);
-  if (!fs41.existsSync(workspace)) {
+  if (!fs42.existsSync(workspace)) {
     console.error(`\u274C workspace \u4E0D\u5B58\u5728: ${workspace}`);
     process.exit(1);
   }
@@ -31305,16 +31318,16 @@ async function doExport(opts) {
   console.log(`   workspace \u6587\u4EF6: ${wsFiles.length}`);
   console.log(`   session jsonl: ${sessionFiles.length} (\u6700\u8FD17\u5929)`);
   console.log(`   configs: ${configFiles.length}`);
-  console.log(`   everos: ${everosFiles.length} (${(everosFiles.reduce((s, f) => s + fs41.statSync(f).size, 0) / 1024 / 1024).toFixed(1)} MB)`);
+  console.log(`   everos: ${everosFiles.length} (${(everosFiles.reduce((s, f) => s + fs42.statSync(f).size, 0) / 1024 / 1024).toFixed(1)} MB)`);
   if (dryRun2) {
     console.log(`
 [DRY RUN] \u4F1A\u6253\u5305\u4EE5\u4E0B\u6587\u4EF6:`);
-    wsFiles.slice(0, 20).forEach((f) => console.log(`   ${path41.relative(workspace, f)}`));
+    wsFiles.slice(0, 20).forEach((f) => console.log(`   ${path42.relative(workspace, f)}`));
     if (wsFiles.length > 20) console.log(`   ... \u8FD8\u6709 ${wsFiles.length - 20} \u4E2A\u6587\u4EF6`);
     if (everosFiles.length > 0) {
       console.log(`
 [DRY RUN] everos (${everosFiles.length} \u6587\u4EF6):`);
-      everosFiles.slice(0, 10).forEach((f) => console.log(`   ${path41.relative(stateDir, f)}`));
+      everosFiles.slice(0, 10).forEach((f) => console.log(`   ${path42.relative(stateDir, f)}`));
       if (everosFiles.length > 10) console.log(`   ... \u8FD8\u6709 ${everosFiles.length - 10} \u4E2A\u6587\u4EF6`);
     }
     console.log(`
@@ -31322,46 +31335,46 @@ async function doExport(opts) {
     return;
   }
   const version = formatLog().replace(/[-: ]/g, "").slice(0, 12).replace(/(d{8})(d{4})/, "$1-$2");
-  const tmpDir = path41.join(os6.tmpdir(), `engine7-export-${agentName}-${version}`);
-  fs41.mkdirSync(tmpDir, { recursive: true });
-  const stagingDir = path41.join(tmpDir, agentName);
-  fs41.mkdirSync(stagingDir, { recursive: true });
+  const tmpDir = path42.join(os6.tmpdir(), `engine7-export-${agentName}-${version}`);
+  fs42.mkdirSync(tmpDir, { recursive: true });
+  const stagingDir = path42.join(tmpDir, agentName);
+  fs42.mkdirSync(stagingDir, { recursive: true });
   let fileCount = 0;
   let totalSize = 0;
   let copyFail = 0;
   const copyOne = (srcFile, relRoot, destRoot) => {
-    const relPath = path41.relative(relRoot, srcFile);
-    const destFile = path41.join(destRoot, relPath);
-    fs41.mkdirSync(path41.dirname(destFile), { recursive: true });
+    const relPath = path42.relative(relRoot, srcFile);
+    const destFile = path42.join(destRoot, relPath);
+    fs42.mkdirSync(path42.dirname(destFile), { recursive: true });
     try {
       if (isTextFile(srcFile)) {
-        const content = fs41.readFileSync(srcFile, "utf-8");
-        fs41.writeFileSync(destFile, sanitizeContent(content, dirs));
+        const content = fs42.readFileSync(srcFile, "utf-8");
+        fs42.writeFileSync(destFile, sanitizeContent(content, dirs));
       } else {
-        fs41.copyFileSync(srcFile, destFile);
+        fs42.copyFileSync(srcFile, destFile);
       }
       fileCount++;
-      totalSize += fs41.statSync(srcFile).size;
+      totalSize += fs42.statSync(srcFile).size;
     } catch (e) {
       copyFail++;
       console.warn(`   \u26A0\uFE0F \u62F7\u8D1D\u5931\u8D25: ${relPath} (${e.code || e.message})`);
     }
   };
-  for (const srcFile of wsFiles) copyOne(srcFile, workspace, path41.join(stagingDir, "workspace"));
+  for (const srcFile of wsFiles) copyOne(srcFile, workspace, path42.join(stagingDir, "workspace"));
   for (const srcFile of sessionFiles) {
-    const relPath = path41.relative(stateDir, srcFile);
-    const destFile = path41.join(stagingDir, relPath);
-    fs41.mkdirSync(path41.dirname(destFile), { recursive: true });
+    const relPath = path42.relative(stateDir, srcFile);
+    const destFile = path42.join(stagingDir, relPath);
+    fs42.mkdirSync(path42.dirname(destFile), { recursive: true });
     try {
-      let content = fs41.readFileSync(srcFile, "utf-8");
+      let content = fs42.readFileSync(srcFile, "utf-8");
       content = sanitizeContent(content, dirs);
-      const baseName = path41.basename(srcFile);
+      const baseName = path42.basename(srcFile);
       if (baseName === "session-index.json" || baseName === "platform-map.json") {
         content = content.split("\\\\").join("/");
       }
-      fs41.writeFileSync(destFile, content);
+      fs42.writeFileSync(destFile, content);
       fileCount++;
-      totalSize += fs41.statSync(srcFile).size;
+      totalSize += fs42.statSync(srcFile).size;
     } catch (e) {
       copyFail++;
       console.warn(`   \u26A0\uFE0F \u62F7\u8D1D\u5931\u8D25: ${relPath} (${e.code || e.message})`);
@@ -31383,13 +31396,13 @@ async function doExport(opts) {
     totalSize,
     note
   };
-  fs41.writeFileSync(path41.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  const archiveFile = path41.join(tmpDir, `${agentName}-${version}.tar.gz`);
+  fs42.writeFileSync(path42.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  const archiveFile = path42.join(tmpDir, `${agentName}-${version}.tar.gz`);
   console.log(`
 \u{1F5DC}\uFE0F  \u6253\u5305\u4E2D...`);
   const tarExe = process.platform === "win32" ? "C:\\Windows\\System32\\tar.exe" : "tar";
-  execSync2(`"${tarExe}" -czf "${archiveFile}" -C "${tmpDir}" ${agentName}`, { stdio: "pipe" });
-  const archiveSize = fs41.statSync(archiveFile).size;
+  execSync3(`"${tarExe}" -czf "${archiveFile}" -C "${tmpDir}" ${agentName}`, { stdio: "pipe" });
+  const archiveSize = fs42.statSync(archiveFile).size;
   console.log(`\u2705 \u6253\u5305\u5B8C\u6210: ${archiveFile} (${(archiveSize / 1024 / 1024).toFixed(1)} MB, ${fileCount} \u6587\u4EF6${copyFail ? `, \u5931\u8D25 ${copyFail}` : ""})`);
   const cfg = loadTravelConfig();
   if (!cfg || !cfg.githubToken) {
@@ -31415,12 +31428,12 @@ function parseImportArgs(args) {
     else if (args[i] === "--dry-run") dryRun2 = true;
   }
   if (!stateDir) throw new Error("import \u9700\u8981 --state-dir <path>");
-  if (!agentName) agentName = path41.basename(stateDir);
+  if (!agentName) agentName = path42.basename(stateDir);
   return { stateDir, agentName, version, archiveFile, dryRun: dryRun2 };
 }
 async function resolveArchiveForTest(opts) {
   if (opts.archiveFile) {
-    if (!fs41.existsSync(opts.archiveFile)) {
+    if (!fs42.existsSync(opts.archiveFile)) {
       throw new Error(`\u672C\u5730\u5305\u4E0D\u5B58\u5728: ${opts.archiveFile}`);
     }
     return opts.archiveFile;
@@ -31432,8 +31445,8 @@ async function doImport(opts) {
   console.log(`\u{1F4E5} engine7 import`);
   console.log(`   agent: ${agentName}`);
   console.log(`   target: ${stateDir}`);
-  const tmpDir = path41.join(os6.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
-  fs41.mkdirSync(tmpDir, { recursive: true });
+  const tmpDir = path42.join(os6.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
+  fs42.mkdirSync(tmpDir, { recursive: true });
   const resolved = await resolveArchiveForTest({
     archiveFile: archiveFile || "",
     tmpDir,
@@ -31457,100 +31470,100 @@ async function doImport(opts) {
   }
   console.log(`\u{1F4C2} \u89E3\u5305\u4E2D...`);
   const tarExe = process.platform === "win32" ? "C:\\Windows\\System32\\tar.exe" : "tar";
-  execSync2(`"${tarExe}" -xzf "${finalArchive}" -C "${tmpDir}"`, { stdio: "pipe" });
-  const stagingDir = path41.join(tmpDir, agentName);
-  const manifestPath = path41.join(stagingDir, "manifest.json");
-  if (!fs41.existsSync(manifestPath)) {
+  execSync3(`"${tarExe}" -xzf "${finalArchive}" -C "${tmpDir}"`, { stdio: "pipe" });
+  const stagingDir = path42.join(tmpDir, agentName);
+  const manifestPath = path42.join(stagingDir, "manifest.json");
+  if (!fs42.existsSync(manifestPath)) {
     console.error(`\u274C manifest.json \u4E0D\u5B58\u5728\uFF0C\u6587\u4EF6\u53EF\u80FD\u635F\u574F`);
     process.exit(1);
   }
-  const manifest = JSON.parse(fs41.readFileSync(manifestPath, "utf-8"));
-  const workspace = path41.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
-  const engineHome = path41.join(os6.homedir(), ".engine7").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const manifest = JSON.parse(fs42.readFileSync(manifestPath, "utf-8"));
+  const workspace = path42.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const engineHome = path42.join(os6.homedir(), ".engine7").replace(/\\/g, "/").replace(/[/\\]+$/, "");
   const dirs = { workspace, stateDir: stateDir.replace(/\\/g, "/").replace(/[/\\]+$/, ""), engineHome };
   console.log(`   \u7248\u672C: ${manifest.version}`);
   console.log(`   \u521B\u5EFA: ${manifest.createdAt}`);
   console.log(`   \u6587\u4EF6\u6570: ${manifest.fileCount}`);
-  const wsStaging = path41.join(stagingDir, "workspace");
+  const wsStaging = path42.join(stagingDir, "workspace");
   let restoredCount = 0;
   let skipCount = 0;
-  if (fs41.existsSync(wsStaging)) {
+  if (fs42.existsSync(wsStaging)) {
     const allFiles = collectAllFiles(wsStaging);
     for (const srcFile of allFiles) {
-      const relPath = path41.relative(wsStaging, srcFile);
-      const destFile = path41.join(workspace, relPath);
-      fs41.mkdirSync(path41.dirname(destFile), { recursive: true });
+      const relPath = path42.relative(wsStaging, srcFile);
+      const destFile = path42.join(workspace, relPath);
+      fs42.mkdirSync(path42.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs41.readFileSync(srcFile, "utf-8");
-          fs41.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs42.readFileSync(srcFile, "utf-8");
+          fs42.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs41.copyFileSync(srcFile, destFile);
+          fs42.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path41.relative(wsStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path42.relative(wsStaging, srcFile)} (${e.code || e.message})`);
       }
     }
   }
-  const agentsStaging = path41.join(stagingDir, "agents");
-  if (fs41.existsSync(agentsStaging)) {
+  const agentsStaging = path42.join(stagingDir, "agents");
+  if (fs42.existsSync(agentsStaging)) {
     const sessionFiles = collectAllFiles(agentsStaging);
     for (const srcFile of sessionFiles) {
-      const relPath = path41.relative(stagingDir, srcFile);
-      const destFile = path41.join(stateDir, relPath);
-      fs41.mkdirSync(path41.dirname(destFile), { recursive: true });
-      const content = fs41.readFileSync(srcFile, "utf-8");
-      fs41.writeFileSync(destFile, restoreContent(content, dirs));
+      const relPath = path42.relative(stagingDir, srcFile);
+      const destFile = path42.join(stateDir, relPath);
+      fs42.mkdirSync(path42.dirname(destFile), { recursive: true });
+      const content = fs42.readFileSync(srcFile, "utf-8");
+      fs42.writeFileSync(destFile, restoreContent(content, dirs));
       restoredCount++;
     }
   }
-  const configsStaging = path41.join(stagingDir, "configs");
-  if (fs41.existsSync(configsStaging)) {
+  const configsStaging = path42.join(stagingDir, "configs");
+  if (fs42.existsSync(configsStaging)) {
     const cfgFiles = collectAllFiles(configsStaging);
     for (const srcFile of cfgFiles) {
-      const relPath = path41.relative(stagingDir, srcFile);
-      const destFile = path41.join(stateDir, relPath);
-      fs41.mkdirSync(path41.dirname(destFile), { recursive: true });
+      const relPath = path42.relative(stagingDir, srcFile);
+      const destFile = path42.join(stateDir, relPath);
+      fs42.mkdirSync(path42.dirname(destFile), { recursive: true });
       if (isTextFile(srcFile)) {
-        const content = fs41.readFileSync(srcFile, "utf-8");
-        fs41.writeFileSync(destFile, restoreContent(content, dirs));
+        const content = fs42.readFileSync(srcFile, "utf-8");
+        fs42.writeFileSync(destFile, restoreContent(content, dirs));
       } else {
-        fs41.copyFileSync(srcFile, destFile);
+        fs42.copyFileSync(srcFile, destFile);
       }
       restoredCount++;
     }
   }
-  const everosStaging = path41.join(stagingDir, ".everos");
-  if (fs41.existsSync(everosStaging)) {
+  const everosStaging = path42.join(stagingDir, ".everos");
+  if (fs42.existsSync(everosStaging)) {
     const everosFiles = collectAllFiles(everosStaging);
     for (const srcFile of everosFiles) {
-      const relPath = path41.relative(stagingDir, srcFile);
-      const destFile = path41.join(stateDir, relPath);
-      fs41.mkdirSync(path41.dirname(destFile), { recursive: true });
+      const relPath = path42.relative(stagingDir, srcFile);
+      const destFile = path42.join(stateDir, relPath);
+      fs42.mkdirSync(path42.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs41.readFileSync(srcFile, "utf-8");
-          fs41.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs42.readFileSync(srcFile, "utf-8");
+          fs42.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs41.copyFileSync(srcFile, destFile);
+          fs42.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path41.relative(everosStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path42.relative(everosStaging, srcFile)} (${e.code || e.message})`);
       }
     }
     console.log(`   everos: ${everosFiles.length} \u6587\u4EF6\u5DF2\u6062\u590D`);
   }
   console.log(`\u2705 \u6062\u590D\u5B8C\u6210: ${restoredCount} \u6587\u4EF6 \u2192 ${stateDir}${skipCount ? ` (\u8DF3\u8FC7 ${skipCount})` : ""}`);
   const platformConfigName = process.platform === "darwin" ? "xiaoke-mac.json" : "xiaoke-win.json";
-  const restoredConfigPath = path41.join(stateDir, "configs", platformConfigName);
-  const configToUse = fs41.existsSync(restoredConfigPath) ? restoredConfigPath : path41.join(stateDir, "configs", "xiaoke.json");
+  const restoredConfigPath = path42.join(stateDir, "configs", platformConfigName);
+  const configToUse = fs42.existsSync(restoredConfigPath) ? restoredConfigPath : path42.join(stateDir, "configs", "xiaoke.json");
   console.log(`
 \u{1F4A1} \u4E0B\u4E00\u6B65: engine7 start --config "${configToUse}"`);
-  fs41.rmSync(tmpDir, { recursive: true, force: true });
+  fs42.rmSync(tmpDir, { recursive: true, force: true });
 }
 async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
   const repo = `${cfg.githubOwner}/${cfg.repoName}`;
@@ -31580,8 +31593,8 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     }
     const release2 = await createRes.json();
     const uploadUrl = release2.upload_url.replace("{?name,label}", "");
-    const fileBuffer = fs41.readFileSync(archiveFile);
-    const fileName = path41.basename(archiveFile);
+    const fileBuffer = fs42.readFileSync(archiveFile);
+    const fileName = path42.basename(archiveFile);
     const uploadRes = await fetch(`${uploadUrl}?name=${fileName}`, {
       method: "POST",
       headers: {
@@ -31604,7 +31617,7 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     throw e;
   }
   try {
-    fs41.rmSync(path41.dirname(archiveFile), { recursive: true, force: true });
+    fs42.rmSync(path42.dirname(archiveFile), { recursive: true, force: true });
   } catch {
   }
 }
@@ -31636,8 +31649,8 @@ async function downloadFromGitHub(cfg, agentName, version, destDir) {
     throw new Error(`\u4E0B\u8F7D asset \u5931\u8D25: ${downloadRes.status}`);
   }
   const buffer = Buffer.from(await downloadRes.arrayBuffer());
-  const archiveFile = path41.join(destDir, asset.name);
-  fs41.writeFileSync(archiveFile, buffer);
+  const archiveFile = path42.join(destDir, asset.name);
+  fs42.writeFileSync(archiveFile, buffer);
   return archiveFile;
 }
 async function getLatestReleaseTag(cfg, agentName) {
@@ -31663,7 +31676,7 @@ var init_cli_travel = __esm({
   "src/cli-travel.ts"() {
     "use strict";
     init_clock();
-    CONFIG_PATH = path41.join(os6.homedir(), ".engine7-travel.json");
+    CONFIG_PATH = path42.join(os6.homedir(), ".engine7-travel.json");
     PATH_PLACEHOLDERS = [
       { placeholder: "{{WORKSPACE}}", getOriginal: (d) => d.workspace },
       { placeholder: "{{ENGINE_HOME}}", getOriginal: (d) => d.engineHome },
@@ -31736,8 +31749,8 @@ var init_cli_travel = __esm({
 });
 
 // src/cli-init.ts
-import * as path42 from "node:path";
-import * as fs42 from "node:fs";
+import * as path43 from "node:path";
+import * as fs43 from "node:fs";
 
 // src/cli-service.ts
 function parseServiceArgs(args) {
@@ -31892,6 +31905,136 @@ function buildConfigValuesFromAnswers(stateDir, a, existing = {}) {
 
 // src/cli-init.ts
 init_secrets_env();
+
+// src/pid-lock.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { execSync } from "node:child_process";
+function enginePidFile(stateDir) {
+  return path3.join(stateDir, ".engine.pid");
+}
+function isEngineImage(text) {
+  return /node|engine7|electron/i.test(text);
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function probeImage(pid) {
+  try {
+    if (process.platform === "win32") {
+      return execSync(`tasklist /FI "PID eq ${pid}" /NH /FO CSV`, {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+    }
+    if (process.platform === "darwin") {
+      return execSync(`ps -p ${pid} -o comm=`, {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+    }
+    return fs3.readFileSync(`/proc/${pid}/comm`, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function probeEngineImage(pid) {
+  return isEngineImage(probeImage(pid) ?? "");
+}
+function isCliWrapperImage(text) {
+  return /node/i.test(text);
+}
+function probeIsCliWrapper(pid) {
+  return isCliWrapperImage(probeImage(pid) ?? "");
+}
+function readOwnEnginePidText(stateDir) {
+  try {
+    return fs3.readFileSync(enginePidFile(stateDir), "utf-8");
+  } catch (err) {
+    if (err?.code !== "ENOENT") console.warn(`[pid-lock] read lock failed: ${err.message}`);
+    return null;
+  }
+}
+function pickOwnEnginePid(probe) {
+  const pid = parseInt((probe.pidFileContent ?? "").trim(), 10);
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  if (pid === probe.myPid) return null;
+  if (!probe.isAlive(pid)) return null;
+  if (!probe.isEngineImage(pid)) return null;
+  return pid;
+}
+function ownEnginePid(stateDir, myPid = process.pid) {
+  return pickOwnEnginePid({
+    pidFileContent: readOwnEnginePidText(stateDir),
+    myPid,
+    isAlive: isPidAlive,
+    isEngineImage: probeEngineImage
+  });
+}
+function killOwnEngineForStateDir(stateDir) {
+  const pid = ownEnginePid(stateDir);
+  if (pid === null) return null;
+  killTree(pid);
+  return pid;
+}
+async function waitForPidGone(pid, timeoutMs = 5e3) {
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    if (!isPidAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return !isPidAlive(pid);
+}
+function pickParentPid(procStatus, psOutput) {
+  const fromProc = Number(/PPid:\s*(\d+)/.exec(procStatus ?? "")?.[1] ?? NaN);
+  if (Number.isInteger(fromProc) && fromProc > 0) return fromProc;
+  const fromPs = Number((psOutput ?? "").trim());
+  return Number.isInteger(fromPs) && fromPs > 0 ? fromPs : 0;
+}
+function killTree(pid) {
+  try {
+    if (process.platform === "win32") {
+      execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore", timeout: 8e3 });
+      try {
+        const parentPid = parseInt(execSync(`wmic process where ProcessId=${pid} get ParentProcessId /value`, { encoding: "utf-8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"] }).match(/ParentProcessId=(\d+)/)?.[1] ?? "0", 10);
+        if (parentPid && parentPid !== process.ppid && probeIsCliWrapper(parentPid)) {
+          execSync(`taskkill /PID ${parentPid} /F`, { stdio: "ignore", timeout: 3e3 });
+        }
+      } catch {
+      }
+    } else {
+      process.kill(pid, "SIGKILL");
+      let parentPid = 0;
+      try {
+        parentPid = pickParentPid(fs3.readFileSync(`/proc/${pid}/status`, "utf-8"), null);
+      } catch {
+      }
+      if (!parentPid) {
+        try {
+          parentPid = pickParentPid(null, execSync(`ps -p ${pid} -o ppid=`, { encoding: "utf-8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"] }));
+        } catch {
+        }
+      }
+      if (parentPid > 1 && parentPid !== process.ppid && probeIsCliWrapper(parentPid)) {
+        try {
+          process.kill(parentPid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+  } catch (err) {
+    console.warn(`[pid-lock] kill ${pid} failed: ${err.message}`);
+  }
+}
+
+// src/cli-init.ts
 init_clock();
 init_cli_init_config();
 init_registry();
@@ -31910,7 +32053,7 @@ function describeCurrentToken(v) {
   return /^(?:env:|{{\s*)[A-Z0-9_]+/.test(v) ? "\u5DF2\u5B58\u5728 secrets \u4E2D" : v.slice(0, 12) + "...";
 }
 var __filename2 = fileURLToPath7(import.meta.url);
-var __dirname = path42.dirname(__filename2);
+var __dirname = path43.dirname(__filename2);
 function parseArgs2() {
   const args = process.argv.slice(2);
   let stateDir = "";
@@ -31937,10 +32080,10 @@ function parseArgs2() {
     }
   }
   if (!stateDir) {
-    stateDir = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    stateDir = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
     console.log(`   \u4F7F\u7528\u9ED8\u8BA4\u76EE\u5F55: ${stateDir}`);
   }
-  stateDir = path42.resolve(stateDir);
+  stateDir = path43.resolve(stateDir);
   return { stateDir, quick, dryRun: dryRun2, force, answersPath };
 }
 function printHelp() {
@@ -32061,16 +32204,16 @@ function getDefaultValues(stateDir) {
   };
 }
 function loadExistingValues(stateDir) {
-  const configPath = path42.join(stateDir, "configs", "main7.json");
+  const configPath = path43.join(stateDir, "configs", "main7.json");
   try {
-    if (!fs42.existsSync(configPath)) return {};
-    const j = JSON.parse(fs42.readFileSync(configPath, "utf8"));
+    if (!fs43.existsSync(configPath)) return {};
+    const j = JSON.parse(fs43.readFileSync(configPath, "utf8"));
     const out = {};
     if (typeof j.timezone === "string" && j.timezone) out.timezone = j.timezone;
     if (j.agents?.defaults?.name) out.agentName = j.agents.defaults.name;
     if (j.agents?.defaults?.persona) out.persona = j.agents.defaults.persona;
     try {
-      const wm = fs42.readFileSync(path42.join(stateDir, "workspace", ".work-mode"), "utf8").trim();
+      const wm = fs43.readFileSync(path43.join(stateDir, "workspace", ".work-mode"), "utf8").trim();
       if (wm === "on") out.chatMode = "work";
       else if (wm === "off") out.chatMode = "emotion";
     } catch {
@@ -32127,8 +32270,8 @@ function readSecretsValue(stateDir, envName) {
   try {
     const cfgBase = "main7";
     for (const p of secretsCandidates(stateDir, cfgBase)) {
-      if (fs42.existsSync(p)) {
-        for (const line of fs42.readFileSync(p, "utf8").split("\n")) {
+      if (fs43.existsSync(p)) {
+        for (const line of fs43.readFileSync(p, "utf8").split("\n")) {
           const eq = line.indexOf("=");
           if (eq > 0 && line.slice(0, eq).trim() === envName) {
             return line.slice(eq + 1).trim();
@@ -32362,29 +32505,29 @@ async function configureWechat(rl, v) {
 }
 function buildDirTree(v) {
   const d = v.stateDir;
-  const w = path42.join(d, "workspace");
+  const w = path43.join(d, "workspace");
   return [
     // 目录
-    { path: path42.join(d, "configs"), type: "dir" },
-    { path: path42.join(d, "state", "agents", "main", "sessions"), type: "dir" },
-    { path: path42.join(w, "prompts"), type: "dir" },
-    { path: path42.join(w, "memory", "daily"), type: "dir" },
-    { path: path42.join(w, "docs", "research"), type: "dir" },
-    { path: path42.join(w, "docs", "todo"), type: "dir" },
-    { path: path42.join(w, "docs", "decisions"), type: "dir" },
-    { path: path42.join(w, "docs", "knowledge"), type: "dir" },
-    { path: path42.join(w, "docs", "sop"), type: "dir" },
-    { path: path42.join(d, "logs"), type: "dir" },
-    { path: path42.join(d, "media", "inbound"), type: "dir" },
+    { path: path43.join(d, "configs"), type: "dir" },
+    { path: path43.join(d, "state", "agents", "main", "sessions"), type: "dir" },
+    { path: path43.join(w, "prompts"), type: "dir" },
+    { path: path43.join(w, "memory", "daily"), type: "dir" },
+    { path: path43.join(w, "docs", "research"), type: "dir" },
+    { path: path43.join(w, "docs", "todo"), type: "dir" },
+    { path: path43.join(w, "docs", "decisions"), type: "dir" },
+    { path: path43.join(w, "docs", "knowledge"), type: "dir" },
+    { path: path43.join(w, "docs", "sop"), type: "dir" },
+    { path: path43.join(d, "logs"), type: "dir" },
+    { path: path43.join(d, "media", "inbound"), type: "dir" },
     // workspace 文件
     {
-      path: path42.join(w, "SESSION-STATE.md"),
+      path: path43.join(w, "SESSION-STATE.md"),
       type: "file",
       content: readTemplate("workspace/SESSION-STATE.md")
     },
-    { path: path42.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
+    { path: path43.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
     {
-      path: path42.join(w, "SOUL.md"),
+      path: path43.join(w, "SOUL.md"),
       type: "file",
       // 0917：SOUL 按人设取模板（templates/workspace/souls/<persona>.md），
       // 单一人设模板缺失时回退通用骨架（workspace/SOUL.md）
@@ -32396,12 +32539,12 @@ function buildDirTree(v) {
         }
       })()
     },
-    { path: path42.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
+    { path: path43.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
     {
       // 0920 翀哥拍板：EMOTION.md 模板按人设装（templates/workspace/emotion/<persona>.md）
       // 冷启动默认带"想 TA 了就直接发（msg_send）"那段（写在每份模板 §一）
       // 单一人设模板缺失时回退通用骨架（emotion/_default.md）
-      path: path42.join(w, "EMOTION.md"),
+      path: path43.join(w, "EMOTION.md"),
       type: "file",
       content: (() => {
         try {
@@ -32412,39 +32555,39 @@ function buildDirTree(v) {
       })()
     },
     {
-      path: path42.join(w, "prompts", "contacts.md"),
+      path: path43.join(w, "prompts", "contacts.md"),
       type: "file",
       content: readTemplate("workspace/prompts/contacts.md").replace("{{DISCORD_USER_ID}}", v.discordUserId || "YOUR_DISCORD_ID").replace("{{FEISHU_OPEN_ID}}", v.feishuOpenId || "YOUR_FEISHU_OPEN_ID")
     },
-    { path: path42.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
+    { path: path43.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
     {
       // 0925：proactive 到期处理规则。此前仓内**零模板**——那份规则只在私有部署的
       // stateDir 里手工存在，装机用户吃的是引擎内置兜底文案（那份也没点名工具）。
       // 结果：agent 用正文写判定、不调工具，判定全部不落库。
       // 注意 readTemplate 找不到模板会 **throw**，所以本文件与 templates/ 下那份必须成对存在。
-      path: path42.join(w, "prompts", "proactive.md"),
+      path: path43.join(w, "prompts", "proactive.md"),
       type: "file",
       content: readTemplate("workspace/prompts/proactive.md")
     },
     {
       // 0917：inner-voice 定制 prompt 按人设装（templates/workspace/inner-voice/<persona>.md）
-      path: path42.join(w, "prompts", "my-inner-voice.md"),
+      path: path43.join(w, "prompts", "my-inner-voice.md"),
       type: "file",
       content: readTemplate(`workspace/inner-voice/${v.persona}.md`).replace(/\{\{AGENT_NAME\}\}/g, v.agentName)
     },
-    { path: path42.join(w, "MEMORY.md"), type: "file", content: "# MEMORY.md \u2014 \u8BB0\u5FC6\u6587\u4EF6\u7D22\u5F15\n\n> \u6700\u540E\u66F4\u65B0\uFF1A\u521D\u59CB\u5316\n" },
-    { path: path42.join(w, "USER.md"), type: "file", content: "# USER.md \u2014 \u7528\u6237\u4FE1\u606F\n\n\uFF08\u5728\u8FD9\u91CC\u8BB0\u5F55\u7528\u6237\u7684\u504F\u597D\u3001\u80CC\u666F\u7B49\uFF09\n" },
+    { path: path43.join(w, "MEMORY.md"), type: "file", content: "# MEMORY.md \u2014 \u8BB0\u5FC6\u6587\u4EF6\u7D22\u5F15\n\n> \u6700\u540E\u66F4\u65B0\uFF1A\u521D\u59CB\u5316\n" },
+    { path: path43.join(w, "USER.md"), type: "file", content: "# USER.md \u2014 \u7528\u6237\u4FE1\u606F\n\n\uFF08\u5728\u8FD9\u91CC\u8BB0\u5F55\u7528\u6237\u7684\u504F\u597D\u3001\u80CC\u666F\u7B49\uFF09\n" },
     // 情绪状态机（0917）：脚本 + hook 接线 + 人设情绪表（用户在 init 选的 persona）
     //
     // 0920 起装的是 **.mjs 版**（原来是 .py，见下面 hook 命令那段）。老装机的 workspace
     // 里那份 .py 不动它——没被引用就不会跑，删了反而无据可查。
     {
-      path: path42.join(w, "scripts", "emotion_state_machine.mjs"),
+      path: path43.join(w, "scripts", "emotion_state_machine.mjs"),
       type: "file",
       content: readTemplate("workspace/scripts/emotion_state_machine.mjs")
     },
     {
-      path: path42.join(w, ".hooks.json"),
+      path: path43.join(w, ".hooks.json"),
       type: "file",
       content: JSON.stringify({
         hooks: {
@@ -32459,26 +32602,26 @@ function buildDirTree(v) {
             // （hook 的 env 是 {...process.env} 继承的），所以它就是个 node。
             // 与 `service install --node-exe` 同一个路子。
             // 路径两侧都加引号：stateDir 可能带空格（C:\Users\Foo Bar\...）。
-            { hooks: [{ type: "command", command: '"${E7_NODE}" "' + path42.join(w, "scripts", "emotion_state_machine.mjs") + '"' }] }
+            { hooks: [{ type: "command", command: '"${E7_NODE}" "' + path43.join(w, "scripts", "emotion_state_machine.mjs") + '"' }] }
           ]
         }
       }, null, 2) + "\n"
     },
     {
-      path: path42.join(w, ".emotion_states.json"),
+      path: path43.join(w, ".emotion_states.json"),
       type: "file",
       content: readTemplate(`workspace/emotion-states/${v.persona}.json`)
     },
     // 模式档位（0920）：与 /work 命令写的是同一个文件，读端只认 on/off，
     // 没有这个键就是 auto。auto 刻意不写——写个 "auto" 进去反而多一种除了这里没人认得的状态。
     ...v.chatMode === "work" || v.chatMode === "emotion" ? [{
-      path: path42.join(w, ".work-mode"),
+      path: path43.join(w, ".work-mode"),
       type: "file",
       content: v.chatMode === "work" ? "on" : "off"
     }] : [],
     // package.json — 让 agent 目录成为独立 npm 项目根，防止 npm hoisting
     {
-      path: path42.join(d, "package.json"),
+      path: path43.join(d, "package.json"),
       type: "file",
       content: JSON.stringify({
         name: v.agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-") || "agent",
@@ -32489,7 +32632,7 @@ function buildDirTree(v) {
     },
     // 启动脚本（根据 OS 生成）
     ...process.platform === "win32" ? [{
-      path: path42.join(d, "start.cmd"),
+      path: path43.join(d, "start.cmd"),
       type: "file",
       content: `@echo off
 rem Engine 7 startup script
@@ -32521,7 +32664,7 @@ if %ERRORLEVEL% NEQ 0 (
 )
 `
     }] : [{
-      path: path42.join(d, "start.sh"),
+      path: path43.join(d, "start.sh"),
       type: "file",
       content: `#!/bin/bash
 # Engine 7 startup script
@@ -32555,24 +32698,24 @@ node "$ENGINE7_BIN" --engine-config "$CFG_ABS"
 }
 function readTemplate(relativePath) {
   const candidates = [
-    path42.join(__dirname, "..", "templates", relativePath),
-    path42.join(__dirname, "..", "..", "templates", relativePath),
-    path42.join(process.cwd(), "templates", relativePath)
+    path43.join(__dirname, "..", "templates", relativePath),
+    path43.join(__dirname, "..", "..", "templates", relativePath),
+    path43.join(process.cwd(), "templates", relativePath)
   ];
   for (const p of candidates) {
-    if (fs42.existsSync(p)) {
-      return fs42.readFileSync(p, "utf-8");
+    if (fs43.existsSync(p)) {
+      return fs43.readFileSync(p, "utf-8");
     }
   }
   throw new Error(`\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${relativePath}\uFF08\u627E\u4E86: ${candidates.join(", ")}\uFF09`);
 }
 function looksLikeAppInstall(dir) {
-  return ["", "install"].some((sub) => fs42.existsSync(path42.join(dir, sub, "Engine7.exe")) && fs42.existsSync(path42.join(dir, sub, "resources", "engine7", "dist", "cli.mjs")));
+  return ["", "install"].some((sub) => fs43.existsSync(path43.join(dir, sub, "Engine7.exe")) && fs43.existsSync(path43.join(dir, sub, "resources", "engine7", "dist", "cli.mjs")));
 }
 var PHOTO_EXTS = [".png", ".jpg", ".jpeg", ".webp"];
 function hasOnlyEngineBookkeeping(dir) {
   try {
-    const entries2 = fs42.readdirSync(dir);
+    const entries2 = fs43.readdirSync(dir);
     return entries2.length > 0 && entries2.every((e) => e === "install-identity.json");
   } catch {
     return false;
@@ -32588,11 +32731,11 @@ function dryRun(entries2) {
 function execute(entries2) {
   for (const e of entries2) {
     if (e.type === "dir") {
-      fs42.mkdirSync(e.path, { recursive: true });
+      fs43.mkdirSync(e.path, { recursive: true });
       console.log(`  \u{1F4C1} ${e.path}`);
     } else {
-      fs42.mkdirSync(path42.dirname(e.path), { recursive: true });
-      fs42.writeFileSync(e.path, e.content || "", "utf-8");
+      fs43.mkdirSync(path43.dirname(e.path), { recursive: true });
+      fs43.writeFileSync(e.path, e.content || "", "utf-8");
       console.log(`  \u{1F4C4} ${e.path}`);
     }
   }
@@ -32626,8 +32769,8 @@ async function main() {
   if (subcommand === "--version" || subcommand === "-v") {
     let ver = "unknown";
     try {
-      const pkgPath = path42.join(path42.dirname(__filename2), "..", "package.json");
-      ver = JSON.parse(fs42.readFileSync(pkgPath, "utf8")).version || "unknown";
+      const pkgPath = path43.join(path43.dirname(__filename2), "..", "package.json");
+      ver = JSON.parse(fs43.readFileSync(pkgPath, "utf8")).version || "unknown";
     } catch {
     }
     console.log(`engine7 ${ver}`);
@@ -32656,14 +32799,14 @@ async function main() {
     relay = resolveRelayUrl(relay, process.env);
     if (!relayFromArg) console.error(`   \u4E2D\u8F6C\u7AD9: ${relay}\uFF08\u8981\u6362\u5730\u5740\u7528 --relay <\u5730\u5740>\uFF09`);
     const { resolveStateDirFromArgs: resolveStateDirFromArgs2 } = await Promise.resolve().then(() => (init_cli_doctor(), cli_doctor_exports));
-    stateDir = stateDir ? path42.resolve(stateDir) : resolveStateDirFromArgs2(args.slice(1));
+    stateDir = stateDir ? path43.resolve(stateDir) : resolveStateDirFromArgs2(args.slice(1));
     try {
       const { provisionFreeToken: provisionFreeToken2 } = await Promise.resolve().then(() => (init_provision_free(), provision_free_exports));
       const result = await provisionFreeToken2({
         relayBaseUrl: relay,
         stateDir,
         // 和 init 写 config 的路径一致（cli-init.ts 里 configPath 就是这么拼的）
-        configPath: path42.join(stateDir, "configs", "main7.json")
+        configPath: path43.join(stateDir, "configs", "main7.json")
       });
       console.log(JSON.stringify(result, null, 2));
       process.exit(0);
@@ -32690,18 +32833,18 @@ async function main() {
       else if (args[i] === "--base-url" && args[i + 1]) relayBaseUrl = args[++i].trim();
     }
     if (!stateDir) {
-      const cwd = path42.resolve(process.cwd());
-      if (fs42.existsSync(path42.join(cwd, "configs"))) {
+      const cwd = path43.resolve(process.cwd());
+      if (fs43.existsSync(path43.join(cwd, "configs"))) {
         stateDir = cwd;
       } else {
-        const pointer = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
-        if (fs42.existsSync(pointer)) {
+        const pointer = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+        if (fs43.existsSync(pointer)) {
           try {
-            stateDir = JSON.parse(fs42.readFileSync(pointer, "utf8")).stateDir || "";
+            stateDir = JSON.parse(fs43.readFileSync(pointer, "utf8")).stateDir || "";
           } catch {
           }
         }
-        if (!stateDir) stateDir = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+        if (!stateDir) stateDir = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
       }
     }
     if (!target && !isLegacyAddchannel) {
@@ -32721,12 +32864,12 @@ async function main() {
       process.exit(0);
     }
     if (channel === "channels") {
-      const configsDir = path42.join(stateDir, "configs");
-      if (fs42.existsSync(configsDir)) {
-        const files = fs42.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
+      const configsDir = path43.join(stateDir, "configs");
+      if (fs43.existsSync(configsDir)) {
+        const files = fs43.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
         for (const f of files) {
           try {
-            const j = JSON.parse(fs42.readFileSync(path42.join(configsDir, f), "utf8"));
+            const j = JSON.parse(fs43.readFileSync(path43.join(configsDir, f), "utf8"));
             if (!j.channels) continue;
             console.log(`
 \u{1F4C4} ${f}:`);
@@ -32763,7 +32906,7 @@ async function main() {
       }
       const configFile = resolveConfigPath2(stateDir, configName);
       if (!configFile) {
-        fail2(`\u6CA1\u627E\u5230\u53EF\u6539\u7684 config\uFF1A\u5728 ${path42.join(stateDir, "configs")} \u4E0B\u65E2\u6CA1\u6709 main7.json\uFF0C\u4E5F\u6CA1\u6709\u542B models.providers \u7684 json\u3002\u7528 --config <\u6587\u4EF6\u540D> \u6307\u5B9A\u3002`);
+        fail2(`\u6CA1\u627E\u5230\u53EF\u6539\u7684 config\uFF1A\u5728 ${path43.join(stateDir, "configs")} \u4E0B\u65E2\u6CA1\u6709 main7.json\uFF0C\u4E5F\u6CA1\u6709\u542B models.providers \u7684 json\u3002\u7528 --config <\u6587\u4EF6\u540D> \u6307\u5B9A\u3002`);
       }
       if (!readSecretsValue(stateDir, FREE_TIER_ENV_KEY2)) {
         fail2(`\u514D\u8D39\u6863\u7F3A\u5C11\u4EE4\u724C\uFF1Asecrets \u91CC\u6CA1\u6709 ${FREE_TIER_ENV_KEY2}\u3002\u5148\u9886\u53F7\uFF1A
@@ -32830,8 +32973,8 @@ async function main() {
       else if (args[i] === "--note" && args[i + 1]) note = args[++i];
       else if (args[i] === "--dry-run") dryRun2 = true;
     }
-    if (!exportStateDir) exportStateDir = path42.resolve(process.cwd());
-    if (!agentName) agentName = path42.basename(exportStateDir);
+    if (!exportStateDir) exportStateDir = path43.resolve(process.cwd());
+    if (!agentName) agentName = path43.basename(exportStateDir);
     await doExport2({ agentName, stateDir: exportStateDir, note, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -32853,7 +32996,7 @@ async function main() {
       console.error("\u274C import \u9700\u8981 --state-dir <path>");
       process.exit(1);
     }
-    if (!agentName) agentName = path42.basename(importStateDir);
+    if (!agentName) agentName = path43.basename(importStateDir);
     await doImport2({ agentName, stateDir: importStateDir, version, archiveFile: archiveFile || void 0, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -32881,18 +33024,18 @@ engine7 start \u2014 \u542F\u52A8 Engine
       }
     }
     if (!configPath2) {
-      const defaultCfg = path42.join("configs", "main7.json");
-      const homeCfg = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs42.existsSync(defaultCfg)) {
+      const defaultCfg = path43.join("configs", "main7.json");
+      const homeCfg = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs43.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs42.existsSync(homeCfg)) {
+      } else if (fs43.existsSync(homeCfg)) {
         configPath2 = homeCfg;
         console.log(`   \u4F7F\u7528\u9ED8\u8BA4 config: ${homeCfg}`);
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path42.join(ptr.stateDir, "configs", "main7.json");
-          if (fs42.existsSync(ptrCfg)) {
+          const ptrCfg = path43.join(ptr.stateDir, "configs", "main7.json");
+          if (fs43.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             console.log(`   \u4F7F\u7528 config: ${ptrCfg}`);
           }
@@ -32905,26 +33048,26 @@ engine7 start \u2014 \u542F\u52A8 Engine
         }
       }
     }
-    if (configPath2 && !fs42.existsSync(configPath2)) {
+    if (configPath2 && !fs43.existsSync(configPath2)) {
       console.error(`\u274C config \u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath2}`);
       console.error("   \u7528\u6CD5: engine7 start [configs/xxx.json | --config <path>]");
       process.exit(1);
     }
-    const { execSync: execSync3, spawn: spawn5 } = await import("node:child_process");
+    const { execSync: execSync4, spawn: spawn5 } = await import("node:child_process");
     let enginePath;
-    const localPath = path42.join("node_modules", "engine7", "dist", "main.mjs");
-    if (fs42.existsSync(localPath)) {
+    const localPath = path43.join("node_modules", "engine7", "dist", "main.mjs");
+    if (fs43.existsSync(localPath)) {
       enginePath = localPath;
     } else {
-      const cliPath = path42.resolve(process.argv[1]);
-      const distDir = path42.dirname(cliPath);
-      const candidate = path42.join(distDir, "main.mjs");
-      if (fs42.existsSync(candidate)) {
+      const cliPath = path43.resolve(process.argv[1]);
+      const distDir = path43.dirname(cliPath);
+      const candidate = path43.join(distDir, "main.mjs");
+      if (fs43.existsSync(candidate)) {
         enginePath = candidate;
       } else {
         try {
-          const globalRoot = execSync3("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-          enginePath = path42.join(globalRoot, "engine7", "dist", "main.mjs");
+          const globalRoot = execSync4("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+          enginePath = path43.join(globalRoot, "engine7", "dist", "main.mjs");
         } catch {
           console.error("\u274C \u627E\u4E0D\u5230 engine7 main.mjs");
           process.exit(1);
@@ -32934,29 +33077,23 @@ engine7 start \u2014 \u542F\u52A8 Engine
     console.log(label);
     console.log(`   config: ${configPath2}`);
     console.log(`   engine: ${enginePath}`);
-    const configName = path42.basename(configPath2);
-    const configAbs = path42.resolve(configPath2);
-    const myPid = process.pid;
+    const configAbs = path43.resolve(configPath2);
     try {
-      if (process.platform === "win32") {
-        execSync3(`powershell -Command "Get-WmiObject Win32_Process | Where-Object { $_.Name -eq 'node.exe' -and $_.CommandLine.Contains('${configAbs}') -and $_.CommandLine -like '*dist*' -and $_.ProcessId -ne ${myPid} } | ForEach-Object { Write-Host '[start] Killing PID' $_.ProcessId; Stop-Process -Id $_.ProcessId -Force }"`, { stdio: "inherit" });
-      } else {
-        const psOut = execSync3(`ps -axo pid=,command= | grep -F 'dist/main.mjs' | grep -F '${configAbs}' | grep -vF 'ps -axo' | awk '{print $1}' 2>/dev/null || true`, { encoding: "utf-8" }).trim();
-        const otherPids = psOut.split("\n").map((p) => p.trim()).filter((p) => p && /^\d+$/.test(p) && p !== String(myPid)).join("\n").trim();
-        if (otherPids) {
-          console.log(`[start] Killing existing engine (PID: ${otherPids})...`);
-          execSync3(`echo "${otherPids}" | xargs kill -9 2>/dev/null || true`);
-          await new Promise((r) => setTimeout(r, 2e3));
-        }
+      const stateDir = engineStateDirOfConfig(configAbs);
+      const killed = stateDir ? killOwnEngineForStateDir(stateDir) : null;
+      if (killed !== null) {
+        console.log(`[start] Killing existing engine (PID: ${killed})...`);
+        await waitForPidGone(killed);
       }
-    } catch {
+    } catch (err) {
+      console.warn(`[start] \u6740\u65E7\u8FDB\u7A0B\u5931\u8D25\uFF08\u4E0D\u6321\u542F\u52A8\uFF09\uFF1A${err.message}`);
     }
     console.log("");
     const envForChild = { ...process.env };
     const { stateDir: secretsStateDir, configName: secretsCfgName } = resolveConfigIdentity(configPath2);
     for (const secretPath of secretsCandidates(secretsStateDir, secretsCfgName)) {
-      if (fs42.existsSync(secretPath)) {
-        const content = fs42.readFileSync(secretPath, "utf-8");
+      if (fs43.existsSync(secretPath)) {
+        const content = fs43.readFileSync(secretPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -33004,7 +33141,6 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
       process.exit(0);
     }
     if (action === "reset") {
-      const { execSync: execSync3 } = await import("node:child_process");
       let configPath2 = "";
       let mode = "archive";
       let dropN = 3;
@@ -33031,14 +33167,14 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         console.error(`\u274C \u672A\u77E5\u6A21\u5F0F: ${mode}\uFF08\u53EF\u9009: archive / drop-last / strip-images\uFF09`);
         process.exit(1);
       }
-      const configRaw = JSON.parse(fs42.readFileSync(configPath2, "utf-8"));
+      const configRaw = JSON.parse(fs43.readFileSync(configPath2, "utf-8"));
       const stateDir = configRaw.stateDir;
       if (!stateDir) {
         console.error("\u274C config \u91CC\u6CA1\u6709 stateDir");
         process.exit(1);
       }
-      const sessionsDir = path42.join(stateDir, "agents", "main", "sessions");
-      if (!fs42.existsSync(sessionsDir)) {
+      const sessionsDir = path43.join(stateDir, "agents", "main", "sessions");
+      if (!fs43.existsSync(sessionsDir)) {
         console.error(`\u274C sessions \u76EE\u5F55\u4E0D\u5B58\u5728: ${sessionsDir}`);
         process.exit(1);
       }
@@ -33046,56 +33182,54 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
       console.log(`   config: ${configPath2}`);
       console.log(`   mode:   ${mode}`);
       if (mode === "drop-last") console.log(`   n:      ${dropN}`);
-      const platformMapPath = path42.join(sessionsDir, "platform-map.json");
-      const indexPath = path42.join(sessionsDir, "session-index.json");
+      const platformMapPath = path43.join(sessionsDir, "platform-map.json");
+      const indexPath = path43.join(sessionsDir, "session-index.json");
       let sessionFileUUID = null;
-      if (fs42.existsSync(indexPath)) {
-        const index = JSON.parse(fs42.readFileSync(indexPath, "utf-8"));
+      if (fs43.existsSync(indexPath)) {
+        const index = JSON.parse(fs43.readFileSync(indexPath, "utf-8"));
         const entries2 = Object.values(index);
         if (entries2.length > 0) {
           const fileVal = entries2[0].file || "";
-          sessionFileUUID = path42.isAbsolute(fileVal) ? path42.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
+          sessionFileUUID = path43.isAbsolute(fileVal) ? path43.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
         }
       }
       if (!sessionFileUUID) {
-        const jsonlFiles = fs42.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs42.statSync(path42.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+        const jsonlFiles = fs43.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs43.statSync(path43.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
         if (jsonlFiles.length === 0) {
           console.error("\u274C \u627E\u4E0D\u5230\u6D3B\u8DC3\u7684 session JSONL \u6587\u4EF6");
           process.exit(1);
         }
         sessionFileUUID = jsonlFiles[0].name.replace(".jsonl", "");
       }
-      let jsonlPath = path42.join(sessionsDir, `${sessionFileUUID}.jsonl`);
-      if (!fs42.existsSync(jsonlPath)) {
-        const jsonlFiles = fs42.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs42.statSync(path42.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+      let jsonlPath = path43.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+      if (!fs43.existsSync(jsonlPath)) {
+        const jsonlFiles = fs43.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs43.statSync(path43.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
         if (jsonlFiles.length === 0) {
           console.error(`\u274C JSONL \u6587\u4EF6\u4E0D\u5B58\u5728: ${jsonlPath}`);
           process.exit(1);
         }
         sessionFileUUID = jsonlFiles[0].name.replace(".jsonl", "");
-        jsonlPath = path42.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+        jsonlPath = path43.join(sessionsDir, `${sessionFileUUID}.jsonl`);
       }
       console.log(`   file:   ${jsonlPath}`);
-      const configName = path42.basename(configPath2);
       if (autoRestart) {
         try {
-          const myPid = process.pid;
-          const pids = execSync3(`pgrep -f "dist/main.mjs.*${configName}" 2>/dev/null || true`, { encoding: "utf-8" }).trim();
-          const otherPids = pids.split("\n").filter((p) => p && p.trim() !== String(myPid)).join("\n").trim();
-          if (otherPids) {
+          const stateDir2 = engineStateDirOfConfig(path43.resolve(configPath2));
+          const killed = stateDir2 ? killOwnEngineForStateDir(stateDir2) : null;
+          if (killed !== null) {
             console.log(`
-   Killing engine (PID: ${otherPids})...`);
-            execSync3(`echo "${otherPids}" | xargs kill -9 2>/dev/null || true`);
-            await new Promise((r) => setTimeout(r, 2e3));
+   Killing engine (PID: ${killed})...`);
+            await waitForPidGone(killed);
           }
-        } catch {
+        } catch (err) {
+          console.warn(`[session] \u6740\u65E7\u8FDB\u7A0B\u5931\u8D25\uFF08\u4E0D\u6321\u91CD\u7F6E\uFF09\uFF1A${err.message}`);
         }
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const { readFileSync: readFileSync45, writeFileSync: writeFileSync26, renameSync: renameSync5 } = fs42;
+      const { readFileSync: readFileSync45, writeFileSync: writeFileSync26, renameSync: renameSync5 } = fs43;
       if (mode === "archive") {
         const archiveName = `${sessionFileUUID}.jsonl.archived.${timestamp}`;
-        renameSync5(jsonlPath, path42.join(sessionsDir, archiveName));
+        renameSync5(jsonlPath, path43.join(sessionsDir, archiveName));
         console.log(`
 \u2705 \u5F52\u6863\u5B8C\u6210: ${archiveName}`);
         console.log(`   \u91CD\u542F\u540E\u5C06\u4ECE\u7A7A\u767D\u4F1A\u8BDD\u5F00\u59CB`);
@@ -33170,12 +33304,12 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
 \u2705 \u6458\u9664 ${stripped} \u884C\u56FE\u7247\u76F8\u5173\u5185\u5BB9`);
       }
       if (autoRestart) {
-        const realCliPath = fs42.realpathSync(process.argv[1]);
-        const cliDir = path42.dirname(realCliPath);
-        const pkgRoot = path42.resolve(cliDir, "..");
-        let enginePath = path42.join(pkgRoot, "dist", "main.mjs");
-        if (!fs42.existsSync(enginePath)) {
-          enginePath = path42.join(cliDir, "main.mjs");
+        const realCliPath = fs43.realpathSync(process.argv[1]);
+        const cliDir = path43.dirname(realCliPath);
+        const pkgRoot = path43.resolve(cliDir, "..");
+        let enginePath = path43.join(pkgRoot, "dist", "main.mjs");
+        if (!fs43.existsSync(enginePath)) {
+          enginePath = path43.join(cliDir, "main.mjs");
         }
         console.log(`
 \u{1F680} \u62C9\u8D77 engine...`);
@@ -33215,18 +33349,18 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
     let configPath2 = cfg;
     let cwd = svcCwd;
     if (!configPath2) {
-      const defaultCfg = path42.join(cwd, "configs", "main7.json");
-      const homeCfg = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs42.existsSync(defaultCfg)) {
+      const defaultCfg = path43.join(cwd, "configs", "main7.json");
+      const homeCfg = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs43.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs42.existsSync(homeCfg)) {
+      } else if (fs43.existsSync(homeCfg)) {
         configPath2 = homeCfg;
-        cwd = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+        cwd = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path42.join(ptr.stateDir, "configs", "main7.json");
-          if (fs42.existsSync(ptrCfg)) {
+          const ptrCfg = path43.join(ptr.stateDir, "configs", "main7.json");
+          if (fs43.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             cwd = ptr.stateDir;
           }
@@ -33239,32 +33373,32 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
         }
       }
     }
-    const { execSync: execSync3 } = await import("node:child_process");
+    const { execSync: execSync4 } = await import("node:child_process");
     const engine7Bin = process.argv[1];
     if (action === "install") {
       if (process.platform === "win32") {
         const taskName = "Engine7";
-        const wrapperPath = path42.join(cwd, "engine7-start.cmd");
+        const wrapperPath = path43.join(cwd, "engine7-start.cmd");
         const wrapperContent = buildServiceWrapper({
           cwd,
           nodeExe: nodeExe || void 0,
-          cliMjs: path42.resolve(engine7Bin),
-          configPath: path42.resolve(configPath2)
+          cliMjs: path43.resolve(engine7Bin),
+          configPath: path43.resolve(configPath2)
         });
-        fs42.writeFileSync(wrapperPath, wrapperContent);
-        const startupDir = path42.join(
-          process.env.APPDATA || path42.join(process.env.USERPROFILE || "", "AppData", "Roaming"),
+        fs43.writeFileSync(wrapperPath, wrapperContent);
+        const startupDir = path43.join(
+          process.env.APPDATA || path43.join(process.env.USERPROFILE || "", "AppData", "Roaming"),
           "Microsoft",
           "Windows",
           "Start Menu",
           "Programs",
           "Startup"
         );
-        fs42.mkdirSync(startupDir, { recursive: true });
-        const vbsPath = path42.join(startupDir, "Engine7.vbs");
+        fs43.mkdirSync(startupDir, { recursive: true });
+        const vbsPath = path43.join(startupDir, "Engine7.vbs");
         const nodeExePath = nodeExe || process.execPath;
-        const cliMjsPath = path42.resolve(engine7Bin);
-        const absCfg = path42.resolve(configPath2);
+        const cliMjsPath = path43.resolve(engine7Bin);
+        const absCfg = path43.resolve(configPath2);
         const vbs = [
           "' Engine 7 \u5F00\u673A\u81EA\u542F\uFF08\u542F\u52A8\u6587\u4EF6\u5939\uFF0C\u514D\u7BA1\u7406\u5458\uFF09",
           'Set fso = CreateObject("Scripting.FileSystemObject")',
@@ -33280,15 +33414,15 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
           's.Run """' + nodeExePath + '"" ""' + cliMjsPath + '"" start --config ""' + absCfg + '""", 0, False',
           ""
         ].join(String.fromCharCode(13) + String.fromCharCode(10));
-        fs42.writeFileSync(vbsPath, vbs);
+        fs43.writeFileSync(vbsPath, vbs);
         console.log(`\u2705 \u5F00\u673A\u81EA\u542F\u52A8\u5DF2\u6CE8\u518C\uFF08\u542F\u52A8\u6587\u4EF6\u5939: ${vbsPath}\uFF09`);
       } else if (process.platform === "darwin") {
         const label = "com.engine7.agent";
-        const plistDir = path42.join(process.env.HOME, "Library", "LaunchAgents");
-        fs42.mkdirSync(plistDir, { recursive: true });
-        const plistPath = path42.join(plistDir, `${label}.plist`);
-        const localCli = path42.join("node_modules", "engine7", "dist", "cli.mjs");
-        const cliMjs = fs42.existsSync(localCli) ? path42.resolve(localCli) : path42.join(path42.dirname(path42.dirname(engine7Bin)), "lib", "node_modules", "engine7", "dist", "cli.mjs");
+        const plistDir = path43.join(process.env.HOME, "Library", "LaunchAgents");
+        fs43.mkdirSync(plistDir, { recursive: true });
+        const plistPath = path43.join(plistDir, `${label}.plist`);
+        const localCli = path43.join("node_modules", "engine7", "dist", "cli.mjs");
+        const cliMjs = fs43.existsSync(localCli) ? path43.resolve(localCli) : path43.join(path43.dirname(path43.dirname(engine7Bin)), "lib", "node_modules", "engine7", "dist", "cli.mjs");
         const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -33300,16 +33434,16 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
     <string>${cliMjs}</string>
     <string>start</string>
     <string>--config</string>
-    <string>${path42.resolve(configPath2)}</string>
+    <string>${path43.resolve(configPath2)}</string>
   </array>
   <key>WorkingDirectory</key><string>${cwd}</string>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
 </dict>
 </plist>`;
-        fs42.writeFileSync(plistPath, plist);
+        fs43.writeFileSync(plistPath, plist);
         try {
-          execSync3(`launchctl load "${plistPath}"`, { stdio: "inherit" });
+          execSync4(`launchctl load "${plistPath}"`, { stdio: "inherit" });
           console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
           console.log(`   ${plistPath}`);
         } catch {
@@ -33318,9 +33452,9 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
         }
       } else {
         const svcName = "engine7";
-        const svcDir = path42.join(process.env.HOME, ".config", "systemd", "user");
-        fs42.mkdirSync(svcDir, { recursive: true });
-        const svcPath = path42.join(svcDir, `${svcName}.service`);
+        const svcDir = path43.join(process.env.HOME, ".config", "systemd", "user");
+        fs43.mkdirSync(svcDir, { recursive: true });
+        const svcPath = path43.join(svcDir, `${svcName}.service`);
         const svc = `[Unit]
 Description=Engine 7 Agent
 After=network.target
@@ -33328,16 +33462,16 @@ After=network.target
 [Service]
 Type=simple
 WorkingDirectory=${cwd}
-ExecStart=${process.execPath} ${engine7Bin} start --config ${path42.resolve(configPath2)}
+ExecStart=${process.execPath} ${engine7Bin} start --config ${path43.resolve(configPath2)}
 Restart=on-failure
 RestartSec=10
 
 [Install]
 WantedBy=default.target`;
-        fs42.writeFileSync(svcPath, svc);
+        fs43.writeFileSync(svcPath, svc);
         try {
-          execSync3(`systemctl --user daemon-reload`, { stdio: "inherit" });
-          execSync3(`systemctl --user enable ${svcName}`, { stdio: "inherit" });
+          execSync4(`systemctl --user daemon-reload`, { stdio: "inherit" });
+          execSync4(`systemctl --user enable ${svcName}`, { stdio: "inherit" });
           console.log(`\u2705 systemd \u7528\u6237\u670D\u52A1\u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
           console.log(`   ${svcPath}`);
         } catch {
@@ -33347,8 +33481,8 @@ WantedBy=default.target`;
       }
     } else if (action === "uninstall") {
       if (process.platform === "win32") {
-        const vbsPath = path42.join(
-          process.env.APPDATA || path42.join(process.env.USERPROFILE || "", "AppData", "Roaming"),
+        const vbsPath = path43.join(
+          process.env.APPDATA || path43.join(process.env.USERPROFILE || "", "AppData", "Roaming"),
           "Microsoft",
           "Windows",
           "Start Menu",
@@ -33357,46 +33491,46 @@ WantedBy=default.target`;
           "Engine7.vbs"
         );
         try {
-          execSync3(`schtasks /delete /tn "Engine7" /f`, { stdio: "ignore" });
+          execSync4(`schtasks /delete /tn "Engine7" /f`, { stdio: "ignore" });
         } catch {
         }
-        if (fs42.existsSync(vbsPath)) {
-          fs42.rmSync(vbsPath, { force: true });
+        if (fs43.existsSync(vbsPath)) {
+          fs43.rmSync(vbsPath, { force: true });
           console.log(`\u2705 \u5F00\u673A\u81EA\u542F\u52A8\u5DF2\u79FB\u9664\uFF08${vbsPath}\uFF09`);
         } else {
           console.log("\uFF08\u5F00\u673A\u81EA\u542F\u52A8\u672C\u6765\u5C31\u6CA1\u6CE8\u518C\uFF09");
         }
       } else if (process.platform === "darwin") {
-        const plistPath = path42.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        const plistPath = path43.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
         try {
-          execSync3(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
+          execSync4(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
         } catch {
         }
         try {
-          fs42.unlinkSync(plistPath);
+          fs43.unlinkSync(plistPath);
         } catch {
         }
         console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u5220\u9664`);
       } else {
         try {
-          execSync3(`systemctl --user disable engine7`, { stdio: "inherit" });
+          execSync4(`systemctl --user disable engine7`, { stdio: "inherit" });
         } catch {
         }
-        const svcPath = path42.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
+        const svcPath = path43.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
         try {
-          fs42.unlinkSync(svcPath);
+          fs43.unlinkSync(svcPath);
         } catch {
         }
         try {
-          execSync3(`systemctl --user daemon-reload`, { stdio: "inherit" });
+          execSync4(`systemctl --user daemon-reload`, { stdio: "inherit" });
         } catch {
         }
         console.log(`\u2705 systemd \u7528\u6237\u670D\u52A1\u5DF2\u5220\u9664`);
       }
     } else if (action === "status") {
       if (process.platform === "win32") {
-        const vbsPath = path42.join(
-          process.env.APPDATA || path42.join(process.env.USERPROFILE || "", "AppData", "Roaming"),
+        const vbsPath = path43.join(
+          process.env.APPDATA || path43.join(process.env.USERPROFILE || "", "AppData", "Roaming"),
           "Microsoft",
           "Windows",
           "Start Menu",
@@ -33404,17 +33538,17 @@ WantedBy=default.target`;
           "Startup",
           "Engine7.vbs"
         );
-        console.log(fs42.existsSync(vbsPath) ? `\u2705 \u5DF2\u6CE8\u518C\uFF08\u542F\u52A8\u6587\u4EF6\u5939\uFF09: ${vbsPath}` : "\u274C \u672A\u6CE8\u518C");
+        console.log(fs43.existsSync(vbsPath) ? `\u2705 \u5DF2\u6CE8\u518C\uFF08\u542F\u52A8\u6587\u4EF6\u5939\uFF09: ${vbsPath}` : "\u274C \u672A\u6CE8\u518C");
       } else if (process.platform === "darwin") {
-        const plistPath = path42.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
-        if (fs42.existsSync(plistPath)) {
+        const plistPath = path43.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        if (fs43.existsSync(plistPath)) {
           console.log("\u2705 \u5DF2\u5B89\u88C5\uFF08launchd\uFF09");
         } else {
           console.log("\u274C \u672A\u5B89\u88C5");
         }
       } else {
         try {
-          execSync3(`systemctl --user is-enabled engine7`, { stdio: "inherit" });
+          execSync4(`systemctl --user is-enabled engine7`, { stdio: "inherit" });
         } catch {
           console.log("\u274C \u672A\u5B89\u88C5");
         }
@@ -33440,8 +33574,8 @@ WantedBy=default.target`;
   console.log(`
 \u{1F680} engine7 init`);
   console.log(`   state-dir: ${opts.stateDir}`);
-  if (fs42.existsSync(opts.stateDir) && !opts.dryRun) {
-    const files = fs42.readdirSync(opts.stateDir);
+  if (fs43.existsSync(opts.stateDir) && !opts.dryRun) {
+    const files = fs43.readdirSync(opts.stateDir);
     if (files.length > 0) {
       if (opts.force) {
         if (looksLikeAppInstall(opts.stateDir)) {
@@ -33454,10 +33588,10 @@ WantedBy=default.target`;
         }
         console.log(`
 \u26A0\uFE0F --force: \u6E05\u7A7A\u5DF2\u6709\u76EE\u5F55 ${opts.stateDir}`);
-        fs42.rmSync(opts.stateDir, { recursive: true, force: true });
+        fs43.rmSync(opts.stateDir, { recursive: true, force: true });
       } else {
-        const existingConfig = path42.join(opts.stateDir, "configs", "main7.json");
-        if (fs42.existsSync(existingConfig)) {
+        const existingConfig = path43.join(opts.stateDir, "configs", "main7.json");
+        if (fs43.existsSync(existingConfig)) {
           console.log(`
 \u267B\uFE0F \u68C0\u6D4B\u5230\u5DF2\u6709\u914D\u7F6E: ${existingConfig}`);
           console.log(`   \u2192 \u590D\u8DD1\u6A21\u5F0F\uFF1A\u663E\u793A\u73B0\u6709\u914D\u7F6E\uFF0C\u56DE\u8F66\u4FDD\u7559\uFF0C\u6539\u4E86\u624D\u751F\u6548\uFF08\u4E0D\u4F1A\u6E05\u7A7A\u76EE\u5F55\uFF09`);
@@ -33538,12 +33672,12 @@ WantedBy=default.target`;
   let photoSrc = "";
   if (answers?.selfie?.photoPath) {
     const { dimsOf: dimsOf2 } = await Promise.resolve().then(() => (init_my_selfie(), my_selfie_exports));
-    const src = path42.resolve(answers.selfie.photoPath.trim());
-    const ext = path42.extname(src).toLowerCase();
+    const src = path43.resolve(answers.selfie.photoPath.trim());
+    const ext = path43.extname(src).toLowerCase();
     if (!PHOTO_EXTS.includes(ext)) {
       throw new Error(`\u7167\u7247\u683C\u5F0F\u4E0D\u652F\u6301\uFF1A${ext || "(\u6CA1\u6709\u540E\u7F00)"}\u3002\u8BF7\u7528 PNG / JPEG / WebP\u3002`);
     }
-    if (!fs42.existsSync(src)) {
+    if (!fs43.existsSync(src)) {
       throw new Error(`\u7167\u7247\u4E0D\u5B58\u5728\uFF1A${src}`);
     }
     const dims = dimsOf2(src);
@@ -33554,7 +33688,7 @@ WantedBy=default.target`;
     photoSrc = src;
   }
   const config = generateConfig(values);
-  const configPath = path42.join(opts.stateDir, "configs", "main7.json");
+  const configPath = path43.join(opts.stateDir, "configs", "main7.json");
   const tree = buildDirTree(values);
   if (headlessEmit) headlessEmit({ event: "progress", step: "write_config" });
   tree.push({
@@ -33566,22 +33700,22 @@ WantedBy=default.target`;
     dryRun(tree);
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skills = fs42.readdirSync(skillsSrc);
+      const skills = fs43.readdirSync(skillsSrc);
       for (const s of skills) {
-        console.log(`  \u{1F4C1} ${path42.join(opts.stateDir, "workspace", "skills", s)}`);
+        console.log(`  \u{1F4C1} ${path43.join(opts.stateDir, "workspace", "skills", s)}`);
       }
     }
   } else {
     if (values.chatMode === "auto") {
       try {
-        fs42.unlinkSync(path42.join(opts.stateDir, "workspace", ".work-mode"));
+        fs43.unlinkSync(path43.join(opts.stateDir, "workspace", ".work-mode"));
       } catch {
       }
     }
     if (photoSrc && values.selfiePhotoRelPath) {
-      const dest = path42.join(opts.stateDir, "workspace", values.selfiePhotoRelPath);
-      fs42.mkdirSync(path42.dirname(dest), { recursive: true });
-      fs42.copyFileSync(photoSrc, dest);
+      const dest = path43.join(opts.stateDir, "workspace", values.selfiePhotoRelPath);
+      fs43.mkdirSync(path43.dirname(dest), { recursive: true });
+      fs43.copyFileSync(photoSrc, dest);
       console.log(`  \u{1F5BC}  \u5F62\u8C61: ${dest}`);
     }
     if (headlessEmit) headlessEmit({ event: "progress", step: "create_dirs" });
@@ -33610,58 +33744,58 @@ WantedBy=default.target`;
     if (headlessEmit) headlessEmit({ event: "progress", step: "copy_skills" });
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skillsDest = path42.join(opts.stateDir, "workspace", "skills");
-      fs42.mkdirSync(skillsDest, { recursive: true });
-      const skills = fs42.readdirSync(skillsSrc);
+      const skillsDest = path43.join(opts.stateDir, "workspace", "skills");
+      fs43.mkdirSync(skillsDest, { recursive: true });
+      const skills = fs43.readdirSync(skillsSrc);
       for (const s of skills) {
-        copyDirRecursive(path42.join(skillsSrc, s), path42.join(skillsDest, s));
+        copyDirRecursive(path43.join(skillsSrc, s), path43.join(skillsDest, s));
         console.log(`  \u{1F4E6} skill: ${s}`);
       }
     }
     console.log(`
 \u2705 \u521D\u59CB\u5316\u5B8C\u6210\uFF01
 `);
-    const homePointer = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+    const homePointer = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
     const pointerData = { stateDir: opts.stateDir };
-    fs42.writeFileSync(homePointer, JSON.stringify(pointerData, null, 2) + "\n");
+    fs43.writeFileSync(homePointer, JSON.stringify(pointerData, null, 2) + "\n");
     console.log(`   \u{1F4C4} ${homePointer}\uFF08\u4ECE\u4EFB\u610F\u76EE\u5F55\u90FD\u80FD\u627E\u5230\u6B64 agent\uFF09`);
     console.log(`\u4E0B\u4E00\u6B65\uFF1A`);
     console.log(`  1. \u68C0\u67E5\u5E76\u4FEE\u6539 ${opts.stateDir}/configs/main7.json`);
     console.log(`  2. \u542F\u52A8 Engine: engine7 start\uFF08\u5728\u4EFB\u610F\u76EE\u5F55\u90FD\u884C\uFF09`);
     console.log(`  3. \u5F00\u673A\u81EA\u542F: engine7 service install\uFF08\u5728\u4EFB\u610F\u76EE\u5F55\u90FD\u884C\uFF09`);
-    console.log(`  4. \u67E5\u770B workspace: ${path42.join(opts.stateDir, "workspace")}`);
+    console.log(`  4. \u67E5\u770B workspace: ${path43.join(opts.stateDir, "workspace")}`);
     if (headlessEmit) {
       headlessEmit({ event: "done", stateDir: opts.stateDir.replace(/\\/g, "/"), configPath: configPath.replace(/\\/g, "/") });
     }
   }
 }
 function copyDirRecursive(src, dest) {
-  fs42.mkdirSync(dest, { recursive: true });
-  for (const entry of fs42.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path42.join(src, entry.name);
-    const destPath = path42.join(dest, entry.name);
+  fs43.mkdirSync(dest, { recursive: true });
+  for (const entry of fs43.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path43.join(src, entry.name);
+    const destPath = path43.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs42.copyFileSync(srcPath, destPath);
+      fs43.copyFileSync(srcPath, destPath);
     }
   }
 }
 function findTemplateDir(name) {
   const candidates = [
-    path42.join(__dirname, "..", "templates", name),
-    path42.join(__dirname, "..", "..", "templates", name),
-    path42.join(process.cwd(), "templates", name)
+    path43.join(__dirname, "..", "templates", name),
+    path43.join(__dirname, "..", "..", "templates", name),
+    path43.join(process.cwd(), "templates", name)
   ];
   for (const p of candidates) {
-    if (fs42.existsSync(p)) return p;
+    if (fs43.existsSync(p)) return p;
   }
   return null;
 }
 function readHomePointer() {
-  const ptrPath = path42.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+  const ptrPath = path43.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
   try {
-    return JSON.parse(fs42.readFileSync(ptrPath, "utf-8"));
+    return JSON.parse(fs43.readFileSync(ptrPath, "utf-8"));
   } catch {
     return null;
   }