engine7 7.1.66 → 7.1.68

package/dist/cli.mjs

@@ -1254,14 +1254,14 @@ var init_live = __esm({
       }
       /** 把改动写回 config 文件对应段（找不到文件路径则只内存生效） */
       async persistToFile(dotPath, val) {
-        const fs28 = await import("node:fs");
+        const fs29 = await import("node:fs");
         const cfgPath = this.current?._configFilePath;
-        if (!cfgPath || !fs28.existsSync(cfgPath)) {
+        if (!cfgPath || !fs29.existsSync(cfgPath)) {
           console.warn(`[liveConfig] set: no config file path, in-memory only (${dotPath})`);
           return;
         }
         try {
-          const raw = JSON.parse(fs28.readFileSync(cfgPath, "utf-8"));
+          const raw = JSON.parse(fs29.readFileSync(cfgPath, "utf-8"));
           const keys = dotPath.split(".");
           let o = raw;
           for (let i = 0; i < keys.length - 1; i++) {
@@ -1269,7 +1269,7 @@ var init_live = __esm({
             o = o[keys[i]];
           }
           o[keys[keys.length - 1]] = val;
-          fs28.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+          fs29.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
           console.log(`[liveConfig] persisted ${dotPath} = ${JSON.stringify(val)} to ${cfgPath}`);
           markSelfWrite();
         } catch (e) {
@@ -1515,7 +1515,6 @@ function loadConfig(configPath) {
     services: raw.services,
     commands: raw.commands,
     compaction: raw.compaction,
-    cognifold: raw.cognifold,
     everos: raw.everos,
     // 保留原始 agents 段，供 liveConfig.get('agents.defaults.*') 读取（如 privateTools 开关）
     agents: raw.agents,
@@ -1684,6 +1683,130 @@ var init_registry = __esm({
   }
 });
 
+// src/calendar/db.ts
+import * as path3 from "node:path";
+import * as fs3 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 = path3.join(workspace, ".calendar");
+  fs3.mkdirSync(dir, { recursive: true });
+  const dbPath = path3.join(dir, "calendar.db");
+  const db2 = new DatabaseSync(dbPath);
+  db2.exec("PRAGMA journal_mode=WAL");
+  db2.exec(`CREATE TABLE IF NOT EXISTS events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    type TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending',
+    event TEXT NOT NULL,
+    day TEXT,
+    time TEXT,
+    date_str TEXT,
+    created_at TEXT NOT NULL,
+    done_at TEXT,
+    archived_at TEXT
+  )`);
+  migrate(db2);
+  return db2;
+}
+function migrate(db2) {
+  const cols = new Set(
+    db2.prepare("PRAGMA table_info(events)").all().map((r) => r.name)
+  );
+  if (!cols.has("remind_before_min")) {
+    db2.exec("ALTER TABLE events ADD COLUMN remind_before_min INTEGER DEFAULT 60");
+  }
+  if (!cols.has("remind_at")) {
+    db2.exec("ALTER TABLE events ADD COLUMN remind_at TEXT");
+  }
+  if (!cols.has("reminded")) {
+    db2.exec("ALTER TABLE events ADD COLUMN reminded INTEGER DEFAULT 0");
+  }
+  if (!cols.has("time_exact")) {
+    db2.exec("ALTER TABLE events ADD COLUMN time_exact TEXT");
+  }
+  if (!cols.has("start_time")) {
+    db2.exec("ALTER TABLE events ADD COLUMN start_time TEXT");
+  }
+  if (!cols.has("duration_min")) {
+    db2.exec("ALTER TABLE events ADD COLUMN duration_min INTEGER");
+  }
+  if (!cols.has("created_channel")) {
+    db2.exec("ALTER TABLE events ADD COLUMN created_channel TEXT");
+  }
+  if (!cols.has("created_channel_target")) {
+    db2.exec("ALTER TABLE events ADD COLUMN created_channel_target TEXT");
+  }
+  if (!cols.has("repeat_type")) {
+    db2.exec("ALTER TABLE events ADD COLUMN repeat_type TEXT DEFAULT 'once'");
+  }
+  if (!cols.has("doc_path")) {
+    db2.exec("ALTER TABLE events ADD COLUMN doc_path TEXT");
+  }
+}
+var _sqlite, DatabaseSync, TZ_OFFSET_MS;
+var init_db = __esm({
+  "src/calendar/db.ts"() {
+    "use strict";
+    _sqlite = null;
+    DatabaseSync = new Proxy(function() {
+    }, {
+      construct(_t, args) {
+        return new (getSqlite()).DatabaseSync(...args);
+      },
+      get(_t, prop) {
+        return getSqlite().DatabaseSync[prop];
+      }
+    });
+    TZ_OFFSET_MS = 8 * 60 * 60 * 1e3;
+  }
+});
+
+// src/goals/store.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+function file(stateDir) {
+  return path4.join(stateDir, "goals.json");
+}
+function db(stateDir) {
+  const d = openDb(stateDir);
+  d.exec(`CREATE TABLE IF NOT EXISTS goals (id TEXT PRIMARY KEY, objective TEXT NOT NULL, status TEXT NOT NULL, steps_json TEXT NOT NULL, current_step INTEGER NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, blocker TEXT)`);
+  d.exec(`CREATE TABLE IF NOT EXISTS goal_events (event_id TEXT PRIMARY KEY, goal_id TEXT NOT NULL, type TEXT NOT NULL, payload_json TEXT NOT NULL, created_at TEXT NOT NULL)`);
+  return d;
+}
+function read(stateDir) {
+  try {
+    const v = JSON.parse(fs4.readFileSync(file(stateDir), "utf8"));
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+function rowToGoal(r) {
+  return { id: r.id, objective: r.objective, status: r.status, steps: JSON.parse(r.steps_json), currentStep: r.current_step, createdAt: r.created_at, updatedAt: r.updated_at, ...r.blocker ? { blocker: r.blocker } : {} };
+}
+function migrateLegacy(stateDir, d) {
+  const count = Number(d.prepare("SELECT COUNT(*) AS n FROM goals").get()?.n ?? 0);
+  if (count > 0) return;
+  for (const g of read(stateDir)) d.prepare("INSERT OR IGNORE INTO goals VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(g.id, g.objective, g.status, JSON.stringify(g.steps), g.currentStep, g.createdAt, g.updatedAt, g.blocker ?? null);
+}
+function listGoals(stateDir) {
+  const d = db(stateDir);
+  migrateLegacy(stateDir, d);
+  const rows = d.prepare("SELECT * FROM goals ORDER BY created_at").all().map(rowToGoal);
+  d.close?.();
+  return rows;
+}
+var init_store = __esm({
+  "src/goals/store.ts"() {
+    "use strict";
+    init_db();
+  }
+});
+
 // src/memory/memdir/paths.ts
 var paths_exports = {};
 __export(paths_exports, {
@@ -1695,26 +1818,26 @@ __export(paths_exports, {
   isAutoMemPath: () => isAutoMemPath,
   setMemoryDirOverride: () => setMemoryDirOverride
 });
-import { join as join3, normalize, sep, isAbsolute, resolve as resolve2 } from "node:path";
+import { join as join4, normalize, sep, isAbsolute, resolve as resolve2 } from "node:path";
 function setMemoryDirOverride(dir) {
   _overrideMemoryDir = dir;
 }
 function getAutoMemPath(workspace) {
-  const dir = _overrideMemoryDir ? isAbsolute(_overrideMemoryDir) ? _overrideMemoryDir : resolve2(workspace, _overrideMemoryDir) : join3(workspace, AUTO_MEM_DIRNAME);
+  const dir = _overrideMemoryDir ? isAbsolute(_overrideMemoryDir) ? _overrideMemoryDir : resolve2(workspace, _overrideMemoryDir) : join4(workspace, AUTO_MEM_DIRNAME);
   const normalized = normalize(dir);
   return (normalized + sep).normalize("NFC");
 }
 function getAutoMemEntrypoint(workspace) {
-  return join3(getAutoMemPath(workspace), ENTRYPOINT_NAME);
+  return join4(getAutoMemPath(workspace), ENTRYPOINT_NAME);
 }
 function isAutoMemPath(absolutePath, workspace) {
   const normalizedPath = normalize(absolutePath);
   return normalizedPath.startsWith(getAutoMemPath(workspace));
 }
 async function ensureMemoryDirExists(memoryDir) {
-  const fs28 = await import("node:fs");
+  const fs29 = await import("node:fs");
   try {
-    await fs28.promises.mkdir(memoryDir, { recursive: true });
+    await fs29.promises.mkdir(memoryDir, { recursive: true });
   } catch (e) {
     const code = e?.code;
     if (code !== "EEXIST") {
@@ -1899,7 +2022,7 @@ __export(memdir_exports, {
   truncateEntrypointContent: () => truncateEntrypointContent
 });
 import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function truncateEntrypointContent(raw) {
   const trimmed = raw.trim();
   const contentLines = trimmed.split("\n");
@@ -1992,7 +2115,7 @@ function buildMemoryLines(displayName, memoryDir, extraGuidelines, skipIndex = f
 }
 function buildMemoryPrompt(params) {
   const { displayName, memoryDir, extraGuidelines } = params;
-  const entrypoint = join4(memoryDir, ENTRYPOINT_NAME);
+  const entrypoint = join5(memoryDir, ENTRYPOINT_NAME);
   let entrypointContent = "";
   try {
     entrypointContent = readFileSync3(entrypoint, { encoding: "utf-8" });
@@ -2044,13 +2167,13 @@ __export(prompt_exports, {
   buildSystemPrompt: () => buildSystemPrompt,
   buildVolatileRuntimeContext: () => buildVolatileRuntimeContext
 });
-import * as path3 from "node:path";
-import * as fs3 from "node:fs";
+import * as path5 from "node:path";
+import * as fs5 from "node:fs";
 import * as os2 from "node:os";
 function readFileIfExists(filePath) {
   try {
-    if (fs3.existsSync(filePath)) {
-      return fs3.readFileSync(filePath, "utf-8");
+    if (fs5.existsSync(filePath)) {
+      return fs5.readFileSync(filePath, "utf-8");
     }
   } catch {
   }
@@ -2205,8 +2328,8 @@ function getEnvInfoSection(workspace) {
 function loadStaticFiles(workspace, staticFiles) {
   if (!staticFiles || staticFiles.length === 0) return null;
   const parts = [];
-  for (const file of staticFiles) {
-    const filePath = path3.isAbsolute(file) ? file : path3.join(workspace, file);
+  for (const file2 of staticFiles) {
+    const filePath = path5.isAbsolute(file2) ? file2 : path5.join(workspace, file2);
     const content = readFileIfExists(filePath);
     if (content) parts.push(content);
   }
@@ -2225,7 +2348,7 @@ function loadMemoryInstructions(workspace) {
   }
 }
 function resolveBlockContent(block, ctx) {
-  const overridePath = path3.join(ctx.workspace, "prompts", `${block.name}.md`);
+  const overridePath = path5.join(ctx.workspace, "prompts", `${block.name}.md`);
   const override = readFileIfExists(overridePath);
   if (override) return override;
   return block.generate(ctx);
@@ -2274,7 +2397,7 @@ function buildCustomPrompt(workspace, config) {
       continue;
     }
     if (name.endsWith(".md")) {
-      const filePath = path3.isAbsolute(name) ? name : path3.join(workspace, name);
+      const filePath = path5.isAbsolute(name) ? name : path5.join(workspace, name);
       const content = readFileIfExists(filePath);
       if (content) {
         parts.push(content);
@@ -2316,6 +2439,18 @@ ${skillsListing}`);
     loaded2.push("session-guidance");
   }
   parts.push(getEnvInfoSection(options.workspace));
+  const activeGoals = listGoals(options.workspace).filter((g) => g.status === "active" || g.status === "waiting" || g.status === "blocked");
+  if (activeGoals.length > 0) {
+    const summary = activeGoals.map((g) => {
+      const step = g.steps[g.currentStep];
+      return `- ${g.id} [${g.status}] ${g.objective}${step ? ` | current: ${step.title}` : ""}${g.blocker ? ` | blocker: ${g.blocker}` : ""}`;
+    }).join("\n");
+    parts.push(`# Active Goals
+${summary}
+
+Continue active goals across turns. Do not claim a goal is complete without updating its state.`);
+    loaded2.push("active-goals");
+  }
   console.log(`[dynamic-prompt] Loaded: ${loaded2.length > 0 ? loaded2.join(", ") : "(none)"}`);
   return parts.join("\n\n");
 }
@@ -2341,6 +2476,7 @@ var init_prompt = __esm({
   "src/prompt.ts"() {
     "use strict";
     init_registry();
+    init_store();
     init_memdir();
     init_paths();
     BASH_TOOL_NAME = "exec";
@@ -2366,7 +2502,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(path3.join(ctx.workspace, "SOUL.md")) },
+      { name: "soul", description: "SOUL.md \u4EBA\u683C\u8EAB\u4EFD", generate: (ctx) => readFileIfExists(path5.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（永远在最后）
@@ -4150,7 +4286,10 @@ async function executePreToolUseHooks(toolName, toolInput, ctx, signal) {
     transcript_path: "",
     cwd: ctx.cwd,
     tool_name: toolName,
-    tool_input: toolInput
+    tool_input: toolInput,
+    channel: ctx.channel,
+    // 让 callback hook 能判断来源（0905 skill-gate：channel allowlist 依赖此字段）
+    source: ctx.source || ""
   };
   return executeHooks("PreToolUse", hookInput, ctx, signal, toolName);
 }
@@ -4217,7 +4356,9 @@ async function executeUserPromptSubmitHooks(prompt, ctx, signal) {
     prompt,
     sender_id: ctx.senderId || "",
     channel_type: ctx.channelType || "",
-    source: ctx.source || ""
+    source: ctx.source || "",
+    channel: ctx.channel
+    // 让 callback hook 能判断来源（0905 skill-gate prompt 注入依赖）
   };
   return executeHooks("UserPromptSubmit", hookInput, ctx, signal);
 }
@@ -4664,8 +4805,8 @@ var init_attachments = __esm({
 });
 
 // src/utils/context-dump.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 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===",
@@ -4698,7 +4839,7 @@ function dumpApiRequest(opts) {
       lines.push(`[${i}] ${m.role}: (empty)`);
     }
   }
-  fs4.writeFileSync(path4.join(opts.workspace, ".context-debug.txt"), lines.join("\n") + "\n", "utf-8");
+  fs6.writeFileSync(path6.join(opts.workspace, ".context-debug.txt"), lines.join("\n") + "\n", "utf-8");
 }
 var init_context_dump = __esm({
   "src/utils/context-dump.ts"() {
@@ -5668,6 +5809,23 @@ var init_compact2 = __esm({
   }
 });
 
+// src/skills/skill-gate.ts
+function beginSkillGate(sessionId) {
+  if (loadedBySession.size >= MAX_TRACKED_SESSIONS && !loadedBySession.has(sessionId)) {
+    const oldest = loadedBySession.keys().next().value;
+    if (oldest !== void 0) loadedBySession.delete(oldest);
+  }
+  loadedBySession.set(sessionId, /* @__PURE__ */ new Set());
+}
+var loadedBySession, MAX_TRACKED_SESSIONS;
+var init_skill_gate = __esm({
+  "src/skills/skill-gate.ts"() {
+    "use strict";
+    loadedBySession = /* @__PURE__ */ new Map();
+    MAX_TRACKED_SESSIONS = 100;
+  }
+});
+
 // src/utils/context-analyzer.ts
 var context_analyzer_exports = {};
 __export(context_analyzer_exports, {
@@ -5676,8 +5834,8 @@ __export(context_analyzer_exports, {
   formatContextReport: () => formatContextReport,
   scanMemoryFiles: () => scanMemoryFiles
 });
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 function estimateMessageTokens2(m) {
   let tokens = 0;
   if (typeof m.content === "string") {
@@ -5787,9 +5945,9 @@ function breakdownMessages(messages) {
 }
 async function scanMemoryFiles(workspace) {
   const files = [];
-  const soul = readFileIfExists2(path5.join(workspace, "SOUL.md"));
+  const soul = readFileIfExists2(path7.join(workspace, "SOUL.md"));
   if (soul) files.push({ path: "SOUL.md", tokens: roughTokenCountEstimation(soul), stable: true });
-  const agents = readFileIfExists2(path5.join(workspace, "AGENTS.md"));
+  const agents = readFileIfExists2(path7.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));
@@ -5805,7 +5963,7 @@ async function scanMemoryFiles(workspace) {
 }
 function readFileIfExists2(filePath) {
   try {
-    if (fs5.existsSync(filePath)) return fs5.readFileSync(filePath, "utf-8");
+    if (fs7.existsSync(filePath)) return fs7.readFileSync(filePath, "utf-8");
   } catch {
   }
   return null;
@@ -5932,8 +6090,8 @@ function formatContextReport(report) {
 `;
     output += `|------|--------|
 `;
-    for (const file of stableFiles) {
-      output += `| ${file.path} | ${formatTokens(file.tokens)} |
+    for (const file2 of stableFiles) {
+      output += `| ${file2.path} | ${formatTokens(file2.tokens)} |
 `;
     }
     output += "\n";
@@ -5947,8 +6105,8 @@ function formatContextReport(report) {
 `;
     output += `|------|--------|
 `;
-    for (const file of dynamicFiles) {
-      output += `| ${file.path} | ${formatTokens(file.tokens)} |
+    for (const file2 of dynamicFiles) {
+      output += `| ${file2.path} | ${formatTokens(file2.tokens)} |
 `;
     }
     output += "\n";
@@ -6014,6 +6172,7 @@ var init_query = __esm({
     init_deferred();
     init_hooks();
     init_live();
+    init_skill_gate();
     QueryEngine = class _QueryEngine {
       constructor(provider, options) {
         this.provider = provider;
@@ -6140,6 +6299,7 @@ var init_query = __esm({
         let ac = new AbortController();
         this.abortController = ac;
         this.preQueryAbort = null;
+        beginSkillGate(context?.sessionId || "default");
         if (signal) {
           signal.addEventListener("abort", () => ac.abort(), { once: true });
         }
@@ -6456,6 +6616,7 @@ ${perTurnSystemDynamic}` : deferredHint || perTurnSystemDynamic;
                 channel: context?.channel || "",
                 cwd: context?.workspace || ""
               };
+              const gatedCalls = [];
               for (const tc of toolCalls) {
                 const toolName = tc.function?.name || tc.name || "unknown";
                 let toolInput = {};
@@ -6470,11 +6631,35 @@ ${perTurnSystemDynamic}` : deferredHint || perTurnSystemDynamic;
                   }
                   if (preResult.preventContinuation) {
                     console.log(`[hook] PreToolUse ${toolName}: blocked - ${preResult.stopReason || "no reason"}`);
+                    gatedCalls.push({
+                      call: tc,
+                      text: preResult.additionalContexts?.join("\n") || preResult.stopReason || `Tool ${toolName} was blocked by a hook.`
+                    });
                   }
                 } catch (e) {
                   console.warn(`[hook] PreToolUse ${toolName} error: ${e.message}`);
                 }
               }
+              if (gatedCalls.length > 0) {
+                const gatedTexts = new Map(gatedCalls.map((g) => [g.call.id, g.text]));
+                const blockResults = toolCalls.map(
+                  (tc) => msg.tool(tc.id, gatedTexts.get(tc.id) || "\u672C\u8F6E\u6709\u5176\u4ED6\u8C03\u7528\u88AB\u95E8\u7981\u62E6\u4E0B\uFF0C\u6574\u6279\u672A\u6267\u884C\uFF1B\u8BF7\u5148\u6309\u63D0\u793A\u52A0\u8F7D Skill \u518D\u91CD\u8BD5\u3002", true)
+                );
+                const gateAssistant = msg.assistant(textContent, toolCalls);
+                if (turnThinking) {
+                  gateAssistant.reasoning_content = turnThinking;
+                  if (turnThinkingSig) gateAssistant.thinking_signature = turnThinkingSig;
+                }
+                turnThinking = "";
+                turnThinkingSig = "";
+                currentMessages.push(gateAssistant);
+                currentMessages.push(...blockResults);
+                for (const g of gatedCalls) {
+                  yield { type: "tool_result", tool: g.call.function?.name, tool_call_id: g.call.id, summary: g.text.slice(0, 200), isError: true };
+                }
+                yield { type: "history", messages: [msg.assistant(textContent, toolCalls), ...blockResults] };
+                continue;
+              }
               const vcPlaceholderOn = context?.channel === "voice-chat" && (liveConfig.get("voiceChat.placeholder.enabled") ?? true);
               const vcTimer = vcPlaceholderOn ? setTimeout(() => {
                 _QueryEngine.tryVoicePlaceholder(context).catch(() => {
@@ -6634,8 +6819,8 @@ ${perTurnSystemDynamic}` : deferredHint || perTurnSystemDynamic;
 });
 
 // src/session/writer.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
 import * as crypto2 from "node:crypto";
 var SessionWriter;
 var init_writer = __esm({
@@ -6658,7 +6843,7 @@ var init_writer = __esm({
         this.sessionId = sessionId || crypto2.randomUUID();
         this.engineSessionId = "";
         const filename = `${this.sessionId}.jsonl`;
-        this.filePath = path6.join(sessionsDir, filename);
+        this.filePath = path8.join(sessionsDir, filename);
       }
       get id() {
         return this.sessionId;
@@ -6669,9 +6854,9 @@ var init_writer = __esm({
       /** 打开文件写入 header（新文件才写 header） */
       open(cwd, engineSessionId) {
         this.engineSessionId = engineSessionId || "";
-        fs6.mkdirSync(path6.dirname(this.filePath), { recursive: true });
-        const fileExists = fs6.existsSync(this.filePath) && fs6.statSync(this.filePath).size > 0;
-        this.stream = fs6.createWriteStream(this.filePath, { flags: "a" });
+        fs8.mkdirSync(path8.dirname(this.filePath), { recursive: true });
+        const fileExists = fs8.existsSync(this.filePath) && fs8.statSync(this.filePath).size > 0;
+        this.stream = fs8.createWriteStream(this.filePath, { flags: "a" });
         this.stream.on("error", (err) => {
           console.error(`[SessionWriter] write error on ${this.filePath}:`, err.message);
         });
@@ -6871,17 +7056,17 @@ var init_writer = __esm({
           this.stream.end();
           this.stream = null;
         }
-        if (!fs6.existsSync(this.filePath)) return null;
-        const fileSize = fs6.statSync(this.filePath).size;
+        if (!fs8.existsSync(this.filePath)) return null;
+        const fileSize = fs8.statSync(this.filePath).size;
         if (fileSize === 0) return null;
         const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
         const archivedPath = `${this.filePath}.${reason}.${ts}`;
-        fs6.renameSync(this.filePath, archivedPath);
+        fs8.renameSync(this.filePath, archivedPath);
         const sizeMB = (fileSize / 1024 / 1024).toFixed(1);
-        console.log(`[SessionWriter] Archived JSONL: ${path6.basename(this.filePath)} \u2192 ${path6.basename(archivedPath)} (${sizeMB}MB)`);
+        console.log(`[SessionWriter] Archived JSONL: ${path8.basename(this.filePath)} \u2192 ${path8.basename(archivedPath)} (${sizeMB}MB)`);
         const postBoundaryData = this.readPostBoundaryFromArchived(archivedPath);
-        const dir = path6.dirname(this.filePath);
-        fs6.mkdirSync(dir, { recursive: true });
+        const dir = path8.dirname(this.filePath);
+        fs8.mkdirSync(dir, { recursive: true });
         const header = {
           type: "session",
           version: 3,
@@ -6895,8 +7080,8 @@ var init_writer = __esm({
         if (postBoundaryData.length > 0) {
           initialData += postBoundaryData.toString("utf-8");
         }
-        fs6.writeFileSync(this.filePath, initialData, "utf-8");
-        this.stream = fs6.createWriteStream(this.filePath, { flags: "a" });
+        fs8.writeFileSync(this.filePath, initialData, "utf-8");
+        this.stream = fs8.createWriteStream(this.filePath, { flags: "a" });
         this.stream.on("error", (err) => {
           console.error(`[SessionWriter] write error on ${this.filePath}:`, err.message);
         });
@@ -6906,10 +7091,10 @@ var init_writer = __esm({
        * 从归档文件中读取最后一个 compact_boundary 之后的内容
        */
       readPostBoundaryFromArchived(archivedPath) {
-        const fileSize = fs6.statSync(archivedPath).size;
+        const fileSize = fs8.statSync(archivedPath).size;
         if (fileSize === 0) return Buffer.alloc(0);
         if (fileSize <= 5 * 1024 * 1024) {
-          const content = fs6.readFileSync(archivedPath, "utf-8");
+          const content = fs8.readFileSync(archivedPath, "utf-8");
           const lines = content.split("\n");
           let lastBoundaryIdx = -1;
           for (let i = lines.length - 1; i >= 0; i--) {
@@ -6926,11 +7111,11 @@ var init_writer = __esm({
         {
           const probeSize = Math.min(fileSize, 1024 * 1024);
           const probeBuf = Buffer.allocUnsafe(probeSize);
-          const probeFd = fs6.openSync(archivedPath, "r");
+          const probeFd = fs8.openSync(archivedPath, "r");
           let hasBoundary = false;
           let probed = 0;
           while (probed < fileSize) {
-            const n = fs6.readSync(probeFd, probeBuf, 0, Math.min(probeSize, fileSize - probed), probed);
+            const n = fs8.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;
@@ -6938,19 +7123,19 @@ var init_writer = __esm({
             }
             probed += n;
           }
-          fs6.closeSync(probeFd);
+          fs8.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 = fs6.openSync(archivedPath, "r");
+        const fd = fs8.openSync(archivedPath, "r");
         try {
           let filePos = 0;
           let carryBuf;
           let carryLen = 0;
           while (filePos < fileSize) {
-            const bytesRead = fs6.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
+            const bytesRead = fs8.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
             if (bytesRead === 0) break;
             filePos += bytesRead;
             let scanBuf;
@@ -6999,7 +7184,7 @@ var init_writer = __esm({
             }
           }
         } finally {
-          fs6.closeSync(fd);
+          fs8.closeSync(fd);
         }
         return outBuf.subarray(0, outLen);
       }
@@ -7011,15 +7196,15 @@ var init_writer = __esm({
        */
       readLastId() {
         try {
-          const stat4 = fs6.statSync(this.filePath);
+          const stat4 = fs8.statSync(this.filePath);
           if (stat4.size === 0) return null;
           const readSize = Math.min(stat4.size, 4096);
           const buf = Buffer.alloc(readSize);
-          const fd = fs6.openSync(this.filePath, "r");
+          const fd = fs8.openSync(this.filePath, "r");
           try {
-            fs6.readSync(fd, buf, 0, readSize, stat4.size - readSize);
+            fs8.readSync(fd, buf, 0, readSize, stat4.size - readSize);
           } finally {
-            fs6.closeSync(fd);
+            fs8.closeSync(fd);
           }
           const text = buf.toString("utf-8");
           const lines = text.split("\n").filter((l) => l.trim().length > 0);
@@ -7066,11 +7251,11 @@ var init_writer = __esm({
 });
 
 // src/session/reader.ts
-import * as fs7 from "node:fs";
-import * as path7 from "node:path";
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
 import * as readline from "node:readline";
 async function readSessionHeader(filePath) {
-  const stream = fs7.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs9.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream });
   return new Promise((resolve11) => {
     let resolved = false;
@@ -7101,7 +7286,7 @@ async function readSessionHeader(filePath) {
   });
 }
 async function readLargeFilePostBoundary(filePath) {
-  const stat4 = fs7.statSync(filePath);
+  const stat4 = fs9.statSync(filePath);
   const fileSize = stat4.size;
   const boundaryMarker = '"compact_boundary"';
   const CHUNK_SIZE = TRANSCRIPT_READ_CHUNK_SIZE;
@@ -7109,13 +7294,13 @@ async function readLargeFilePostBoundary(filePath) {
   let outLen = 0;
   let boundaryStartOffset = 0;
   const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
-  const fd = fs7.openSync(filePath, "r");
+  const fd = fs9.openSync(filePath, "r");
   try {
     let filePos = 0;
     let carryBuf;
     let carryLen = 0;
     while (filePos < fileSize) {
-      const bytesRead = fs7.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
+      const bytesRead = fs9.readSync(fd, chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
       if (bytesRead === 0) break;
       filePos += bytesRead;
       let scanBuf;
@@ -7167,7 +7352,7 @@ async function readLargeFilePostBoundary(filePath) {
       }
     }
   } finally {
-    fs7.closeSync(fd);
+    fs9.closeSync(fd);
   }
   const postBoundaryText = outBuf.subarray(0, outLen).toString("utf-8");
   return postBoundaryText.split("\n").filter((l) => l.trim().length > 0);
@@ -7291,7 +7476,7 @@ function recoverOrphanedParallelToolResults(allEntries, chain, byUuid, seen) {
   return result2;
 }
 async function readSessionHistory(filePath) {
-  const stat4 = fs7.statSync(filePath);
+  const stat4 = fs9.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`);
@@ -7318,12 +7503,19 @@ async function readSessionHistory(filePath) {
   let filtered = filterUnresolvedToolUses(sessionMsgs);
   filtered = filterOrphanedThinkingOnly(filtered);
   filtered = filterWhitespaceOnlyAssistant(filtered);
-  const sessionStarts = attachmentMsgs.filter((m) => m.attachment.type === "session_start");
-  const restAttachments = attachmentMsgs.filter((m) => m.attachment.type !== "session_start");
+  const seenStartTexts = /* @__PURE__ */ new Set();
+  const sessionStarts = attachmentMsgs.filter((m) => {
+    if (m.attachment.type !== "session_start") return false;
+    const key = JSON.stringify(m.attachment);
+    if (seenStartTexts.has(key)) return false;
+    seenStartTexts.add(key);
+    return true;
+  });
+  const restAttachments = attachmentMsgs.filter((m) => m.type === "attachment" && m.attachment.type !== "session_start");
   return [...sessionStarts, ...filtered, ...restAttachments];
 }
 async function readAllLines(filePath) {
-  const stream = fs7.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs9.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream });
   const lines = [];
   return new Promise((resolve11, reject) => {
@@ -7473,12 +7665,12 @@ function extractText2(content) {
   return content.filter((b) => b.type === "text").map((b) => b.text || "").join("") || null;
 }
 function listSessions(sessionsDir) {
-  if (!fs7.existsSync(sessionsDir)) return [];
-  const files = fs7.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") || f.includes(".jsonl.")).map((f) => ({
-    file: path7.join(sessionsDir, f),
+  if (!fs9.existsSync(sessionsDir)) return [];
+  const files = fs9.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") || f.includes(".jsonl.")).map((f) => ({
+    file: path9.join(sessionsDir, f),
     id: f.replace(/\.jsonl.*$/, ""),
     // strip .jsonl and everything after (archived suffix)
-    modified: new Date(fs7.statSync(path7.join(sessionsDir, f)).mtimeMs)
+    modified: new Date(fs9.statSync(path9.join(sessionsDir, f)).mtimeMs)
   })).sort((a, b) => b.modified.getTime() - a.modified.getTime());
   return files;
 }
@@ -7498,8 +7690,8 @@ var session_manager_exports = {};
 __export(session_manager_exports, {
   SessionManager: () => SessionManager
 });
-import * as path8 from "node:path";
-import * as fs8 from "node:fs";
+import * as path10 from "node:path";
+import * as fs10 from "node:fs";
 import * as crypto3 from "node:crypto";
 var RESTORE_MAX_CHARS, CHARS_PER_TOKEN, SessionManager;
 var init_session_manager = __esm({
@@ -7531,24 +7723,24 @@ var init_session_manager = __esm({
       constructor(config) {
         this.config = config;
         this.scopeConfig = config.scopeConfig;
-        this.sessionsDir = path8.join(config.stateDir, "agents", "main", "sessions");
-        this.indexPath = path8.join(this.sessionsDir, "session-index.json");
-        this.platformMapPath = path8.join(this.sessionsDir, "platform-map.json");
-        fs8.mkdirSync(this.sessionsDir, { recursive: true });
+        this.sessionsDir = path10.join(config.stateDir, "agents", "main", "sessions");
+        this.indexPath = path10.join(this.sessionsDir, "session-index.json");
+        this.platformMapPath = path10.join(this.sessionsDir, "platform-map.json");
+        fs10.mkdirSync(this.sessionsDir, { recursive: true });
       }
       // === 索引操作 ===
       loadIndex() {
         try {
-          if (fs8.existsSync(this.indexPath)) {
-            const raw = fs8.readFileSync(this.indexPath, "utf-8");
+          if (fs10.existsSync(this.indexPath)) {
+            const raw = fs10.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 (fs8.existsSync(entry.file)) continue;
-              const basename8 = path8.basename(entry.file);
-              const localPath = path8.join(this.sessionsDir, basename8);
-              if (fs8.existsSync(localPath)) {
+              if (fs10.existsSync(entry.file)) continue;
+              const basename8 = path10.basename(entry.file);
+              const localPath = path10.join(this.sessionsDir, basename8);
+              if (fs10.existsSync(localPath)) {
                 entry.file = localPath;
                 fixed++;
               }
@@ -7567,7 +7759,7 @@ var init_session_manager = __esm({
         try {
           const obj = {};
           for (const [k, v] of this.index) obj[k] = v;
-          fs8.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
+          fs10.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2));
         } catch (err) {
           console.error(`[session] Failed to save index: ${err.message}`);
         }
@@ -7575,8 +7767,8 @@ var init_session_manager = __esm({
       // === 平台映射 ===
       loadPlatformMap() {
         try {
-          if (fs8.existsSync(this.platformMapPath)) {
-            const raw = fs8.readFileSync(this.platformMapPath, "utf-8");
+          if (fs10.existsSync(this.platformMapPath)) {
+            const raw = fs10.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`);
@@ -7588,7 +7780,7 @@ var init_session_manager = __esm({
         try {
           const obj = {};
           for (const [k, v] of this.platformMap) obj[k] = v;
-          fs8.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
+          fs10.writeFileSync(this.platformMapPath, JSON.stringify(obj, null, 2));
         } catch (err) {
           console.error(`[session] Failed to save platform map: ${err.message}`);
         }
@@ -7627,17 +7819,17 @@ var init_session_manager = __esm({
        */
       getSessionFilePath(sessionId) {
         const entry = this.index.get(sessionId);
-        if (entry && fs8.existsSync(entry.file)) return entry.file;
-        const direct = path8.join(this.sessionsDir, `${sessionId}.jsonl`);
-        return fs8.existsSync(direct) ? direct : null;
+        if (entry && fs10.existsSync(entry.file)) return entry.file;
+        const direct = path10.join(this.sessionsDir, `${sessionId}.jsonl`);
+        return fs10.existsSync(direct) ? direct : null;
       }
       // === Writer 管理 ===
       getWriter(sessionId) {
         let writer = this.writers.get(sessionId);
         if (!writer) {
           const existing = this.index.get(sessionId);
-          if (existing && fs8.existsSync(existing.file)) {
-            const existingFileId = path8.basename(existing.file, ".jsonl");
+          if (existing && fs10.existsSync(existing.file)) {
+            const existingFileId = path10.basename(existing.file, ".jsonl");
             writer = new SessionWriter(this.sessionsDir, existingFileId);
             writer.open(this.config.workspace, sessionId);
           } else {
@@ -7649,7 +7841,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 ${path8.basename(writer.path)}`);
+          console.log(`[session] ${existing ? "Resumed" : "New"}: ${sessionId} \u2192 ${path10.basename(writer.path)}`);
         }
         return writer;
       }
@@ -7668,7 +7860,7 @@ var init_session_manager = __esm({
         if (!writer) return null;
         try {
           this.lastArchiveCheck = Date.now();
-          const stat4 = fs8.statSync(writer.path);
+          const stat4 = fs10.statSync(writer.path);
           if (stat4.size < threshold) return null;
           const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
           const thresholdMB = (threshold / 1024 / 1024).toFixed(1);
@@ -7677,10 +7869,10 @@ var init_session_manager = __esm({
           if (archivedPath) {
             this.index.set(sessionId, { file: writer.path, updatedAt: Date.now() });
             this.saveIndex();
-            const newSize = fs8.statSync(writer.path).size;
+            const newSize = fs10.statSync(writer.path).size;
             const oldSizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-            console.log(`[session] Archive complete: ${path8.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
-            const fileId = path8.basename(writer.path).replace(/\.jsonl$/, "");
+            console.log(`[session] Archive complete: ${path10.basename(archivedPath)} (${oldSizeMB}MB) \u2192 new JSONL created (${newSize} bytes)`);
+            const fileId = path10.basename(writer.path).replace(/\.jsonl$/, "");
             this.purgeOldArchives(fileId, 3);
             return archivedPath;
           }
@@ -7696,15 +7888,15 @@ var init_session_manager = __esm({
       purgeOldArchives(sessionId, keepCount = 3) {
         try {
           const dir = this.sessionsDir;
-          if (!fs8.existsSync(dir)) return;
-          const allFiles = fs8.readdirSync(dir);
+          if (!fs10.existsSync(dir)) return;
+          const allFiles = fs10.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: path8.join(dir, f),
-            mtime: fs8.statSync(path8.join(dir, f)).mtimeMs
+            path: path10.join(dir, f),
+            mtime: fs10.statSync(path10.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;
@@ -7714,7 +7906,7 @@ var init_session_manager = __esm({
               console.log(`[session] Skipping archived (kept for history): ${f.name}`);
               continue;
             }
-            fs8.unlinkSync(f.path);
+            fs10.unlinkSync(f.path);
             console.log(`[session] Purged old archive: ${f.name}`);
           }
           if (toDelete.length > 0) {
@@ -7763,29 +7955,29 @@ var init_session_manager = __esm({
       /** 列出 session 的所有文件（当前 + 归档），按修改时间排序 */
       findAllSessionFiles(sessionId) {
         const results = [];
-        const mainFile = path8.join(this.sessionsDir, `${sessionId}.jsonl`);
-        if (fs8.existsSync(mainFile)) {
+        const mainFile = path10.join(this.sessionsDir, `${sessionId}.jsonl`);
+        if (fs10.existsSync(mainFile)) {
           results.push(mainFile);
         }
-        if (fs8.existsSync(this.sessionsDir)) {
-          const compactionFiles = fs8.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
+        if (fs10.existsSync(this.sessionsDir)) {
+          const compactionFiles = fs10.readdirSync(this.sessionsDir).filter((f) => f.startsWith(`${sessionId}.jsonl.compaction.`)).map((f) => ({
             name: f,
-            path: path8.join(this.sessionsDir, f),
-            mtime: fs8.statSync(path8.join(this.sessionsDir, f)).mtimeMs
+            path: path10.join(this.sessionsDir, f),
+            mtime: fs10.statSync(path10.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 = fs8.statSync(a).mtimeMs;
-          const tb = fs8.statSync(b).mtimeMs;
+          const ta = fs10.statSync(a).mtimeMs;
+          const tb = fs10.statSync(b).mtimeMs;
           return ta - tb;
         });
         return results;
       }
       async findSessionFiles(sessionId) {
-        if (!fs8.existsSync(this.sessionsDir)) {
+        if (!fs10.existsSync(this.sessionsDir)) {
           console.log(`[session:find] SESSIONS_DIR not found: ${this.sessionsDir}`);
           return [];
         }
@@ -7797,15 +7989,15 @@ var init_session_manager = __esm({
             return mappedFiles;
           }
           const indexedEntry = this.index.get(mappedId);
-          if (indexedEntry && fs8.existsSync(indexedEntry.file)) {
-            const fileUuid = path8.basename(indexedEntry.file, ".jsonl");
+          if (indexedEntry && fs10.existsSync(indexedEntry.file)) {
+            const fileUuid = path10.basename(indexedEntry.file, ".jsonl");
             return this.findAllSessionFiles(fileUuid);
           }
         }
         const allFiles = this.findAllSessionFiles(sessionId);
         if (allFiles.length > 0) {
           const labels = allFiles.map((f) => {
-            const base = path8.basename(f);
+            const base = path10.basename(f);
             return base.endsWith(".jsonl") ? base : `${base} (archived)`;
           });
           console.log(`[session:find] Found ${allFiles.length} file(s) for ${sessionId}: ${labels.join(", ")}`);
@@ -7813,9 +8005,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=${fs8.existsSync(indexed.file)})`);
-          if (fs8.existsSync(indexed.file)) {
-            return this.findAllSessionFiles(path8.basename(indexed.file, ".jsonl"));
+          console.log(`[session:find] Index hit: ${sessionId} \u2192 ${indexed.file} (exists=${fs10.existsSync(indexed.file)})`);
+          if (fs10.existsSync(indexed.file)) {
+            return this.findAllSessionFiles(path10.basename(indexed.file, ".jsonl"));
           }
         } else {
           console.log(`[session:find] Index miss: ${sessionId} (index has ${this.index.size} entries)`);
@@ -7844,8 +8036,8 @@ var init_session_manager = __esm({
           return [];
         }
         files.sort((a, b) => {
-          const ta = fs8.statSync(a).mtimeMs;
-          const tb = fs8.statSync(b).mtimeMs;
+          const ta = fs10.statSync(a).mtimeMs;
+          const tb = fs10.statSync(b).mtimeMs;
           return ta - tb;
         });
         const latestFile = files[files.length - 1];
@@ -7853,11 +8045,11 @@ 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 ${path8.basename(latestFile)}`);
+          console.log(`[session:restore] Synced index: ${sessionId} \u2192 ${path10.basename(latestFile)}`);
         }
         const allMessages = [];
-        for (const file of files) {
-          const sessionMsgs = await readSessionHistory(file);
+        for (const file2 of files) {
+          const sessionMsgs = await readSessionHistory(file2);
           for (const m of sessionMsgs) {
             if (isAttachmentMessage(m)) {
               allMessages.push(m);
@@ -7889,7 +8081,7 @@ var init_session_manager = __esm({
           if (isAttachmentMessage(m) && m.attachment.type === "relevant_memories") {
             for (const mem of m.attachment.memories) {
               rawCount++;
-              restoredPaths.add(path8.resolve(mem.path));
+              restoredPaths.add(path10.resolve(mem.path));
             }
           }
         }
@@ -7918,15 +8110,15 @@ var init_session_manager = __esm({
        */
       rotateMainSession() {
         const entry = this.index.get("main");
-        if (!entry || !fs8.existsSync(entry.file)) return;
-        const oldFileId = path8.basename(entry.file, ".jsonl");
-        const stat4 = fs8.statSync(entry.file);
+        if (!entry || !fs10.existsSync(entry.file)) return;
+        const oldFileId = path10.basename(entry.file, ".jsonl");
+        const stat4 = fs10.statSync(entry.file);
         if (stat4.size < 1024) return;
         const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
         const archivedPath = `${entry.file}.archived.${ts}`;
-        fs8.renameSync(entry.file, archivedPath);
+        fs10.renameSync(entry.file, archivedPath);
         const sizeMB = (stat4.size / 1024 / 1024).toFixed(1);
-        console.log(`[session] Archived: ${path8.basename(entry.file)} \u2192 ${path8.basename(archivedPath)} (${sizeMB}MB)`);
+        console.log(`[session] Archived: ${path10.basename(entry.file)} \u2192 ${path10.basename(archivedPath)} (${sizeMB}MB)`);
         const newWriter = new SessionWriter(this.sessionsDir);
         newWriter.open(this.config.workspace, "main");
         newWriter.writeModelChange(this.config.providerId, this.config.model);
@@ -7935,7 +8127,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 ${path8.basename(newPath)}`);
+        console.log(`[session] Rotated main: ${oldFileId}.jsonl \u2192 ${path10.basename(newPath)}`);
       }
       // === 迁移 ===
       /** 迁移旧索引：session-index.json 里有 "discord:xxx" 格式的 key 时，生成 UUID 替换 */
@@ -8000,7 +8192,7 @@ var init_session_manager = __esm({
 });
 
 // src/utils/path.ts
-import * as path9 from "node:path";
+import * as path11 from "node:path";
 function fixMsysPath(p) {
   let fixed = p.includes("\\") ? p.replace(/\\/g, "/") : p;
   if (process.platform === "win32") {
@@ -8010,15 +8202,15 @@ function fixMsysPath(p) {
 }
 function resolvePath(p, workspace) {
   const fixed = fixMsysPath(p);
-  const resolved = path9.isAbsolute(fixed) ? path9.normalize(fixed) : path9.resolve(workspace, fixed);
-  const normalized = path9.normalize(resolved);
-  const normalizedWorkspace = path9.normalize(workspace);
+  const resolved = path11.isAbsolute(fixed) ? path11.normalize(fixed) : path11.resolve(workspace, fixed);
+  const normalized = path11.normalize(resolved);
+  const normalizedWorkspace = path11.normalize(workspace);
   if (sandboxOff) return normalized;
-  if (normalized === normalizedWorkspace || normalized.startsWith(normalizedWorkspace + path9.sep)) {
+  if (normalized === normalizedWorkspace || normalized.startsWith(normalizedWorkspace + path11.sep)) {
     return normalized;
   }
   for (const allowed of extraAllowedPaths) {
-    if (normalized === allowed || normalized.startsWith(allowed + path9.sep)) {
+    if (normalized === allowed || normalized.startsWith(allowed + path11.sep)) {
       return normalized;
     }
   }
@@ -8034,15 +8226,15 @@ var init_path = __esm({
 });
 
 // src/tools/read.ts
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
+import * as fs11 from "node:fs";
+import * as path12 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 = fs9.statSync(filePath);
+  const stat4 = fs11.statSync(filePath);
   const mtimeMs = stat4.mtimeMs;
   const prev = readHistory.get(filePath);
   if (prev && prev.offset === offset && prev.limit === limit && prev.mtimeMs === mtimeMs) {
@@ -8056,19 +8248,19 @@ function checkReadLoop(filePath, offset, limit) {
   return null;
 }
 function readFileContent(filePath) {
-  const fd = fs9.openSync(filePath, "r");
+  const fd = fs11.openSync(filePath, "r");
   const bom = Buffer.alloc(2);
-  fs9.readSync(fd, bom, 0, 2, 0);
-  fs9.closeSync(fd);
+  fs11.readSync(fd, bom, 0, 2, 0);
+  fs11.closeSync(fd);
   let encoding = "utf8";
   if (bom[0] === 255 && bom[1] === 254) {
     encoding = "utf16le";
   }
-  const stat4 = fs9.statSync(filePath);
+  const stat4 = fs11.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 = fs9.readFileSync(filePath, encoding);
+  const raw = fs11.readFileSync(filePath, encoding);
   const content = raw.toString().replaceAll("\r\n", "\n");
   return { content, encoding };
 }
@@ -8210,11 +8402,11 @@ Usage:
         } catch (e) {
           return { content: e.message, isError: true };
         }
-        if (!fs9.existsSync(filePath)) {
+        if (!fs11.existsSync(filePath)) {
           return { content: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, isError: true };
         }
-        const stat4 = fs9.statSync(filePath);
-        const baseName = path10.basename(filePath).toUpperCase();
+        const stat4 = fs11.statSync(filePath);
+        const baseName = path12.basename(filePath).toUpperCase();
         if (BLOCKED_BASENAMES.has(baseName)) {
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6: ${filePath}`, isError: true };
         }
@@ -8222,11 +8414,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 = fs9.readdirSync(filePath);
+          const entries2 = fs11.readdirSync(filePath);
           const items = entries2.map((e) => {
-            const full = path10.join(filePath, e);
+            const full = path12.join(filePath, e);
             try {
-              const s = fs9.statSync(full);
+              const s = fs11.statSync(full);
               return s.isDirectory() ? `${e}/` : e;
             } catch {
               return e;
@@ -8235,7 +8427,7 @@ Usage:
           return { content: `\u76EE\u5F55 (${entries2.length} \u9879):
 ${items.join("\n")}` };
         }
-        const ext = path10.extname(filePath).toLowerCase();
+        const ext = path12.extname(filePath).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext)) {
           return { content: `\u4E8C\u8FDB\u5236\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6 (${ext}): ${filePath}`, isError: true };
         }
@@ -8282,22 +8474,22 @@ ${result2}` : result2 };
 });
 
 // src/tools/write.ts
-import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as fs12 from "node:fs";
+import * as path13 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";
-  fs10.writeFileSync(tmpPath, content, "utf-8");
+  fs12.writeFileSync(tmpPath, content, "utf-8");
   try {
-    fs10.renameSync(tmpPath, filePath);
+    fs12.renameSync(tmpPath, filePath);
   } catch (e) {
     try {
-      fs10.unlinkSync(tmpPath);
+      fs12.unlinkSync(tmpPath);
     } catch {
     }
-    fs10.writeFileSync(filePath, content, "utf-8");
+    fs12.writeFileSync(filePath, content, "utf-8");
   }
 }
 function simpleDiff(oldContent, newContent) {
@@ -8391,15 +8583,15 @@ Usage:
         }
         const rawContent = args.content;
         const content = rawContent.replaceAll("\r\n", "\n");
-        if (fs10.existsSync(filePath) && fs10.statSync(filePath).isDirectory()) {
+        if (fs12.existsSync(filePath) && fs12.statSync(filePath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
         }
         let oldContent = null;
         let isCreate = true;
-        if (fs10.existsSync(filePath)) {
+        if (fs12.existsSync(filePath)) {
           isCreate = false;
           try {
-            oldContent = fs10.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            oldContent = fs12.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
           } catch {
             isCreate = true;
           }
@@ -8415,10 +8607,10 @@ Usage:
               isError: true
             };
           }
-          const currentStat = fs10.statSync(filePath);
+          const currentStat = fs12.statSync(filePath);
           const lastWriteTime = Math.floor(currentStat.mtimeMs);
           if (lastWriteTime > readState.timestamp) {
-            const currentContent = fs10.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            const currentContent = fs12.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}`,
@@ -8427,9 +8619,9 @@ Usage:
             }
           }
         }
-        const dir = path11.dirname(filePath);
+        const dir = path13.dirname(filePath);
         try {
-          fs10.mkdirSync(dir, { recursive: true });
+          fs12.mkdirSync(dir, { recursive: true });
         } catch (e) {
           return { content: `\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${dir} \u2014 ${e.message}`, isError: true };
         }
@@ -8438,11 +8630,11 @@ Usage:
         } catch (e) {
           return { content: `\u5199\u5165\u5931\u8D25: ${e.message}`, isError: true };
         }
-        readFileState.set(filePath, { timestamp: fs10.statSync(filePath).mtimeMs });
+        readFileState.set(filePath, { timestamp: fs12.statSync(filePath).mtimeMs });
         const action = isCreate ? "\u521B\u5EFA" : "\u66F4\u65B0";
         const lines = content.split("\n").length;
         const chars = content.length;
-        const stat4 = fs10.statSync(filePath);
+        const stat4 = fs12.statSync(filePath);
         let diff = "";
         if (!isCreate && oldContent !== null) {
           diff = `
@@ -8461,8 +8653,8 @@ ${simpleDiff(oldContent, content)}`;
 });
 
 // src/tools/edit.ts
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as fs13 from "node:fs";
+import * as path14 from "node:path";
 function normalizeQuotes(str) {
   return str.replaceAll(LEFT_SINGLE_CURLY, "'").replaceAll(RIGHT_SINGLE_CURLY, "'").replaceAll(LEFT_DOUBLE_CURLY, '"').replaceAll(RIGHT_DOUBLE_CURLY, '"');
 }
@@ -8615,7 +8807,7 @@ Usage:
         }
         let fileContent = null;
         try {
-          const stat4 = fs11.statSync(filePath);
+          const stat4 = fs13.statSync(filePath);
           if (stat4.isDirectory()) {
             return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
           }
@@ -8625,21 +8817,21 @@ Usage:
         } catch (e) {
           if (e.code === "ENOENT") {
             if (oldString === "") {
-              const dir = path12.dirname(filePath);
-              fs11.mkdirSync(dir, { recursive: true });
-              fs11.writeFileSync(filePath, newString, "utf-8");
-              readFileState.set(filePath, { timestamp: fs11.statSync(filePath).mtimeMs });
+              const dir = path14.dirname(filePath);
+              fs13.mkdirSync(dir, { recursive: true });
+              fs13.writeFileSync(filePath, newString, "utf-8");
+              readFileState.set(filePath, { timestamp: fs13.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 = fs11.readFileSync(filePath, "utf-8");
+        const rawContent = fs13.readFileSync(filePath, "utf-8");
         fileContent = rawContent.replaceAll("\r\n", "\n");
         if (oldString === "" && fileContent.trim() === "") {
-          fs11.writeFileSync(filePath, newString, "utf-8");
-          readFileState.set(filePath, { timestamp: fs11.statSync(filePath).mtimeMs });
+          fs13.writeFileSync(filePath, newString, "utf-8");
+          readFileState.set(filePath, { timestamp: fs13.statSync(filePath).mtimeMs });
           return { content: `\u5199\u5165\u7A7A\u6587\u4EF6: ${filePath} (${newString.split("\n").length} \u884C)` };
         }
         const readState = readFileState.get(filePath);
@@ -8649,11 +8841,11 @@ Usage:
             isError: true
           };
         }
-        const currentStat = fs11.statSync(filePath);
+        const currentStat = fs13.statSync(filePath);
         const lastWriteTime = Math.floor(currentStat.mtimeMs);
         if (lastWriteTime > readState.timestamp) {
           if (fileContent !== rawContent.replaceAll("\r\n", "\n")) {
-            if (fileContent !== fs11.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n")) {
+            if (fileContent !== fs13.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
@@ -8685,8 +8877,8 @@ ${preview}
         const actualNewString = preserveQuoteStyle(oldString, actualOldString, newString);
         const diffView = generateEditDiff(fileContent, actualOldString, actualNewString);
         const newContent = applyEditToFile(fileContent, actualOldString, actualNewString, replaceAll);
-        fs11.writeFileSync(filePath, newContent, "utf-8");
-        readFileState.set(filePath, { timestamp: fs11.statSync(filePath).mtimeMs });
+        fs13.writeFileSync(filePath, newContent, "utf-8");
+        readFileState.set(filePath, { timestamp: fs13.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`;
@@ -8703,8 +8895,8 @@ ${diffView}`
 });
 
 // src/tools/glob.ts
-import * as fs12 from "node:fs";
-import * as path13 from "node:path";
+import * as fs14 from "node:fs";
+import * as path15 from "node:path";
 function globMatch(pattern, filename) {
   const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   try {
@@ -8724,18 +8916,18 @@ function findFiles(dir, pattern, limit, baseDir) {
     }
     let entries2;
     try {
-      entries2 = fs12.readdirSync(currentDir, { withFileTypes: true });
+      entries2 = fs14.readdirSync(currentDir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries2) {
       if (truncated) return;
-      const fullPath = path13.join(currentDir, entry.name);
+      const fullPath = path15.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (VCS_DIRS.has(entry.name)) continue;
         walk(fullPath);
       } else if (entry.isFile()) {
-        const relativePath = path13.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = path15.relative(baseDir, fullPath).replace(/\\/g, "/");
         const patternsToTry = [pattern];
         if (pattern.startsWith("**/")) {
           patternsToTry.push(pattern.slice(3));
@@ -8745,7 +8937,7 @@ function findFiles(dir, pattern, limit, baseDir) {
         );
         if (matched) {
           try {
-            const stat4 = fs12.statSync(fullPath);
+            const stat4 = fs14.statSync(fullPath);
             results.push({ path: fullPath, mtimeMs: stat4.mtimeMs });
           } catch {
           }
@@ -8762,7 +8954,7 @@ function findFiles(dir, pattern, limit, baseDir) {
   };
 }
 function toRelativePath(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path13.sep)) {
+  if (absolutePath.startsWith(cwd + path15.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   return absolutePath;
@@ -8795,10 +8987,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 (!fs12.existsSync(searchPath)) {
+        if (!fs14.existsSync(searchPath)) {
           return { content: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${searchPath}`, isError: true };
         }
-        if (!fs12.statSync(searchPath).isDirectory()) {
+        if (!fs14.statSync(searchPath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${searchPath}`, isError: true };
         }
         const start = Date.now();
@@ -8822,7 +9014,7 @@ ${filenames.join("\n")}${truncatedNote}`
 
 // src/tools/grep.ts
 import { execFile } from "node:child_process";
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 function ripGrep(args, searchPath, signal) {
   return new Promise((resolve11) => {
     const fullArgs = [...args, searchPath];
@@ -8854,7 +9046,7 @@ function applyHeadLimit(items, limit, offset = 0) {
   };
 }
 function toRelativePath2(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path14.sep)) {
+  if (absolutePath.startsWith(cwd + path16.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   if (absolutePath.startsWith(cwd)) {
@@ -9024,12 +9216,14 @@ ${filenames.join("\n")}${truncatedNote}`
 // src/tools/task-manager.ts
 var task_manager_exports = {};
 __export(task_manager_exports, {
+  ackPendingNotification: () => ackPendingNotification,
   buildCalendarNotification: () => buildCalendarNotification,
   buildNudgeNotification: () => buildNudgeNotification,
   clearNotificationCallback: () => clearNotificationCallback,
   drainPendingNotifications: () => drainPendingNotifications,
   enqueueNotification: () => enqueueNotification,
   generateTaskId: () => generateTaskId,
+  getPendingNotificationRecords: () => getPendingNotificationRecords,
   getPendingNotifications: () => getPendingNotifications,
   getTask: () => getTask,
   getTaskOutput: () => getTaskOutput,
@@ -9038,14 +9232,16 @@ __export(task_manager_exports, {
   getTaskOutputPath: () => getTaskOutputPath,
   getTaskOutputSize: () => getTaskOutputSize,
   killTask: () => killTask,
+  listLiveTasks: () => listLiveTasks,
   listTasks: () => listTasks,
+  loadPersistedTasks: () => loadPersistedTasks,
   setNotificationCallback: () => setNotificationCallback,
   spawnBackgroundTask: () => spawnBackgroundTask
 });
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { spawn as spawn2 } from "node:child_process";
-import * as fs13 from "node:fs";
-import * as path15 from "node:path";
+import * as fs15 from "node:fs";
+import * as path17 from "node:path";
 function generateTaskId(type2 = "local_bash") {
   const prefix = TASK_ID_PREFIXES[type2] ?? "x";
   const bytes = randomBytes3(8);
@@ -9058,60 +9254,182 @@ function generateTaskId(type2 = "local_bash") {
 function getTaskOutputDir() {
   if (_taskOutputDir === void 0) {
     const stateDir = process.env.ENGINE_STATE_DIR || process.cwd();
-    _taskOutputDir = path15.join(stateDir, "tasks");
+    _taskOutputDir = path17.join(stateDir, "tasks");
   }
   return _taskOutputDir;
 }
 function getTaskOutputPath(taskId) {
-  return path15.join(getTaskOutputDir(), `${taskId}.output`);
+  return path17.join(getTaskOutputDir(), `${taskId}.output`);
 }
 function ensureOutputDir() {
   const dir = getTaskOutputDir();
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
   }
 }
 function initTaskOutput(taskId) {
   ensureOutputDir();
   const outputPath = getTaskOutputPath(taskId);
-  fs13.writeFileSync(outputPath, "", "utf-8");
+  fs15.writeFileSync(outputPath, "", "utf-8");
   return outputPath;
 }
+function persistTask(state2) {
+  try {
+    ensureOutputDir();
+    const p = taskIndexPath();
+    const existing = fs15.existsSync(p) ? JSON.parse(fs15.readFileSync(p, "utf8")) : [];
+    const next = existing.filter((t) => t.id !== state2.id);
+    next.push({ ...state2 });
+    const tmp = `${p}.${process.pid}.tmp`;
+    fs15.writeFileSync(tmp, JSON.stringify(next, null, 2));
+    fs15.renameSync(tmp, p);
+  } catch (err) {
+    console.warn(`[task-manager] persist failed: ${err.message}`);
+  }
+}
+function loadPersistedTasks() {
+  try {
+    const v = JSON.parse(fs15.readFileSync(taskIndexPath(), "utf8"));
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+function loadNotificationQueue() {
+  if (notificationsLoaded) return;
+  notificationsLoaded = true;
+  try {
+    const value = JSON.parse(fs15.readFileSync(notificationQueuePath(), "utf8"));
+    if (Array.isArray(value)) pendingNotifications.push(...value.filter((x) => x && typeof x.notification === "string"));
+  } catch {
+  }
+}
+function persistNotificationQueue() {
+  try {
+    ensureOutputDir();
+    const p = notificationQueuePath();
+    const tmp = `${p}.${process.pid}.tmp`;
+    fs15.writeFileSync(tmp, JSON.stringify(pendingNotifications, null, 2), "utf8");
+    fs15.renameSync(tmp, p);
+  } catch (err) {
+    console.warn(`[task-manager] notification persist failed: ${err.message}`);
+  }
+}
+function notificationRetryDelayMs(attempt) {
+  return Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** Math.min(attempt, 6));
+}
+function notificationDue(item, now = Date.now()) {
+  if (!item.nextAttemptAt) return true;
+  const dueAt = Date.parse(item.nextAttemptAt);
+  return Number.isFinite(dueAt) && dueAt <= now;
+}
+function scheduleNotificationRetry() {
+  if (notificationRetryTimer || !notificationCallback || pendingNotifications.length === 0) return;
+  let earliest;
+  for (const item of pendingNotifications) {
+    if (!item.nextAttemptAt) continue;
+    const dueAt = Date.parse(item.nextAttemptAt);
+    if (Number.isFinite(dueAt) && (earliest === void 0 || dueAt < earliest)) earliest = dueAt;
+  }
+  if (earliest === void 0) return;
+  notificationRetryTimer = setTimeout(() => {
+    notificationRetryTimer = void 0;
+    attemptDueNotifications();
+  }, Math.max(0, earliest - Date.now()));
+  notificationRetryTimer.unref?.();
+}
+function attemptDueNotifications() {
+  if (!notificationCallback) return;
+  const remaining = [];
+  for (const item of pendingNotifications) {
+    if (!notificationDue(item)) {
+      remaining.push(item);
+      continue;
+    }
+    try {
+      notificationCallback(item.notification, item.route);
+    } catch (err) {
+      const attempt = (item.attempt ?? 0) + 1;
+      remaining.push({ ...item, attempt, nextAttemptAt: new Date(Date.now() + notificationRetryDelayMs(attempt)).toISOString(), lastError: String(err?.message || err) });
+    }
+  }
+  pendingNotifications.length = 0;
+  pendingNotifications.push(...remaining);
+  persistNotificationQueue();
+  scheduleNotificationRetry();
+}
 function setNotificationCallback(cb) {
   notificationCallback = cb;
+  loadNotificationQueue();
+  if (pendingNotifications.length === 0) return;
+  attemptDueNotifications();
 }
 function clearNotificationCallback() {
   notificationCallback = null;
+  if (notificationRetryTimer) {
+    clearTimeout(notificationRetryTimer);
+    notificationRetryTimer = void 0;
+  }
 }
-function enqueueNotification(notification, route) {
+function enqueueNotification(notification, route, idempotencyKey) {
+  loadNotificationQueue();
+  if (idempotencyKey && pendingNotifications.some((item) => item.idempotencyKey === idempotencyKey)) return;
   if (notificationCallback) {
-    notificationCallback(notification, route);
-    console.log(`[task-manager] Notification dispatched via callback (event-driven, session=${route?.sessionId || "none"}, channel=${route?.channel || "none"})`);
-    return;
+    try {
+      notificationCallback(notification, route);
+      console.log(`[task-manager] Notification dispatched via callback (event-driven, session=${route?.sessionId || "none"}, channel=${route?.channel || "none"})`);
+      return;
+    } catch (err) {
+      console.warn(`[task-manager] Notification callback failed, persisting for retry: ${err.message}`);
+      pendingNotifications.push({ id: `n-${Date.now()}-${randomBytes3(4).toString("hex")}`, notification, route, createdAt: (/* @__PURE__ */ new Date()).toISOString(), attempt: 1, nextAttemptAt: new Date(Date.now() + notificationRetryDelayMs(1)).toISOString(), lastError: String(err?.message || err), idempotencyKey });
+      persistNotificationQueue();
+      scheduleNotificationRetry();
+      return;
+    }
   }
-  pendingNotifications.push(notification);
+  pendingNotifications.push({ id: `n-${Date.now()}-${randomBytes3(4).toString("hex")}`, notification, route, createdAt: (/* @__PURE__ */ new Date()).toISOString(), idempotencyKey });
+  persistNotificationQueue();
   console.log(`[task-manager] Notification queued (${pendingNotifications.length} pending, no callback)`);
 }
 function getPendingNotifications() {
-  return [...pendingNotifications];
+  loadNotificationQueue();
+  return pendingNotifications.map((item) => item.notification);
+}
+function getPendingNotificationRecords() {
+  loadNotificationQueue();
+  return pendingNotifications.map((item) => ({ ...item, route: item.route ? { ...item.route } : void 0 }));
+}
+function ackPendingNotification(id) {
+  loadNotificationQueue();
+  const index = pendingNotifications.findIndex((item) => item.id === id);
+  if (index < 0) return false;
+  pendingNotifications.splice(index, 1);
+  persistNotificationQueue();
+  scheduleNotificationRetry();
+  return true;
 }
 function drainPendingNotifications() {
-  const notifications = [...pendingNotifications];
+  loadNotificationQueue();
+  const due = pendingNotifications.filter((item) => notificationDue(item));
+  if (due.length === 0) return [];
+  const kept = pendingNotifications.filter((item) => !notificationDue(item));
   pendingNotifications.length = 0;
-  return notifications;
+  pendingNotifications.push(...kept);
+  persistNotificationQueue();
+  return due.map((item) => item.notification);
 }
 function spawnBackgroundTask(opts) {
   const taskId = generateTaskId("local_bash");
   const outputPath = initTaskOutput(taskId);
   const { shell, args: shellArgs } = findShell();
-  const outputFd = fs13.openSync(outputPath, "w");
+  const outputFd = fs15.openSync(outputPath, "w");
   const child = spawn2(shell, [...shellArgs, opts.command], {
     cwd: opts.cwd,
     env: opts.env || process.env,
     stdio: ["ignore", outputFd, outputFd]
   });
   try {
-    fs13.closeSync(outputFd);
+    fs15.closeSync(outputFd);
   } catch {
   }
   processes.set(taskId, child);
@@ -9129,6 +9447,7 @@ function spawnBackgroundTask(opts) {
     channelTarget: opts.channelTarget
   };
   tasks.set(taskId, taskState);
+  persistTask(taskState);
   let timer;
   if (opts.timeout && opts.timeout > 0) {
     timer = setTimeout(() => {
@@ -9142,12 +9461,12 @@ function spawnBackgroundTask(opts) {
   let killedForSize = false;
   sizeWatchdog = setInterval(() => {
     if (tasks.get(taskId)?.status !== "running") return;
-    fs13.stat(outputPath, (err, st) => {
+    fs15.stat(outputPath, (err, st) => {
       if (err || st.size <= MAX_TASK_OUTPUT_BYTES) return;
       killedForSize = true;
       if (sizeWatchdog) clearInterval(sizeWatchdog);
       try {
-        fs13.appendFileSync(outputPath, "\n[output truncated: exceeded 5GB disk cap]\n");
+        fs15.appendFileSync(outputPath, "\n[output truncated: exceeded 5GB disk cap]\n");
       } catch {
       }
       killChild(child);
@@ -9165,8 +9484,15 @@ function spawnBackgroundTask(opts) {
       state2.status = status;
       state2.exitCode = exitCode;
       state2.endTime = Date.now();
+      persistTask(state2);
+      try {
+        opts.onComplete?.(state2);
+      } catch (err) {
+        console.error(`[task-manager] completion callback failed: ${err.message}`);
+      }
       if (!state2.notified) {
         state2.notified = true;
+        persistTask(state2);
         const summary = buildSummary(state2);
         const notification = buildTaskNotification(taskId, outputPath, status, summary);
         enqueueNotification(notification, { sessionId: state2.sessionId, channel: state2.channel, channelTarget: state2.channelTarget });
@@ -9221,6 +9547,12 @@ function getTask(taskId) {
   return tasks.get(taskId);
 }
 function listTasks() {
+  const merged = /* @__PURE__ */ new Map();
+  for (const t of loadPersistedTasks()) merged.set(t.id, t);
+  for (const t of tasks.values()) merged.set(t.id, t);
+  return [...merged.values()];
+}
+function listLiveTasks() {
   return [...tasks.values()];
 }
 function getTaskOutput(taskId, maxBytes = 8 * 1024 * 1024) {
@@ -9228,16 +9560,16 @@ function getTaskOutput(taskId, maxBytes = 8 * 1024 * 1024) {
   if (!state2) return "";
   try {
     const outputPath = state2.outputFile;
-    if (!fs13.existsSync(outputPath)) return "";
-    const stat4 = fs13.statSync(outputPath);
+    if (!fs15.existsSync(outputPath)) return "";
+    const stat4 = fs15.statSync(outputPath);
     if (stat4.size <= maxBytes) {
-      return fs13.readFileSync(outputPath, "utf-8");
+      return fs15.readFileSync(outputPath, "utf-8");
     }
-    const fd = fs13.openSync(outputPath, "r");
+    const fd = fs15.openSync(outputPath, "r");
     const start = stat4.size - maxBytes;
     const buf = Buffer.alloc(maxBytes);
-    fs13.readSync(fd, buf, 0, maxBytes, start);
-    fs13.closeSync(fd);
+    fs15.readSync(fd, buf, 0, maxBytes, start);
+    fs15.closeSync(fd);
     const content = buf.toString("utf-8");
     const omitted = Math.round((stat4.size - maxBytes) / 1024);
     return `[${omitted}KB of earlier output omitted]
@@ -9251,14 +9583,14 @@ function getTaskOutputDelta(taskId, fromOffset, maxBytes = 8 * 1024 * 1024) {
   if (!state2) return { content: "", newOffset: fromOffset };
   try {
     const outputPath = state2.outputFile;
-    if (!fs13.existsSync(outputPath)) return { content: "", newOffset: fromOffset };
-    const stat4 = fs13.statSync(outputPath);
+    if (!fs15.existsSync(outputPath)) return { content: "", newOffset: fromOffset };
+    const stat4 = fs15.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 = fs13.openSync(outputPath, "r");
-    fs13.readSync(fd, buf, 0, readLen, fromOffset);
-    fs13.closeSync(fd);
+    const fd = fs15.openSync(outputPath, "r");
+    fs15.readSync(fd, buf, 0, readLen, fromOffset);
+    fs15.closeSync(fd);
     return { content: buf.toString("utf-8"), newOffset: fromOffset + readLen };
   } catch {
     return { content: "", newOffset: fromOffset };
@@ -9268,8 +9600,8 @@ function getTaskOutputSize(taskId) {
   const state2 = tasks.get(taskId);
   if (!state2) return 0;
   try {
-    if (!fs13.existsSync(state2.outputFile)) return 0;
-    return fs13.statSync(state2.outputFile).size;
+    if (!fs15.existsSync(state2.outputFile)) return 0;
+    return fs15.statSync(state2.outputFile).size;
   } catch {
     return 0;
   }
@@ -9293,7 +9625,7 @@ function killTask(taskId) {
   }
   return true;
 }
-var TASK_ID_PREFIXES, TASK_ID_ALPHABET, MAX_TASK_OUTPUT_BYTES, _taskOutputDir, tasks, processes, pendingNotifications, notificationCallback, TASK_NOTIFICATION_TAG, TASK_ID_TAG, TASK_TYPE_TAG, TOOL_USE_ID_TAG, OUTPUT_FILE_TAG, STATUS_TAG, SUMMARY_TAG, CALENDAR_NOTIFICATION_TAG, CAL_TYPE_TAG, CAL_EVENT_TAG, CAL_EVENTS_TAG, NUDGE_NOTIFICATION_TAG, NUDGE_TYPE_TAG, NUDGE_DESC_TAG;
+var TASK_ID_PREFIXES, TASK_ID_ALPHABET, MAX_TASK_OUTPUT_BYTES, _taskOutputDir, tasks, processes, taskIndexPath, pendingNotifications, notificationsLoaded, notificationQueuePath, notificationCallback, RETRY_BASE_MS, RETRY_MAX_MS, notificationRetryTimer, TASK_NOTIFICATION_TAG, TASK_ID_TAG, TASK_TYPE_TAG, TOOL_USE_ID_TAG, OUTPUT_FILE_TAG, STATUS_TAG, SUMMARY_TAG, CALENDAR_NOTIFICATION_TAG, CAL_TYPE_TAG, CAL_EVENT_TAG, CAL_EVENTS_TAG, NUDGE_NOTIFICATION_TAG, NUDGE_TYPE_TAG, NUDGE_DESC_TAG;
 var init_task_manager = __esm({
   "src/tools/task-manager.ts"() {
     "use strict";
@@ -9307,8 +9639,13 @@ var init_task_manager = __esm({
     MAX_TASK_OUTPUT_BYTES = 5 * 1024 * 1024 * 1024;
     tasks = /* @__PURE__ */ new Map();
     processes = /* @__PURE__ */ new Map();
+    taskIndexPath = () => path17.join(process.env.ENGINE_STATE_DIR || process.cwd(), "tasks", "index.json");
     pendingNotifications = [];
+    notificationsLoaded = false;
+    notificationQueuePath = () => path17.join(process.env.ENGINE_STATE_DIR || process.cwd(), "tasks", "notifications.json");
     notificationCallback = null;
+    RETRY_BASE_MS = 1e3;
+    RETRY_MAX_MS = 6e4;
     TASK_NOTIFICATION_TAG = "task-notification";
     TASK_ID_TAG = "task-id";
     TASK_TYPE_TAG = "task-type";
@@ -9547,8 +9884,8 @@ __export(BashTool_exports, {
   killChild: () => killChild
 });
 import { spawn as spawn3, execSync } from "node:child_process";
-import * as fs14 from "node:fs";
-import * as path16 from "node:path";
+import * as fs16 from "node:fs";
+import * as path18 from "node:path";
 function isWslBash(p) {
   const normalized = p.replace(/\//g, "\\").toLowerCase();
   return WSL_PATH_MARKERS.some((m) => normalized.includes(m.toLowerCase()));
@@ -9567,7 +9904,7 @@ function findShell() {
     });
     const candidates = result2.trim().split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
     const nonWsl = candidates.find((p) => !isWslBash(p));
-    if (nonWsl && fs14.existsSync(nonWsl)) {
+    if (nonWsl && fs16.existsSync(nonWsl)) {
       cachedShell = { shell: nonWsl, args: ["-c"] };
       return cachedShell;
     }
@@ -9577,10 +9914,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",
-    path16.join(process.env.LOCALAPPDATA || "", "Programs", "Git", "bin", "bash.exe")
+    path18.join(process.env.LOCALAPPDATA || "", "Programs", "Git", "bin", "bash.exe")
   ];
   for (const p of knownPaths) {
-    if (p && fs14.existsSync(p)) {
+    if (p && fs16.existsSync(p)) {
       cachedShell = { shell: p, args: ["-c"] };
       return cachedShell;
     }
@@ -9683,8 +10020,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 = path16.join(osMod.tmpdir(), `exec-${Date.now()}-${Math.random().toString(36).slice(2)}.out`);
-        const outputHandle = await fs14.promises.open(outputFile, "w");
+        const outputFile = path18.join(osMod.tmpdir(), `exec-${Date.now()}-${Math.random().toString(36).slice(2)}.out`);
+        const outputHandle = await fs16.promises.open(outputFile, "w");
         return new Promise((resolve11) => {
           const { shell, args: shellArgs } = findShell();
           const child = spawn3(shell, [...shellArgs, command], {
@@ -9703,21 +10040,21 @@ For commands that are harder to parse at a glance (piped commands, obscure flags
             let fileOutput = "";
             let truncated = false;
             try {
-              const st = await fs14.promises.stat(outputFile);
+              const st = await fs16.promises.stat(outputFile);
               if (st.size > MAX_OUTPUT) {
-                const rfd = await fs14.promises.open(outputFile, "r");
+                const rfd = await fs16.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 fs14.promises.readFile(outputFile, "utf-8");
+                fileOutput = await fs16.promises.readFile(outputFile, "utf-8");
               }
             } catch {
             }
             try {
-              await fs14.promises.unlink(outputFile);
+              await fs16.promises.unlink(outputFile);
             } catch {
             }
             const processedStdout = fileOutput.replace(/^(\s*\n)+/, "").trimEnd();
@@ -10522,23 +10859,23 @@ var init_agentSwarmsEnabled = __esm({
 });
 
 // src/swarm/teamHelpers.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function getTeamsDir() {
-  return join15(_stateDir, "teams");
+  return join16(_stateDir, "teams");
 }
 function getTasksDir() {
-  return join15(_stateDir, "tasks");
+  return join16(_stateDir, "tasks");
 }
 function sanitizeName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
 }
 function getTeamDir(teamName) {
-  return join15(getTeamsDir(), sanitizeName(teamName));
+  return join16(getTeamsDir(), sanitizeName(teamName));
 }
 function getTeamFilePath(teamName) {
-  return join15(getTeamDir(teamName), "config.json");
+  return join16(getTeamDir(teamName), "config.json");
 }
 function readTeamFile(teamName) {
   try {
@@ -10605,7 +10942,7 @@ async function cleanupTeamDirectories(teamName) {
   } catch (error) {
     console.warn(`[teamHelpers] Failed to clean up team directory ${teamDir}: ${error.message}`);
   }
-  const tasksDir = join15(getTasksDir(), sanitizedName);
+  const tasksDir = join16(getTasksDir(), sanitizedName);
   try {
     await rm(tasksDir, { recursive: true, force: true });
     console.log(`[teamHelpers] Cleaned up tasks directory: ${tasksDir}`);
@@ -10614,8 +10951,8 @@ async function cleanupTeamDirectories(teamName) {
   }
 }
 function ensureTasksDir(taskListId) {
-  const dir = join15(getTasksDir(), taskListId);
-  mkdirSync7(dir, { recursive: true });
+  const dir = join16(getTasksDir(), taskListId);
+  mkdirSync8(dir, { recursive: true });
 }
 function setLeaderTeamName(name) {
   _leaderTeamName = name;
@@ -10795,9 +11132,9 @@ The user interacts primarily with the team lead. Your work is coordinated throug
 
 // src/swarm/teammateMailbox.ts
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function getTeamsDir2() {
-  return join16(process.env.ENGINE_STATE_DIR || ".", "teams");
+  return join17(process.env.ENGINE_STATE_DIR || ".", "teams");
 }
 function sanitizePathComponent(s) {
   return s.replace(/[^a-zA-Z0-9_-]/g, "-");
@@ -10806,12 +11143,12 @@ function getInboxPath(agentName, teamName) {
   const team = teamName || "default";
   const safeTeam = sanitizePathComponent(team);
   const safeAgentName = sanitizePathComponent(agentName);
-  return join16(getTeamsDir2(), safeTeam, "inboxes", `${safeAgentName}.json`);
+  return join17(getTeamsDir2(), safeTeam, "inboxes", `${safeAgentName}.json`);
 }
 async function ensureInboxDir(teamName) {
   const team = teamName || "default";
   const safeTeam = sanitizePathComponent(team);
-  const inboxDir = join16(getTeamsDir2(), safeTeam, "inboxes");
+  const inboxDir = join17(getTeamsDir2(), safeTeam, "inboxes");
   await mkdir2(inboxDir, { recursive: true });
 }
 async function sleep4(ms) {
@@ -10848,7 +11185,7 @@ async function acquireLock(inboxPath) {
   for (let i = 0; i < LOCK_RETRIES; i++) {
     if (await isLockStale(lockPath2)) {
       try {
-        await import("node:fs/promises").then((fs28) => fs28.rm(lockPath2, { force: true }));
+        await import("node:fs/promises").then((fs29) => fs29.rm(lockPath2, { force: true }));
       } catch {
       }
     }
@@ -10856,7 +11193,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((fs28) => fs28.rm(lockPath2, { force: true }));
+          await import("node:fs/promises").then((fs29) => fs29.rm(lockPath2, { force: true }));
         } catch {
         }
       };
@@ -12026,12 +12363,12 @@ Examples:
 });
 
 // src/tools/msg-husband.ts
-import fs15 from "node:fs";
-import path17 from "node:path";
+import fs17 from "node:fs";
+import path19 from "node:path";
 function getHusbandFeishuId(workspace) {
-  const contactsPath = path17.join(workspace, "prompts", "contacts.md");
+  const contactsPath = path19.join(workspace, "prompts", "contacts.md");
   try {
-    const text = fs15.readFileSync(contactsPath, "utf-8");
+    const text = fs17.readFileSync(contactsPath, "utf-8");
     const m = text.match(/\|\s*翀哥\s*\|\s*(ou_[a-f0-9]+)\s*\|/);
     return m ? m[1] : null;
   } catch {
@@ -12184,8 +12521,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 fs28 = await import("node:fs");
-        if (!fs28.existsSync(filePath)) {
+        const fs29 = await import("node:fs");
+        if (!fs29.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) : [];
@@ -12213,7 +12550,7 @@ Examples:
           md: "text/markdown"
         };
         const mimeType = mimeTypeMap[ext] || "application/octet-stream";
-        const stat4 = fs28.statSync(filePath);
+        const stat4 = fs29.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 };
@@ -12242,12 +12579,12 @@ Examples:
 });
 
 // src/tools/my-eyes.ts
-import * as fs16 from "node:fs";
-import * as path18 from "node:path";
+import * as fs18 from "node:fs";
+import * as path20 from "node:path";
 function resolveLatestImage(specifiedPath, mediaDir) {
-  if (specifiedPath && fs16.existsSync(specifiedPath)) return specifiedPath;
-  if (!fs16.existsSync(mediaDir)) return null;
-  const files = fs16.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp)$/i.test(f)).map((f) => ({ name: f, p: path18.join(mediaDir, f), mtime: fs16.statSync(path18.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (specifiedPath && fs18.existsSync(specifiedPath)) return specifiedPath;
+  if (!fs18.existsSync(mediaDir)) return null;
+  const files = fs18.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp)$/i.test(f)).map((f) => ({ name: f, p: path20.join(mediaDir, f), mtime: fs18.statSync(path20.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return files[0]?.p || null;
 }
 var MIME_MAP;
@@ -12292,15 +12629,15 @@ var init_my_eyes = __esm({
         if (!provider?.streamChat) {
           return { content: "Error: provider \u4E0D\u53EF\u7528\u3002", isError: true };
         }
-        const mediaDir = path18.join(ctx.stateDir, "media", "inbound");
+        const mediaDir = path20.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 = path18.extname(imagePath).toLowerCase();
+        const ext = path20.extname(imagePath).toLowerCase();
         const mime = MIME_MAP[ext] || "jpeg";
-        const imgB64 = fs16.readFileSync(imagePath).toString("base64");
+        const imgB64 = fs18.readFileSync(imagePath).toString("base64");
         const userMsg = {
           role: "user",
           content: [
@@ -12335,7 +12672,7 @@ var init_my_eyes = __esm({
 });
 
 // src/tools/opus-encoder.ts
-import * as fs17 from "node:fs";
+import * as fs19 from "node:fs";
 function oggCrc32(buf) {
   let crc = 0;
   for (let i = 0; i < buf.length; i++) {
@@ -12395,7 +12732,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(fs17.readFileSync(wavPath));
+  const wav = parseWav(fs19.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");
@@ -12431,7 +12768,7 @@ async function wavToOggOpusNative(wavPath) {
   }
   ogg.page(cur, pageGranule, false, true);
   const oggPath = wavPath.replace(/\.wav$/, ".ogg");
-  fs17.writeFileSync(oggPath, ogg.finish());
+  fs19.writeFileSync(oggPath, ogg.finish());
   return oggPath;
 }
 var FRAME_MS, PRESKIP_48K, OPUS_RATE, NATIVE_RATES, BITRATE, CRC_TABLE, OggWriter;
@@ -12511,8 +12848,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 fs18 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path21 from "node:path";
 import * as os3 from "node:os";
 function resolvePython(configuredPath) {
   if (configuredPath) {
@@ -12548,8 +12885,8 @@ async function ttsCosyvoice(text, apiKey, model, voice, workspaceId, instruction
 }
 async function ttsCosyvoiceStream(text, cfg, onChunk) {
   const { apiKey, model, voice, workspaceId, instruction } = cfg;
-  fs18.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path19.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs20.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path21.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const script = `
 import sys, json, base64, threading
 import dashscope
@@ -12634,7 +12971,7 @@ print('EOS')
   header.writeUInt16LE(16, 34);
   header.write("data", 36);
   header.writeUInt32LE(pcm.length, 40);
-  fs18.writeFileSync(output, Buffer.concat([header, pcm]));
+  fs20.writeFileSync(output, Buffer.concat([header, pcm]));
   return output;
 }
 async function ttsQwen3Local(text, cfg, onChunk) {
@@ -12686,14 +13023,14 @@ 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);
-  fs18.mkdirSync(VOICE_DIR, { recursive: true });
-  const oggPath = path19.join(VOICE_DIR, `tts_${Date.now()}.ogg`);
-  fs18.writeFileSync(oggPath, ogg);
+  fs20.mkdirSync(VOICE_DIR, { recursive: true });
+  const oggPath = path21.join(VOICE_DIR, `tts_${Date.now()}.ogg`);
+  fs20.writeFileSync(oggPath, ogg);
   return { oggPath, durationMs };
 }
 async function ttsGptsovits(text) {
-  fs18.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path19.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs20.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path21.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const params = new URLSearchParams({
     text,
     text_language: "zh",
@@ -12704,12 +13041,12 @@ async function ttsGptsovits(text) {
   const res = await fetch(`${GPTSOVITS_API}/?${params}`);
   if (!res.ok) throw new Error(`GPT-SoVITS API ${res.status}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs18.writeFileSync(output, buf);
+  fs20.writeFileSync(output, buf);
   return output;
 }
 async function ttsEdge(text) {
-  fs18.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path19.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
+  fs20.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path21.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
   const script = `
 import asyncio, edge_tts, sys
 async def main():
@@ -12736,11 +13073,11 @@ async function toWav24kWithDuration(audioPath) {
       "pcm_s16le",
       wavPath
     ], { timeout: 3e4 });
-    if (!fs18.existsSync(wavPath) || fs18.statSync(wavPath).size < 44) {
+    if (!fs20.existsSync(wavPath) || fs20.statSync(wavPath).size < 44) {
       throw new Error("toWav24k produced empty output");
     }
     try {
-      fs18.unlinkSync(audioPath);
+      fs20.unlinkSync(audioPath);
     } catch {
     }
   }
@@ -12771,7 +13108,7 @@ async function compressWav(wavPath) {
       "+faststart",
       m4aPath
     ], { timeout: 3e4 });
-    fs18.unlinkSync(wavPath);
+    fs20.unlinkSync(wavPath);
     return m4aPath;
   } catch {
     return wavPath;
@@ -12798,10 +13135,10 @@ async function wavToOggOpus(wavPath) {
       oggPath
     ], { timeout: 3e4 });
   }
-  if (!fs18.existsSync(oggPath) || fs18.statSync(oggPath).size < 20) {
+  if (!fs20.existsSync(oggPath) || fs20.statSync(oggPath).size < 20) {
     throw new Error("ogg/opus encode produced empty output");
   }
-  fs18.unlinkSync(wavPath);
+  fs20.unlinkSync(wavPath);
   return oggPath;
 }
 async function sendVoiceToMulticaIssue(text, issueId, opts) {
@@ -12818,8 +13155,8 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
         const pcmChunks = [];
         await ttsQwen3Local(text, { url: vc.url, voice: vc.voice, lang: vc.lang }, (pcm2) => pcmChunks.push(pcm2));
         const pcm = Buffer.concat(pcmChunks);
-        fs18.mkdirSync(VOICE_DIR, { recursive: true });
-        const wavPath = path19.join(VOICE_DIR, `tts_mc_${Date.now()}.wav`);
+        fs20.mkdirSync(VOICE_DIR, { recursive: true });
+        const wavPath = path21.join(VOICE_DIR, `tts_mc_${Date.now()}.wav`);
         const header = Buffer.alloc(44);
         header.write("RIFF", 0);
         header.writeUInt32LE(36 + pcm.length, 4);
@@ -12834,7 +13171,7 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
         header.writeUInt16LE(16, 34);
         header.write("data", 36);
         header.writeUInt32LE(pcm.length, 40);
-        fs18.writeFileSync(wavPath, Buffer.concat([header, pcm]));
+        fs20.writeFileSync(wavPath, Buffer.concat([header, pcm]));
         audioPath = wavPath;
       }
     } else if (actualEngine === "cosyvoice" && vc?.apiKey) {
@@ -12848,7 +13185,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 || !fs18.existsSync(audioPath)) {
+  if (!audioPath || !fs20.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")) {
@@ -12858,21 +13195,21 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
       console.warn(`[my-voice:multaca] opus encode failed (${e.message}), attaching wav`);
     }
   }
-  const ext = path19.extname(audioPath).toLowerCase();
-  const sizeKB = fs18.statSync(audioPath).size / 1024;
+  const ext = path21.extname(audioPath).toLowerCase();
+  const sizeKB = fs20.statSync(audioPath).size / 1024;
   const voiceFile = `voice_${Date.now()}${ext}`;
-  const cwdCopy = path19.join(process.cwd(), voiceFile);
+  const cwdCopy = path21.join(process.cwd(), voiceFile);
   try {
-    fs18.copyFileSync(audioPath, cwdCopy);
+    fs20.copyFileSync(audioPath, cwdCopy);
   } catch (e) {
     try {
-      fs18.unlinkSync(audioPath);
+      fs20.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 {
-    fs18.unlinkSync(audioPath);
+    fs20.unlinkSync(audioPath);
   } catch {
   }
   const content = opts.caption || `\u{1F399}\uFE0F \u8BED\u97F3\u6D88\u606F\uFF08${text.length} \u5B57\uFF09`;
@@ -12901,13 +13238,13 @@ async function sendVoiceToMulticaIssue(text, issueId, opts) {
     }
     if (!ok) throw new Error(`unexpected CLI output: ${String(stdout).slice(0, 200)}`);
     try {
-      fs18.unlinkSync(cwdCopy);
+      fs20.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 {
-      fs18.unlinkSync(cwdCopy);
+      fs20.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 };
@@ -12922,7 +13259,7 @@ var init_my_voice = __esm({
     init_opus_encoder();
     init_voice_chat_tts_daemon();
     execFileAsync = promisify(execFile2);
-    VOICE_DIR = path19.join(os3.tmpdir(), "engine-voice");
+    VOICE_DIR = path21.join(os3.tmpdir(), "engine-voice");
     _pyCache = null;
     GPTSOVITS_API = "http://127.0.0.1:9880";
     GPTSOVITS_REF_WAV = "/home/chong/voice/ref/shanshan_ref_v2.wav";
@@ -13021,8 +13358,8 @@ var init_my_voice = __esm({
                 const pcmChunks = [];
                 await ttsQwen3Local(text, { url: vc.url, voice: vc.voice, lang: vc.lang }, (pcm2) => pcmChunks.push(pcm2));
                 const pcm = Buffer.concat(pcmChunks);
-                fs18.mkdirSync(VOICE_DIR, { recursive: true });
-                const wavPath = path19.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+                fs20.mkdirSync(VOICE_DIR, { recursive: true });
+                const wavPath = path21.join(VOICE_DIR, `tts_${Date.now()}.wav`);
                 const header = Buffer.alloc(44);
                 header.write("RIFF", 0);
                 header.writeUInt32LE(36 + pcm.length, 4);
@@ -13037,7 +13374,7 @@ var init_my_voice = __esm({
                 header.writeUInt16LE(16, 34);
                 header.write("data", 36);
                 header.writeUInt32LE(pcm.length, 40);
-                fs18.writeFileSync(wavPath, Buffer.concat([header, pcm]));
+                fs20.writeFileSync(wavPath, Buffer.concat([header, pcm]));
                 audioPath = wavPath;
               }
             } catch (e) {
@@ -13068,10 +13405,10 @@ var init_my_voice = __esm({
             audioPath = await compressWav(audioPath);
           }
         }
-        const ext = path19.extname(audioPath).toLowerCase();
+        const ext = path21.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 = fs18.statSync(audioPath).size / 1024;
+        const sizeKB = fs20.statSync(audioPath).size / 1024;
         try {
           await mgr.sendFile(resolvedChannel, target, caption, {
             path: audioPath,
@@ -13080,7 +13417,7 @@ var init_my_voice = __esm({
             ...voiceDurationSec !== void 0 ? { voiceDurationSec } : {}
           });
           try {
-            fs18.unlinkSync(audioPath);
+            fs20.unlinkSync(audioPath);
           } catch {
           }
           return { content: `Voice sent! (${actualEngine}, ${sizeKB.toFixed(0)}KB, ${resolvedChannel})` };
@@ -13097,8 +13434,8 @@ var init_my_voice = __esm({
 });
 
 // src/tools/my-selfie.ts
-import * as fs19 from "node:fs";
-import * as path20 from "node:path";
+import * as fs21 from "node:fs";
+import * as path22 from "node:path";
 function getProxyDispatcher2() {
   const cfg = liveConfig.all();
   const proxy = cfg.providers?.xai?.proxy;
@@ -13414,12 +13751,12 @@ var init_my_selfie = __esm({
         const REFERENCES = getReferences(ctx);
         const refName = args.reference || "default";
         const refEntry = REFERENCES.find((r) => r.name === refName) || REFERENCES[0];
-        const refPath = path20.join(ctx.workspace, refEntry.p);
-        if (provider !== "autodl" && !fs19.existsSync(refPath)) {
+        const refPath = path22.join(ctx.workspace, refEntry.p);
+        if (provider !== "autodl" && !fs21.existsSync(refPath)) {
           return { content: `Error: reference image not found at ${refPath}`, isError: true };
         }
         const resolution = args.resolution || DEFAULT_RESOLUTION;
-        const refB64 = fs19.existsSync(refPath) ? fs19.readFileSync(refPath).toString("base64") : "";
+        const refB64 = fs21.existsSync(refPath) ? fs21.readFileSync(refPath).toString("base64") : "";
         let imageBuffer;
         try {
           if (provider === "autodl") {
@@ -13434,11 +13771,11 @@ var init_my_selfie = __esm({
         } catch (err) {
           return { content: `Selfie generation failed: ${err.message}`, isError: true };
         }
-        const imagesDir = path20.join(ctx.workspace, "images");
-        if (!fs19.existsSync(imagesDir)) fs19.mkdirSync(imagesDir, { recursive: true });
+        const imagesDir = path22.join(ctx.workspace, "images");
+        if (!fs21.existsSync(imagesDir)) fs21.mkdirSync(imagesDir, { recursive: true });
         const filename = `selfie_${Date.now()}.jpg`;
-        const outputPath = path20.join(imagesDir, filename);
-        fs19.writeFileSync(outputPath, imageBuffer);
+        const outputPath = path22.join(imagesDir, filename);
+        fs21.writeFileSync(outputPath, imageBuffer);
         const mgr = ctx.channelManager;
         if (mgr) {
           const resolvedChannel = ctx.channel || "feishu";
@@ -13449,11 +13786,11 @@ var init_my_selfie = __esm({
               mimeType: "image/jpeg"
             });
           } catch (err) {
-            return { content: `Selfie generated but send failed: ${err.message}. Image: ${path20.resolve(outputPath)}`, isError: false };
+            return { content: `Selfie generated but send failed: ${err.message}. Image: ${path22.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: ${path20.resolve(outputPath)}` };
+        return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path22.resolve(outputPath)}` };
       },
       isConcurrencySafe: () => false,
       interruptBehavior: () => "block",
@@ -13548,88 +13885,6 @@ var init_body_move = __esm({
   }
 });
 
-// src/calendar/db.ts
-import * as path21 from "node:path";
-import * as fs20 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 = path21.join(workspace, ".calendar");
-  fs20.mkdirSync(dir, { recursive: true });
-  const dbPath = path21.join(dir, "calendar.db");
-  const db = new DatabaseSync(dbPath);
-  db.exec("PRAGMA journal_mode=WAL");
-  db.exec(`CREATE TABLE IF NOT EXISTS events (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    type TEXT NOT NULL,
-    status TEXT NOT NULL DEFAULT 'pending',
-    event TEXT NOT NULL,
-    day TEXT,
-    time TEXT,
-    date_str TEXT,
-    created_at TEXT NOT NULL,
-    done_at TEXT,
-    archived_at TEXT
-  )`);
-  migrate(db);
-  return db;
-}
-function migrate(db) {
-  const cols = new Set(
-    db.prepare("PRAGMA table_info(events)").all().map((r) => r.name)
-  );
-  if (!cols.has("remind_before_min")) {
-    db.exec("ALTER TABLE events ADD COLUMN remind_before_min INTEGER DEFAULT 60");
-  }
-  if (!cols.has("remind_at")) {
-    db.exec("ALTER TABLE events ADD COLUMN remind_at TEXT");
-  }
-  if (!cols.has("reminded")) {
-    db.exec("ALTER TABLE events ADD COLUMN reminded INTEGER DEFAULT 0");
-  }
-  if (!cols.has("time_exact")) {
-    db.exec("ALTER TABLE events ADD COLUMN time_exact TEXT");
-  }
-  if (!cols.has("start_time")) {
-    db.exec("ALTER TABLE events ADD COLUMN start_time TEXT");
-  }
-  if (!cols.has("duration_min")) {
-    db.exec("ALTER TABLE events ADD COLUMN duration_min INTEGER");
-  }
-  if (!cols.has("created_channel")) {
-    db.exec("ALTER TABLE events ADD COLUMN created_channel TEXT");
-  }
-  if (!cols.has("created_channel_target")) {
-    db.exec("ALTER TABLE events ADD COLUMN created_channel_target TEXT");
-  }
-  if (!cols.has("repeat_type")) {
-    db.exec("ALTER TABLE events ADD COLUMN repeat_type TEXT DEFAULT 'once'");
-  }
-  if (!cols.has("doc_path")) {
-    db.exec("ALTER TABLE events ADD COLUMN doc_path TEXT");
-  }
-}
-var _sqlite, DatabaseSync, TZ_OFFSET_MS;
-var init_db = __esm({
-  "src/calendar/db.ts"() {
-    "use strict";
-    _sqlite = null;
-    DatabaseSync = new Proxy(function() {
-    }, {
-      construct(_t, args) {
-        return new (getSqlite()).DatabaseSync(...args);
-      },
-      get(_t, prop) {
-        return getSqlite().DatabaseSync[prop];
-      }
-    });
-    TZ_OFFSET_MS = 8 * 60 * 60 * 1e3;
-  }
-});
-
 // src/calendar/helpers.ts
 function nowIso() {
   return new Date(Date.now() + TZ_OFFSET_MS2 - (/* @__PURE__ */ new Date()).getTimezoneOffset() * 6e4).toISOString().replace("Z", "+08:00");
@@ -13855,14 +14110,14 @@ function fmtEnd(start, durationMin) {
   const total = hh * 60 + mm + durationMin;
   return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, "0")}`;
 }
-function addWeekly(db, args) {
+function addWeekly(db2, args) {
   const { day, event } = args;
   if (!WEEKDAYS2.includes(day)) return `\u9519\u8BEF: \u661F\u671F\u5FC5\u987B\u662F ${WEEKDAYS2.join("/")}`;
   if (!args.time) return `\u9519\u8BEF: \u5468\u671F\u65E5\u7A0B\u5FC5\u987B\u586B start_time\uFF08\u5982 time='14:00'\uFF09`;
   if (!args.duration) return `\u9519\u8BEF: \u5468\u671F\u65E5\u7A0B\u5FC5\u987B\u586B duration\uFF08\u5982 duration='1h'\uFF09`;
   const durationMin = parseDuration(args.duration);
   if (!durationMin) return `\u9519\u8BEF: duration \u683C\u5F0F\u4E0D\u5BF9\uFF08\u5982 '30m' / '1h'\uFF09`;
-  const conflictRows = db.prepare(
+  const conflictRows = db2.prepare(
     "SELECT * FROM events WHERE status='pending' AND type='weekly' AND day=?"
   ).all(day);
   const conflict = checkScheduleConflict(conflictRows, args.time, durationMin);
@@ -13877,16 +14132,16 @@ function addWeekly(db, args) {
     else remindMin = parseInt(v) || 60;
   }
   const remindAt = computeWeeklyRemindAt(day, args.time, remindMin);
-  const r = db.prepare(
+  const r = db2.prepare(
     `INSERT INTO events (type,status,event,day,time,start_time,duration_min,remind_before_min,remind_at,reminded,created_at,created_channel,created_channel_target)
      VALUES ('weekly','pending',?,?,?,?,?,?,?,?,?,?,?)`
   ).run(event, day, args.time, args.time, durationMin, remindMin, remindAt, 0, nowIso(), args.channel || null, args.channelTarget || null);
   return `#${r.lastInsertRowid} \u5DF2\u6DFB\u52A0: [\u6BCF\u5468] ${day} ${args.time} (${durationMin}min) ${event} (\u63D0\u524D${remindMin}min\u63D0\u9192)`;
 }
-function addDaily(db, args) {
+function addDaily(db2, args) {
   const { time, event, repeatType } = args;
   if (!time) return `\u9519\u8BEF: \u6BCF\u65E5\u4EFB\u52A1\u5FC5\u987B\u586B time\uFF08\u5982 time='23:00'\uFF09`;
-  const dailyRows = db.prepare(
+  const dailyRows = db2.prepare(
     "SELECT * FROM events WHERE status='pending' AND type='daily'"
   ).all();
   const [hh, mm] = time.split(":").map(Number);
@@ -13908,21 +14163,21 @@ function addDaily(db, args) {
   }
   const remindAt = repeatType === "daily" ? computeDailyRemindAt(time, remindMin) : computeWeekdaysRemindAt(time, remindMin);
   if (!remindAt) return `\u9519\u8BEF: \u65E0\u6CD5\u8BA1\u7B97 remind_at`;
-  const r = db.prepare(
+  const r = db2.prepare(
     `INSERT INTO events (type,status,event,time,start_time,repeat_type,remind_before_min,remind_at,reminded,created_at,created_channel,created_channel_target)
      VALUES ('daily','pending',?,?,?,?,?,?,?,?,?,?)`
   ).run(event, time, time, repeatType, remindMin, remindAt, 0, nowIso(), args.channel || null, args.channelTarget || null);
   const label = repeatType === "daily" ? "\u6BCF\u5929" : "\u5DE5\u4F5C\u65E5";
   return `#${r.lastInsertRowid} \u5DF2\u6DFB\u52A0: [${label}] ${time} ${event} (\u63D0\u524D${remindMin}min\u63D0\u9192)`;
 }
-function addDate(db, args) {
+function addDate(db2, args) {
   const { dateStr, event } = args;
   if (!args.time) return `\u9519\u8BEF: \u4E00\u6B21\u6027\u65E5\u7A0B\u5FC5\u987B\u586B start_time\uFF08\u5982 time='14:00'\uFF09`;
   if (!args.duration) return `\u9519\u8BEF: \u4E00\u6B21\u6027\u65E5\u7A0B\u5FC5\u987B\u586B duration\uFF08\u5982 duration='1h'\uFF09`;
   const durationMin = parseDuration(args.duration);
   if (!durationMin) return `\u9519\u8BEF: duration \u683C\u5F0F\u4E0D\u5BF9\uFF08\u5982 '30m' / '1h'\uFF09`;
   const todayWeekday = getTodayWeekday();
-  const dateRows = db.prepare(
+  const dateRows = db2.prepare(
     "SELECT * FROM events WHERE status='pending' AND type='date' AND date_str=?"
   ).all(dateStr);
   const parsed = parseDateRange(dateStr);
@@ -13932,7 +14187,7 @@ function addDate(db, args) {
     const year = now.getUTCFullYear();
     const d = new Date(Date.UTC(year, parsed.month - 1, parsed.dStart));
     const weekday = WEEKDAYS2[d.getUTCDay() === 0 ? 6 : d.getUTCDay() - 1];
-    weeklyRows = db.prepare(
+    weeklyRows = db2.prepare(
       "SELECT * FROM events WHERE status='pending' AND type='weekly' AND day=?"
     ).all(weekday);
   }
@@ -13949,13 +14204,13 @@ function addDate(db, args) {
     else remindMin = parseInt(v) || 60;
   }
   const remindAt = computeRemindAt(dateStr, args.time, remindMin);
-  const r = db.prepare(
+  const r = db2.prepare(
     `INSERT INTO events (type,status,event,date_str,time,start_time,duration_min,remind_before_min,remind_at,reminded,created_at,created_channel,created_channel_target)
      VALUES ('date','pending',?,?,?,?,?,?,?,?,?,?,?)`
   ).run(event, dateStr, args.time, args.time, durationMin, remindMin, remindAt, 0, nowIso(), args.channel || null, args.channelTarget || null);
   return `#${r.lastInsertRowid} \u5DF2\u6DFB\u52A0: [${dateStr} ${args.time} (${durationMin}min)] ${event} (\u63D0\u524D${remindMin}min\u63D0\u9192)`;
 }
-function addBatch(db, args) {
+function addBatch(db2, args) {
   if (!args.time) return `\u9519\u8BEF: \u6279\u91CF\u6DFB\u52A0\u5FC5\u987B\u586B time\uFF08\u5982 time='14:00'\uFF09`;
   if (!args.duration) return `\u9519\u8BEF: \u6279\u91CF\u6DFB\u52A0\u5FC5\u987B\u586B duration\uFF08\u5982 duration='1h'\uFF09`;
   const durationMin = parseDuration(args.duration);
@@ -13972,7 +14227,7 @@ function addBatch(db, args) {
   const ok = [];
   const skipped = [];
   for (const dateStr of dates) {
-    const dateRows = db.prepare(
+    const dateRows = db2.prepare(
       "SELECT * FROM events WHERE status='pending' AND type='date' AND date_str=?"
     ).all(dateStr);
     const parsed = parseDateRange(dateStr);
@@ -13982,7 +14237,7 @@ function addBatch(db, args) {
       const year = now.getUTCFullYear();
       const d = new Date(Date.UTC(year, parsed.month - 1, parsed.dStart));
       const weekday = WEEKDAYS2[d.getUTCDay() === 0 ? 6 : d.getUTCDay() - 1];
-      weeklyRows = db.prepare(
+      weeklyRows = db2.prepare(
         "SELECT * FROM events WHERE status='pending' AND type='weekly' AND day=?"
       ).all(weekday);
     }
@@ -13993,7 +14248,7 @@ function addBatch(db, args) {
       continue;
     }
     const remindAt = computeRemindAt(dateStr, args.time, remindMin);
-    const r = db.prepare(
+    const r = db2.prepare(
       `INSERT INTO events (type,status,event,date_str,time,start_time,duration_min,remind_before_min,remind_at,reminded,created_at,created_channel,created_channel_target)
        VALUES ('date','pending',?,?,?,?,?,?,?,?,?,?,?)`
     ).run(args.event, dateStr, args.time, args.time, durationMin, remindMin, remindAt, 0, nowIso(), args.channel || null, args.channelTarget || null);
@@ -14010,7 +14265,7 @@ ${skipped.map((s) => `  ${s}`).join("\n")}`;
   }
   return result2;
 }
-function addTask(db, args) {
+function addTask(db2, args) {
   const { dateStr, timeExact, event, docPath } = args;
   if (!docPath || !docPath.trim()) {
     return `\u274C \u521B\u5EFA\u5931\u8D25\uFF1Aadd-task \u5FC5\u987B\u4F20 doc_path\u3002
@@ -14041,12 +14296,12 @@ function addTask(db, args) {
     else if (v.endsWith("h")) remindMin = parseInt(v.slice(0, -1)) * 60;
     else remindMin = parseInt(v) || 60;
   }
-  const taskRows = db.prepare(
+  const taskRows = db2.prepare(
     "SELECT * FROM events WHERE status='pending' AND type='task' AND date_str=?"
   ).all(dateStr);
   const prox = checkTaskProximity(taskRows, timeExact);
   const remindAt = computeRemindAt(dateStr, timeExact, remindMin);
-  const r = db.prepare(
+  const r = db2.prepare(
     `INSERT INTO events (type,status,event,date_str,time_exact,remind_before_min,remind_at,reminded,created_at,created_channel,created_channel_target,doc_path)
      VALUES ('task','pending',?,?,?,?,?,?,?,?,?,?)`
   ).run(event, dateStr, timeExact, remindMin, remindAt, 0, nowIso(), args.channel || null, args.channelTarget || null, docPath);
@@ -14058,9 +14313,9 @@ function addTask(db, args) {
   }
   return msg2;
 }
-function reschedule(db, args) {
+function reschedule(db2, args) {
   const { id, dateStr, timeExact } = args;
-  const row = db.prepare("SELECT * FROM events WHERE id=?").get(id);
+  const row = db2.prepare("SELECT * FROM events WHERE id=?").get(id);
   if (!row) return `\u672A\u627E\u5230\u4E8B\u4EF6 #${id}`;
   if (row.type !== "task") return `#${id} \u4E0D\u662F task \u7C7B\u578B\uFF08${row.type}\uFF09\uFF0Creschedule \u4EC5\u652F\u6301 task`;
   let remindMin = row.remind_before_min || 60;
@@ -14071,12 +14326,12 @@ function reschedule(db, args) {
     else remindMin = parseInt(v) || remindMin;
   }
   const remindAt = computeRemindAt(dateStr, timeExact, remindMin);
-  db.prepare("UPDATE events SET date_str=?, time_exact=?, remind_before_min=?, remind_at=?, reminded=0 WHERE id=?").run(dateStr, timeExact, remindMin, remindAt, id);
+  db2.prepare("UPDATE events SET date_str=?, time_exact=?, remind_before_min=?, remind_at=?, reminded=0 WHERE id=?").run(dateStr, timeExact, remindMin, remindAt, id);
   return `#${id} \u5DF2\u6539\u671F: [${dateStr} ${timeExact}] ${row.event} (\u63D0\u524D${remindMin}min\u63D0\u9192)`;
 }
-function list(db, opts = {}) {
+function list(db2, opts = {}) {
   if (opts.all) {
-    const rows = db.prepare("SELECT * FROM events WHERE status NOT IN ('archived', 'deleted') ORDER BY type, id").all();
+    const rows = db2.prepare("SELECT * FROM events WHERE status NOT IN ('archived', 'deleted') ORDER BY type, id").all();
     const out2 = ["## \u6BCF\u5468\u56FA\u5B9A"];
     for (const r of rows) if (r.type === "weekly") out2.push(fmtRow(r));
     out2.push("\n## \u6BCF\u65E5\u56FA\u5B9A");
@@ -14090,17 +14345,17 @@ function list(db, opts = {}) {
   const out = [`\u5F53\u524D\u65F6\u95F4: ${fmtNow()}`];
   const todayWeekday = getTodayWeekday();
   const events = [];
-  for (const r of db.prepare("SELECT * FROM events WHERE type='weekly' AND status='pending' AND day=?").all(todayWeekday)) {
+  for (const r of db2.prepare("SELECT * FROM events WHERE type='weekly' AND status='pending' AND day=?").all(todayWeekday)) {
     events.push(`  #${r.id} ${r.time || ""} ${r.event}`);
   }
-  for (const r of db.prepare("SELECT * FROM events WHERE type='daily' AND status='pending'").all()) {
+  for (const r of db2.prepare("SELECT * FROM events WHERE type='daily' AND status='pending'").all()) {
     if (r.repeat_type === "weekdays") {
       const idx = new Date(Date.now() + 8 * 60 * 60 * 1e3).getUTCDay();
       if (idx === 0 || idx === 6) continue;
     }
     events.push(`  #${r.id} ${r.time || ""} ${r.event}`);
   }
-  for (const r of db.prepare("SELECT * FROM events WHERE type='date' AND status='pending'").all()) {
+  for (const r of db2.prepare("SELECT * FROM events WHERE type='date' AND status='pending'").all()) {
     const p = parseDateRange(r.date_str);
     if (p && isToday(p.month, p.dStart, p.dEnd)) {
       events.push(`  #${r.id} ${r.event}`);
@@ -14114,14 +14369,14 @@ function list(db, opts = {}) {
   }
   return out.join("\n");
 }
-function pending(db) {
+function pending(db2) {
   const out = [`\u5F53\u524D\u65F6\u95F4: ${fmtNow()}`];
   const todayWeekday = getTodayWeekday();
   const events = [];
-  for (const r of db.prepare("SELECT * FROM events WHERE type='weekly' AND status='pending' AND day=?").all(todayWeekday)) {
+  for (const r of db2.prepare("SELECT * FROM events WHERE type='weekly' AND status='pending' AND day=?").all(todayWeekday)) {
     events.push(`  #${r.id} [\u6BCF\u5468] ${r.time || ""} ${r.event}`);
   }
-  for (const r of db.prepare("SELECT * FROM events WHERE type='daily' AND status='pending'").all()) {
+  for (const r of db2.prepare("SELECT * FROM events WHERE type='daily' AND status='pending'").all()) {
     if (r.repeat_type === "weekdays") {
       const idx = new Date(Date.now() + 8 * 60 * 60 * 1e3).getUTCDay();
       if (idx === 0 || idx === 6) continue;
@@ -14129,7 +14384,7 @@ function pending(db) {
     const label = r.repeat_type === "weekdays" ? "[\u5DE5\u4F5C\u65E5]" : "[\u6BCF\u5929]";
     events.push(`  #${r.id} ${label} ${r.time || ""} ${r.event}`);
   }
-  for (const r of db.prepare("SELECT * FROM events WHERE type='date' AND status='pending'").all()) {
+  for (const r of db2.prepare("SELECT * FROM events WHERE type='date' AND status='pending'").all()) {
     const p = parseDateRange(r.date_str);
     if (!p) continue;
     if (isToday(p.month, p.dStart, p.dEnd)) {
@@ -14148,31 +14403,31 @@ function pending(db) {
   }
   return out.join("\n");
 }
-function done(db, id) {
-  const row = db.prepare("SELECT * FROM events WHERE id=? AND status=?").get(id, "pending");
+function done(db2, id) {
+  const row = db2.prepare("SELECT * FROM events WHERE id=? AND status=?").get(id, "pending");
   if (!row) return `\u672A\u627E\u5230 pending \u4E8B\u4EF6 #${id}`;
   if (row.type === "daily" || row.type === "weekly") {
     return `\u274C ${row.type === "daily" ? "\u6BCF\u65E5/\u5DE5\u4F5C\u65E5" : "\u6BCF\u5468"}\u7C7B\u578B\u4E0D\u652F\u6301 done\uFF08\u4F1A\u505C\u6B62\u5FAA\u73AF\uFF09\u3002\u4E0D\u9700\u8981\u4E86\u8BF7\u7528 delete ${id}`;
   }
-  db.prepare("UPDATE events SET status=?, done_at=?, reminded=1 WHERE id=?").run("done", nowIso(), id);
+  db2.prepare("UPDATE events SET status=?, done_at=?, reminded=1 WHERE id=?").run("done", nowIso(), id);
   return `#${id} \u5DF2\u6807\u8BB0\u5B8C\u6210: ${row.event}`;
 }
-function linkDoc(db, id, docPath) {
-  const row = db.prepare("SELECT * FROM events WHERE id=?").get(id);
+function linkDoc(db2, id, docPath) {
+  const row = db2.prepare("SELECT * FROM events WHERE id=?").get(id);
   if (!row) return `\u672A\u627E\u5230\u4E8B\u4EF6 #${id}`;
-  db.prepare("UPDATE events SET doc_path=? WHERE id=?").run(docPath, id);
+  db2.prepare("UPDATE events SET doc_path=? WHERE id=?").run(docPath, id);
   return `#${id} \u5DF2\u5173\u8054\u6587\u6863: ${docPath}`;
 }
-function findDoc(db, id) {
-  const row = db.prepare("SELECT * FROM events WHERE id=?").get(id);
+function findDoc(db2, id) {
+  const row = db2.prepare("SELECT * FROM events WHERE id=?").get(id);
   if (!row) return `\u672A\u627E\u5230\u4E8B\u4EF6 #${id}`;
   const parts = [`#${id} ${row.event}`];
   if (row.doc_path) parts.push(`\u{1F4C4} doc_path: ${row.doc_path}`);
   else parts.push(`\u{1F4C4} doc_path: (\u672A\u5173\u8054)`);
   return parts.join("\n");
 }
-function search(db, keyword) {
-  const rows = db.prepare("SELECT * FROM events WHERE event LIKE ? ORDER BY id").all(`%${keyword}%`);
+function search(db2, keyword) {
+  const rows = db2.prepare("SELECT * FROM events WHERE event LIKE ? ORDER BY id").all(`%${keyword}%`);
   if (rows.length > 0) {
     const out = [`\u67E5\u8BE2 '${keyword}' (${rows.length} \u6761):`];
     rows.forEach((r) => out.push(fmtRow(r)));
@@ -14180,29 +14435,29 @@ function search(db, keyword) {
   }
   return `\u67E5\u8BE2 '${keyword}' \u65E0\u7ED3\u679C`;
 }
-function archive(db, id) {
-  const row = db.prepare("SELECT * FROM events WHERE id=? AND status!=?").get(id, "archived");
+function archive(db2, id) {
+  const row = db2.prepare("SELECT * FROM events WHERE id=? AND status!=?").get(id, "archived");
   if (!row) return `\u672A\u627E\u5230\u4E8B\u4EF6 #${id}`;
-  db.prepare("UPDATE events SET status=?, archived_at=?, reminded=1 WHERE id=?").run("archived", nowIso(), id);
+  db2.prepare("UPDATE events SET status=?, archived_at=?, reminded=1 WHERE id=?").run("archived", nowIso(), id);
   return `#${id} \u5DF2\u5F52\u6863: ${row.event}`;
 }
-function cleanup(db) {
-  const rows = db.prepare("SELECT * FROM events WHERE type='date' AND status='done'").all();
+function cleanup(db2) {
+  const rows = db2.prepare("SELECT * FROM events WHERE type='date' AND status='done'").all();
   let archived = 0;
   for (const r of rows) {
     const p = parseDateRange(r.date_str);
     if (p && isOverdue(p.month, p.dStart, p.dEnd)) {
-      db.prepare("UPDATE events SET status=?, archived_at=? WHERE id=?").run("archived", nowIso(), r.id);
+      db2.prepare("UPDATE events SET status=?, archived_at=? WHERE id=?").run("archived", nowIso(), r.id);
       archived++;
     }
   }
   return archived > 0 ? `\u5DF2\u81EA\u52A8\u5F52\u6863 ${archived} \u6761\u8FC7\u671F\u5B8C\u6210\u65E5\u7A0B` : "\u65E0\u8FC7\u671F\u5B8C\u6210\u65E5\u7A0B\u9700\u8981\u5F52\u6863";
 }
-function stats(db) {
-  const total = db.prepare("SELECT COUNT(*) as c FROM events").get().c;
-  const pending2 = db.prepare("SELECT COUNT(*) as c FROM events WHERE status='pending'").get().c;
-  const done2 = db.prepare("SELECT COUNT(*) as c FROM events WHERE status='done'").get().c;
-  const archived = db.prepare("SELECT COUNT(*) as c FROM events WHERE status='archived'").get().c;
+function stats(db2) {
+  const total = db2.prepare("SELECT COUNT(*) as c FROM events").get().c;
+  const pending2 = db2.prepare("SELECT COUNT(*) as c FROM events WHERE status='pending'").get().c;
+  const done2 = db2.prepare("SELECT COUNT(*) as c FROM events WHERE status='done'").get().c;
+  const archived = db2.prepare("SELECT COUNT(*) as c FROM events WHERE status='archived'").get().c;
   return `\u65E5\u5386\u7EDF\u8BA1: \u603B\u8BA1 ${total} | pending ${pending2} | done ${done2} | archived ${archived}`;
 }
 var WEEKDAYS2;
@@ -14248,7 +14503,7 @@ var init_calendar = __esm({
         const action = args.action;
         if (!action) return { content: "Error: action is required", isError: true };
         try {
-          const db = openDb(ctx.workspace);
+          const db2 = openDb(ctx.workspace);
           let result2;
           let isAddTask = false;
           if (action === "add") {
@@ -14258,22 +14513,22 @@ var init_calendar = __esm({
             const repeat = args.repeat || (args.weekly ? "weekly" : "once");
             if (repeat === "daily" || repeat === "weekdays") {
               if (!args.time) return { content: "Error: add daily/weekdays needs time (e.g. 23:00)", isError: true };
-              result2 = addDaily(db, { time: args.time, event, repeatType: repeat, remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
+              result2 = addDaily(db2, { time: args.time, event, repeatType: repeat, remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
             } else if (repeat === "weekly") {
               const day = args.day;
               if (!day) return { content: "Error: add weekly needs day", isError: true };
-              result2 = addWeekly(db, { day, event, time: args.time, duration: args.duration, remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
+              result2 = addWeekly(db2, { day, event, time: args.time, duration: args.duration, remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
             } else {
               const date = args.date?.trim();
               if (!date) return { content: "Error: add once needs date (e.g. 5/26)", isError: true };
-              result2 = addDate(db, { dateStr: date, event, time: args.time, duration: args.duration, remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
+              result2 = addDate(db2, { dateStr: date, event, time: args.time, duration: args.duration, remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
             }
           } else if (action === "add-batch") {
             const event = args.event?.trim();
             const datesInput = args.dates?.trim();
             if (!event) return { content: "Error: add-batch needs event", isError: true };
             if (!datesInput) return { content: 'Error: add-batch needs dates (e.g. "7/2,7/4,7/6-7/10")', isError: true };
-            result2 = addBatch(db, { datesInput, event, time: args.time, duration: args.duration, remind: args.remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
+            result2 = addBatch(db2, { datesInput, event, time: args.time, duration: args.duration, remind: args.remind, channel: ctx.channel, channelTarget: ctx.channelTarget });
           } else if (action === "add-task") {
             isAddTask = true;
             const event = args.event?.trim();
@@ -14284,47 +14539,47 @@ var init_calendar = __esm({
             if (!date) return { content: "Error: add-task needs date (e.g. 7/5)", isError: true };
             if (!timeExact || !timeExact.includes(":")) return { content: "Error: add-task needs time_exact (HH:MM, e.g. 14:00)", isError: true };
             if (!docPath) return { content: "\u274C \u521B\u5EFA\u5931\u8D25\uFF1Aadd-task \u5FC5\u987B\u4F20 doc_path\u3002\n\u6CA1\u6709\u6587\u6863\u652F\u6491\u7684 task \u4E0D\u662F\u5408\u683C\u7684 task\u3002\n\u8BF7\u5148\u5728 docs/todo/ \u4E0B\u521B\u5EFA\u6587\u6863\uFF08\u547D\u540D\uFF1AYYYY-MM-DD_\u4E3B\u9898.md \u6216 \u4EFB\u52A1\u540D.md\uFF09\uFF0C\u7136\u540E\u4F20 doc_path \u53C2\u6570\u3002", isError: true };
-            result2 = addTask(db, { dateStr: date, timeExact, event, remind: args.remind, channel: ctx.channel, channelTarget: ctx.channelTarget, docPath });
+            result2 = addTask(db2, { dateStr: date, timeExact, event, remind: args.remind, channel: ctx.channel, channelTarget: ctx.channelTarget, docPath });
           } else if (action === "reschedule") {
             if (args.id == null) return { content: "Error: reschedule needs id", isError: true };
             const date = args.date?.trim();
             const timeExact = args.time_exact?.trim();
             if (!date) return { content: "Error: reschedule needs date (e.g. 7/10)", isError: true };
             if (!timeExact || !timeExact.includes(":")) return { content: "Error: reschedule needs time_exact (HH:MM)", isError: true };
-            result2 = reschedule(db, { id: args.id, dateStr: date, timeExact, remind: args.remind });
+            result2 = reschedule(db2, { id: args.id, dateStr: date, timeExact, remind: args.remind });
           } else if (action === "link-doc") {
             if (args.id == null) return { content: "Error: link-doc needs id", isError: true };
             const docPath = args.doc_path?.trim();
             if (!docPath) return { content: "Error: link-doc needs doc_path", isError: true };
-            result2 = linkDoc(db, args.id, docPath);
+            result2 = linkDoc(db2, args.id, docPath);
           } else if (action === "find-doc") {
             if (args.id == null) return { content: "Error: find-doc needs id", isError: true };
-            result2 = findDoc(db, args.id);
+            result2 = findDoc(db2, args.id);
           } else if (action === "list") {
-            result2 = list(db, { all: !!args.all });
+            result2 = list(db2, { all: !!args.all });
           } else if (action === "done") {
             if (args.id == null) return { content: "Error: done needs id", isError: true };
-            result2 = done(db, args.id);
+            result2 = done(db2, args.id);
           } else if (action === "pending") {
-            result2 = pending(db);
+            result2 = pending(db2);
           } else if (action === "search") {
             const kw = args.event?.trim();
             if (!kw) return { content: "Error: search needs keyword (event field)", isError: true };
-            result2 = search(db, kw);
+            result2 = search(db2, kw);
           } else if (action === "archive") {
             if (args.id == null) return { content: "Error: archive needs id", isError: true };
-            result2 = archive(db, args.id);
+            result2 = archive(db2, args.id);
           } else if (action === "delete") {
             if (args.id == null) return { content: "Error: delete needs id", isError: true };
-            result2 = archive(db, args.id);
+            result2 = archive(db2, args.id);
           } else if (action === "cleanup") {
-            result2 = cleanup(db);
+            result2 = cleanup(db2);
           } else if (action === "stats") {
-            result2 = stats(db);
+            result2 = stats(db2);
           } else {
             return { content: `Error: unknown action '${action}'`, isError: true };
           }
-          db.close();
+          db2.close();
           const isFailed = result2.startsWith("\u274C") || result2.includes("Error") || result2.includes("\u7528\u6CD5");
           if (isAddTask && !isFailed) {
             const { enqueueNotification: enqueueNotification2, buildCalendarNotification: buildCalendarNotification2 } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
@@ -14568,24 +14823,24 @@ var init_constants5 = __esm({
 });
 
 // src/tools/TodoWriteTool/TodoWriteTool.ts
-import fs21 from "node:fs";
-import path22 from "node:path";
+import fs22 from "node:fs";
+import path23 from "node:path";
 function todoFilePath(sessionId) {
-  return path22.join(todosDir, `${sessionId}.json`);
+  return path23.join(todosDir, `${sessionId}.json`);
 }
 function loadTodos(sessionId) {
   if (!todosDir) return [];
   try {
     const filePath = todoFilePath(sessionId);
-    if (!fs21.existsSync(filePath)) return [];
-    return JSON.parse(fs21.readFileSync(filePath, "utf-8"));
+    if (!fs22.existsSync(filePath)) return [];
+    return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveTodos(sessionId, todos) {
   if (!todosDir) return;
-  fs21.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
+  fs22.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
 }
 var todosDir;
 var init_TodoWriteTool = __esm({
@@ -14842,15 +15097,15 @@ var init_constants7 = __esm({
 });
 
 // src/utils/plans.ts
-import * as fs22 from "node:fs";
-import * as path23 from "node:path";
+import * as fs23 from "node:fs";
+import * as path24 from "node:path";
 import * as crypto4 from "node:crypto";
 function generateSlug() {
   return crypto4.randomBytes(4).toString("hex");
 }
 function getPlansDirectory(stateDir) {
-  const plansDir = path23.join(stateDir, "plans");
-  fs22.mkdirSync(plansDir, { recursive: true });
+  const plansDir = path24.join(stateDir, "plans");
+  fs23.mkdirSync(plansDir, { recursive: true });
   return plansDir;
 }
 function getPlanSlug(sessionId, stateDir) {
@@ -14859,8 +15114,8 @@ function getPlanSlug(sessionId, stateDir) {
     const plansDir = getPlansDirectory(stateDir);
     for (let i = 0; i < MAX_SLUG_RETRIES; i++) {
       slug = generateSlug();
-      const filePath = path23.join(plansDir, `${slug}.md`);
-      if (!fs22.existsSync(filePath)) {
+      const filePath = path24.join(plansDir, `${slug}.md`);
+      if (!fs23.existsSync(filePath)) {
         break;
       }
     }
@@ -14871,21 +15126,21 @@ function getPlanSlug(sessionId, stateDir) {
 function getPlanFilePath(sessionId, stateDir, agentId) {
   const slug = getPlanSlug(sessionId, stateDir);
   if (!agentId) {
-    return path23.join(getPlansDirectory(stateDir), `${slug}.md`);
+    return path24.join(getPlansDirectory(stateDir), `${slug}.md`);
   }
-  return path23.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
+  return path24.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
 }
 function getPlan(sessionId, stateDir, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
   try {
-    return fs22.readFileSync(filePath, "utf-8");
+    return fs23.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writePlan(sessionId, stateDir, content, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
-  fs22.writeFileSync(filePath, content, "utf-8");
+  fs23.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 var MAX_SLUG_RETRIES, planSlugCache;
@@ -15033,28 +15288,28 @@ var init_constants8 = __esm({
 });
 
 // src/utils/tasks.ts
-import * as fs23 from "node:fs";
-import * as path24 from "node:path";
+import * as fs24 from "node:fs";
+import * as path25 from "node:path";
 function sanitizePathComponent2(input) {
   return input.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
 function getTasksDir2(stateDir, listId) {
-  return path24.join(stateDir, "tasks", sanitizePathComponent2(listId));
+  return path25.join(stateDir, "tasks", sanitizePathComponent2(listId));
 }
 function getTaskPath(stateDir, listId, taskId) {
-  return path24.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
+  return path25.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
 }
 function ensureTasksDir2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
-  fs23.mkdirSync(dir, { recursive: true });
+  fs24.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function getHighWaterMarkPath(stateDir, listId) {
-  return path24.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
+  return path25.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
 }
 function readHighWaterMark(stateDir, listId) {
   try {
-    const content = fs23.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
+    const content = fs24.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
     const value = parseInt(content, 10);
     return isNaN(value) ? 0 : value;
   } catch {
@@ -15062,20 +15317,20 @@ function readHighWaterMark(stateDir, listId) {
   }
 }
 function writeHighWaterMark(stateDir, listId, value) {
-  fs23.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
+  fs24.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
 }
 function findHighestTaskIdFromFiles(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs23.readdirSync(dir);
+    files = fs24.readdirSync(dir);
   } catch {
     return 0;
   }
   let highest = 0;
-  for (const file of files) {
-    if (!file.endsWith(".json")) continue;
-    const taskId = parseInt(file.replace(".json", ""), 10);
+  for (const file2 of files) {
+    if (!file2.endsWith(".json")) continue;
+    const taskId = parseInt(file2.replace(".json", ""), 10);
     if (!isNaN(taskId) && taskId > highest) {
       highest = taskId;
     }
@@ -15094,14 +15349,14 @@ function createTask(stateDir, listId, taskData) {
     const id = String(highestId + 1);
     const task = { id, ...taskData };
     const filePath = getTaskPath(stateDir, listId, id);
-    fs23.writeFileSync(filePath, JSON.stringify(task, null, 2));
+    fs24.writeFileSync(filePath, JSON.stringify(task, null, 2));
     return id;
   });
 }
 function getTask2(stateDir, listId, taskId) {
   const filePath = getTaskPath(stateDir, listId, taskId);
   try {
-    const content = fs23.readFileSync(filePath, "utf-8");
+    const content = fs24.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -15111,7 +15366,7 @@ function listTasks2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs23.readdirSync(dir);
+    files = fs24.readdirSync(dir);
   } catch {
     return [];
   }
@@ -15123,7 +15378,7 @@ function updateTask(stateDir, listId, taskId, updates) {
   if (!existing) return null;
   const updated = { ...existing, ...updates, id: taskId };
   const filePath = getTaskPath(stateDir, listId, taskId);
-  fs23.writeFileSync(filePath, JSON.stringify(updated, null, 2));
+  fs24.writeFileSync(filePath, JSON.stringify(updated, null, 2));
   return updated;
 }
 function deleteTask(stateDir, listId, taskId) {
@@ -15137,7 +15392,7 @@ function deleteTask(stateDir, listId, taskId) {
     }
   }
   try {
-    fs23.unlinkSync(filePath);
+    fs24.unlinkSync(filePath);
   } catch {
     return false;
   }
@@ -16570,10 +16825,10 @@ function ensureLoaded(workspace, configIds) {
       if (!state.blockedUserIds.includes(id)) state.blockedUserIds.push(id);
     }
   }
-  const path30 = join23(workspace, ".reply-blocklist.json");
+  const path31 = join23(workspace, ".reply-blocklist.json");
   try {
-    if (existsSync18(path30)) {
-      const raw = readFileSync18(path30, "utf-8");
+    if (existsSync18(path31)) {
+      const raw = readFileSync18(path31, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.blockedUserIds) {
         for (const id of parsed.blockedUserIds) {
@@ -16589,9 +16844,9 @@ function ensureLoaded(workspace, configIds) {
   loaded = true;
 }
 function save(workspace) {
-  const path30 = join23(workspace, ".reply-blocklist.json");
+  const path31 = join23(workspace, ".reply-blocklist.json");
   try {
-    writeFileSync14(path30, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync14(path31, JSON.stringify(state, null, 2), "utf-8");
   } catch (err) {
     console.warn(`[reply-blocklist] Failed to save: ${err.message}`);
   }
@@ -17108,9 +17363,9 @@ function cosineSim(a, b) {
 }
 function readDbEmbeddings(dbPath) {
   const { DatabaseSync: DatabaseSync2 } = require3("node:sqlite");
-  const db = new DatabaseSync2(dbPath, { readOnly: true });
+  const db2 = new DatabaseSync2(dbPath, { readOnly: true });
   try {
-    const stmt = db.prepare(`
+    const stmt = db2.prepare(`
       SELECT file_path, name, description, mtime, embedding
       FROM files
       WHERE embedding IS NOT NULL AND deprecated_by IS NULL
@@ -17127,7 +17382,7 @@ function readDbEmbeddings(dbPath) {
     }
     return rows;
   } finally {
-    db.close();
+    db2.close();
   }
 }
 async function llmRerank(query, candidates, topK, ollamaChatUrl, model) {
@@ -17504,6 +17759,69 @@ var init_light_mode = __esm({
   }
 });
 
+// src/compact/voiceFastView.ts
+function blocksText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.filter((b) => b && b.type === "text").map((b) => b.text || "").join(" ");
+  return "";
+}
+function splitTurns(history) {
+  const turns = [];
+  let cur = [];
+  for (const m of history) {
+    if (m.role === "user" && cur.length > 0) {
+      turns.push(cur);
+      cur = [m];
+    } else cur.push(m);
+  }
+  if (cur.length > 0) turns.push(cur);
+  return turns;
+}
+function voiceFastView(history, opts = VOICE_FAST_DEFAULTS) {
+  const { keepTurns, toolCap, argCap } = opts;
+  const turns = splitTurns(history);
+  const oldTurns = turns.slice(0, Math.max(0, turns.length - keepTurns));
+  const keepTurnsArr = turns.slice(Math.max(0, turns.length - keepTurns));
+  const folded = oldTurns.map(
+    (turn) => turn.map((m) => {
+      if (m.role === "toolResult") {
+        const text = blocksText(m.content);
+        if (text.length > toolCap) {
+          const compressed = smartCompressToolResult(text, void 0, toolCap);
+          return { ...m, content: [{ type: "text", text: compressed }] };
+        }
+        return m;
+      }
+      if (m.role === "assistant" && Array.isArray(m.content)) {
+        const newContent = m.content.map((b) => {
+          if (b && b.type === "toolCall" && b.arguments) {
+            const argStr = typeof b.arguments === "string" ? b.arguments : JSON.stringify(b.arguments);
+            if (argStr.length > argCap) {
+              return { ...b, arguments: argStr.slice(0, argCap) + "\u2026[voice-fold]" };
+            }
+          }
+          return b;
+        });
+        return { ...m, content: newContent };
+      }
+      return m;
+    })
+  );
+  const out = [...folded.flat(), ...keepTurnsArr.flat()];
+  const before = JSON.stringify(history).length;
+  const saved = before - JSON.stringify(out).length;
+  console.log(`[voice-fast] ${history.length} \u2192 ${out.length} \u6761 (keepTurns=${keepTurns}, toolCap=${toolCap}, argCap=${argCap}, -${(saved * 100 / Math.max(1, before)).toFixed(0)}%)`);
+  return out;
+}
+var VOICE_FAST_DEFAULTS;
+var init_voiceFastView = __esm({
+  "src/compact/voiceFastView.ts"() {
+    "use strict";
+    init_ruleCompact();
+    VOICE_FAST_DEFAULTS = { keepTurns: 5, toolCap: 500, argCap: 100 };
+  }
+});
+
 // src/sender-context.ts
 import { readFileSync as readFileSync21, existsSync as existsSync20 } from "node:fs";
 import { join as join28 } from "node:path";
@@ -17671,8 +17989,8 @@ var extractMemories_exports = {};
 __export(extractMemories_exports, {
   createMemoryExtractor: () => createMemoryExtractor
 });
-import * as fs24 from "fs";
-import * as path25 from "path";
+import * as fs25 from "fs";
+import * as path26 from "path";
 function isModelVisibleMessage(message) {
   return message.role === "user" || message.role === "assistant";
 }
@@ -17695,13 +18013,13 @@ function getMemoryTools() {
   return allDefs.filter((d) => MEMORY_TOOL_NAMES.includes(d.function.name));
 }
 function getStatePath(workspace) {
-  return path25.join(workspace, STATE_FILE);
+  return path26.join(workspace, STATE_FILE);
 }
 function loadPersistedState(workspace) {
   try {
     const p = getStatePath(workspace);
-    if (fs24.existsSync(p)) {
-      const data = JSON.parse(fs24.readFileSync(p, "utf-8"));
+    if (fs25.existsSync(p)) {
+      const data = JSON.parse(fs25.readFileSync(p, "utf-8"));
       for (const [sid, ts] of Object.entries(data.lastTs ?? {})) {
         lastTsMap.set(sid, ts);
       }
@@ -17721,7 +18039,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);
-    fs24.writeFileSync(getStatePath(workspace), data, "utf-8");
+    fs25.writeFileSync(getStatePath(workspace), data, "utf-8");
   } catch (e) {
     console.warn(`[memory] failed to persist extract state: ${e?.message ?? e}`);
   }
@@ -17762,11 +18080,11 @@ function createMemoryExtractor(workspace, enabled) {
         const existingMemories = formatMemoryManifest(
           await scanMemoryFiles2(memoryDir, new AbortController().signal)
         );
-        const extractOverridePath = path25.join(workspace, "prompts", "extract.md");
+        const extractOverridePath = path26.join(workspace, "prompts", "extract.md");
         let systemPrompt;
         try {
-          if (fs24.existsSync(extractOverridePath)) {
-            systemPrompt = fs24.readFileSync(extractOverridePath, { encoding: "utf-8" });
+          if (fs25.existsSync(extractOverridePath)) {
+            systemPrompt = fs25.readFileSync(extractOverridePath, { encoding: "utf-8" });
             if (existingMemories.length > 0) {
               systemPrompt += `
 
@@ -17867,8 +18185,8 @@ var ingest_exports = {};
 __export(ingest_exports, {
   pushConversation: () => pushConversation
 });
-import fs25 from "node:fs";
-import path26 from "node:path";
+import fs26 from "node:fs";
+import path27 from "node:path";
 function parseMeta(text) {
   const m = text.match(/^\[meta:\s*(.+?)\s*\((.+?)\)\s*@(\S+)\s*[^\]]*\]/);
   if (!m) return null;
@@ -17901,9 +18219,9 @@ async function readConfig() {
 }
 function loadPushTs(workspace, sessionId) {
   try {
-    const p = path26.join(workspace, PUSH_STATE_FILE);
-    if (fs25.existsSync(p)) {
-      const data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+    const p = path27.join(workspace, PUSH_STATE_FILE);
+    if (fs26.existsSync(p)) {
+      const data = JSON.parse(fs26.readFileSync(p, "utf-8"));
       return typeof data[sessionId] === "number" ? data[sessionId] : 0;
     }
   } catch (e) {
@@ -17913,14 +18231,14 @@ function loadPushTs(workspace, sessionId) {
 }
 function savePushTs(workspace, sessionId, ts) {
   try {
-    const p = path26.join(workspace, PUSH_STATE_FILE);
+    const p = path27.join(workspace, PUSH_STATE_FILE);
     let data = {};
     try {
-      if (fs25.existsSync(p)) data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+      if (fs26.existsSync(p)) data = JSON.parse(fs26.readFileSync(p, "utf-8"));
     } catch {
     }
     data[sessionId] = ts;
-    fs25.writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
+    fs26.writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
   } catch (e) {
     console.warn(`[everos-ingest] save pushTs failed: ${e?.message ?? e}`);
   }
@@ -18569,11 +18887,11 @@ async function readLastConsolidatedAt(memoryDir) {
   }
 }
 async function tryAcquireConsolidationLock(memoryDir) {
-  const path30 = lockPath(memoryDir);
+  const path31 = lockPath(memoryDir);
   let mtimeMs;
   let holderPid;
   try {
-    const [s, raw] = await Promise.all([stat3(path30), readFile5(path30, "utf8")]);
+    const [s, raw] = await Promise.all([stat3(path31), readFile5(path31, "utf8")]);
     mtimeMs = s.mtimeMs;
     const parsed = parseInt(raw.trim(), 10);
     holderPid = Number.isFinite(parsed) ? parsed : void 0;
@@ -18586,10 +18904,10 @@ async function tryAcquireConsolidationLock(memoryDir) {
     }
   }
   await mkdir3(memoryDir, { recursive: true });
-  await writeFile4(path30, String(process.pid));
+  await writeFile4(path31, String(process.pid));
   let verify;
   try {
-    verify = await readFile5(path30, "utf8");
+    verify = await readFile5(path31, "utf8");
   } catch {
     return null;
   }
@@ -18597,15 +18915,15 @@ async function tryAcquireConsolidationLock(memoryDir) {
   return mtimeMs ?? 0;
 }
 async function rollbackConsolidationLock(memoryDir, priorMtime) {
-  const path30 = lockPath(memoryDir);
+  const path31 = lockPath(memoryDir);
   try {
     if (priorMtime === 0) {
-      await unlink(path30);
+      await unlink(path31);
       return;
     }
-    await writeFile4(path30, "");
+    await writeFile4(path31, "");
     const t = priorMtime / 1e3;
-    await utimes(path30, t, t);
+    await utimes(path31, t, t);
   } catch (e) {
     console.log(`[autoDream] rollback failed: ${e.message} \u2014 next trigger delayed to minHours`);
   }
@@ -18888,34 +19206,30 @@ var handle_query_exports = {};
 __export(handle_query_exports, {
   handleQuery: () => handleQuery,
   resetSessionStartInjection: () => resetSessionStartInjection,
-  resetWorkModeInjection: () => resetWorkModeInjection,
   resolveSystemPrompt: () => resolveSystemPrompt
 });
 import { readFileSync as readFileSync25, existsSync as existsSync22 } from "node:fs";
 import { join as join33, resolve as resolve8 } from "node:path";
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 function resolveSystemPrompt(v) {
   return typeof v === "function" ? v() : v || "";
 }
 function resetSessionStartInjection(sessionId) {
   sessionStartDone.delete(sessionId);
 }
-function resetWorkModeInjection(sessionId) {
-  workModeInjected.delete(sessionId);
-}
 function loadExternalChanRules(workspace) {
-  const path30 = join33(workspace, "prompts", "external-chan-rules.md");
-  if (externalChanRulesCache && externalChanRulesCache.path === path30) return externalChanRulesCache;
+  const path31 = join33(workspace, "prompts", "external-chan-rules.md");
+  if (externalChanRulesCache && externalChanRulesCache.path === path31) return externalChanRulesCache;
   let content = "";
-  if (existsSync22(path30)) {
+  if (existsSync22(path31)) {
     try {
-      content = readFileSync25(path30, "utf-8").trim();
+      content = readFileSync25(path31, "utf-8").trim();
     } catch (e) {
       console.warn(`[external-chan-rules] Failed to load: ${e}`);
     }
   }
-  externalChanRulesCache = { path: path30, content };
-  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path30}`);
+  externalChanRulesCache = { path: path31, content };
+  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path31}`);
   return externalChanRulesCache;
 }
 function getExternalChanRulesBlock(inboundMeta, workspace) {
@@ -19123,7 +19437,13 @@ ${text}` : text });
   const isLight = isLightMode(chatMode, channelName) && chatMode !== "emotion";
   const lightN = resolveLightN(channelName);
   const lightHistory = buildLightHistory(history, { isLight, lightN, channelName, chatMode, recallFull: emotionStripped });
-  const messages = [...lightHistory, msg.user(userMsgContent)];
+  const voiceFastOn = channelName === "voice-chat" && chatMode === "work";
+  const finalHistory = voiceFastOn ? voiceFastView(lightHistory, {
+    keepTurns: liveConfig.get("voiceChat.voiceFast.keepTurns") ?? 5,
+    toolCap: liveConfig.get("voiceChat.voiceFast.toolCap") ?? 500,
+    argCap: liveConfig.get("voiceChat.voiceFast.argCap") ?? 100
+  }) : lightHistory;
+  const messages = [...finalHistory, msg.user(userMsgContent)];
   if (deps.mcpManager && !deps.mcpManager.isMcpDeltaSent(sessionId)) {
     const delta = deps.mcpManager.getMcpDelta();
     if (delta && delta.addedBlocks.length > 0) {
@@ -19177,30 +19497,6 @@ ${text}` : text });
       }
     }
   }
-  if (chatMode === "emotion") {
-    if (workModeInjected.has(sessionId)) workModeInjected.delete(sessionId);
-  } else if (!workModeInjected.has(sessionId)) {
-    workModeInjected.add(sessionId);
-    try {
-      const sr = await executeSessionStartHooks(channelName === "cli" ? "cli" : "channel", {
-        sessionId,
-        workspace,
-        cwd: workspace,
-        channel: channelName === "cli" ? "console" : channelName,
-        senderId: inboundMeta?.from || "",
-        channelType: inboundMeta?.channelType || "",
-        source
-      });
-      if (sr.additionalContexts && sr.additionalContexts.length > 0) {
-        const att = createAttachmentMessage({ type: "session_start", text: sr.additionalContexts.join("\n\n") });
-        history.push(att);
-        messages.push(att);
-        console.log(`[hooks] work-mode injection: ${sr.additionalContexts.length} additionalContext(s) at END of messages (session ${sessionId}, cache-safe, persisted)`);
-      }
-    } catch (err) {
-      console.warn(`[hooks] work-mode injection error: ${err.message}`);
-    }
-  }
   const pendingNotifications2 = drainPendingNotifications();
   if (pendingNotifications2.length > 0) {
     messages.push(createAttachmentMessage({
@@ -19221,7 +19517,7 @@ ${text}` : text });
     }));
     console.log(`[handle-query] Injected ${teammateMsgs.length} teammate message(s): ${teammateMsgs.map((m) => `[from=${m.from}] ${(m.text || "").slice(0, 80).replace(/\n/g, " ")}`).join(" | ")}`);
   }
-  if (channelName !== "heartbeat" && channelName !== "cron" && channelName !== "inner-voice" && channelName !== "cognifold") {
+  if (channelName !== "heartbeat" && channelName !== "cron" && channelName !== "inner-voice" && channelName !== "proactive") {
     sessions.touch(sessionId);
   }
   const toolContext = {
@@ -19665,7 +19961,7 @@ stack: ${err.stack ?? "(none)"}`);
     }
   } catch (err) {
     try {
-      (await import("node:fs")).appendFileSync(join33(process.env.ENGINE7_STATE_DIR || path27.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(join33(process.env.ENGINE7_STATE_DIR || path28.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 {
@@ -19683,7 +19979,7 @@ function roughTokenCount(messages) {
   }
   return total;
 }
-var sessionStartDone, workModeInjected, externalChanRulesCache;
+var sessionStartDone, externalChanRulesCache;
 var init_handle_query = __esm({
   "src/handle-query.ts"() {
     "use strict";
@@ -19703,9 +19999,9 @@ var init_handle_query = __esm({
     init_findRelevantMemoriesEveros();
     init_paths();
     init_light_mode();
+    init_voiceFastView();
     init_sender_context();
     sessionStartDone = /* @__PURE__ */ new Set();
-    workModeInjected = /* @__PURE__ */ new Set();
     externalChanRulesCache = null;
   }
 });
@@ -20211,20 +20507,20 @@ __export(cli_travel_exports, {
   loadTravelConfig: () => loadTravelConfig,
   saveTravelConfig: () => saveTravelConfig
 });
-import * as path28 from "node:path";
-import * as fs26 from "node:fs";
+import * as path29 from "node:path";
+import * as fs27 from "node:fs";
 import * as os4 from "node:os";
 import { execSync as execSync2 } from "node:child_process";
 function loadTravelConfig() {
   try {
-    if (!fs26.existsSync(CONFIG_PATH)) return null;
-    return JSON.parse(fs26.readFileSync(CONFIG_PATH, "utf-8"));
+    if (!fs27.existsSync(CONFIG_PATH)) return null;
+    return JSON.parse(fs27.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveTravelConfig(cfg) {
-  fs26.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+  fs27.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
 }
 function sanitizeContent(content, dirs) {
   let result2 = content;
@@ -20249,7 +20545,7 @@ function restoreContent(content, dirs) {
   return result2;
 }
 function isTextFile(filePath) {
-  const ext = path28.extname(filePath).toLowerCase();
+  const ext = path29.extname(filePath).toLowerCase();
   return TEXT_EXTENSIONS.has(ext);
 }
 function shouldExclude(name) {
@@ -20264,14 +20560,14 @@ function shouldExclude(name) {
 }
 function collectFiles(rootDir, includeSet, optionalSet) {
   const files = [];
-  const entries2 = fs26.readdirSync(rootDir, { withFileTypes: true });
+  const entries2 = fs27.readdirSync(rootDir, { withFileTypes: true });
   for (const entry of entries2) {
     if (shouldExclude(entry.name)) continue;
-    const fullPath = path28.join(rootDir, entry.name);
-    const realPath = fs26.realpathSync(fullPath);
+    const fullPath = path29.join(rootDir, entry.name);
+    const realPath = fs27.realpathSync(fullPath);
     if (realPath !== fullPath) {
       try {
-        const lstat = fs26.lstatSync(fullPath);
+        const lstat = fs27.lstatSync(fullPath);
         if (lstat.isSymbolicLink()) {
           continue;
         }
@@ -20292,12 +20588,12 @@ function collectFiles(rootDir, includeSet, optionalSet) {
 function collectAllFiles(dir) {
   const files = [];
   try {
-    const entries2 = fs26.readdirSync(dir, { withFileTypes: true });
+    const entries2 = fs27.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries2) {
       if (shouldExclude(entry.name)) continue;
-      const fullPath = path28.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       try {
-        if (fs26.lstatSync(fullPath).isSymbolicLink()) continue;
+        if (fs27.lstatSync(fullPath).isSymbolicLink()) continue;
       } catch {
       }
       if (entry.isDirectory()) {
@@ -20312,16 +20608,16 @@ function collectAllFiles(dir) {
 }
 function readMainEngineUuid(agentsDir) {
   try {
-    const platformMapPath = path28.join(agentsDir, "main", "sessions", "platform-map.json");
-    const indexMapPath = path28.join(agentsDir, "main", "sessions", "session-index.json");
-    if (!fs26.existsSync(platformMapPath) || !fs26.existsSync(indexMapPath)) return null;
-    const platformMap = JSON.parse(fs26.readFileSync(platformMapPath, "utf-8"));
+    const platformMapPath = path29.join(agentsDir, "main", "sessions", "platform-map.json");
+    const indexMapPath = path29.join(agentsDir, "main", "sessions", "session-index.json");
+    if (!fs27.existsSync(platformMapPath) || !fs27.existsSync(indexMapPath)) return null;
+    const platformMap = JSON.parse(fs27.readFileSync(platformMapPath, "utf-8"));
     const mainPlatformId = platformMap["scope:main"] || platformMap["main"];
     if (!mainPlatformId) return null;
-    const indexMap = JSON.parse(fs26.readFileSync(indexMapPath, "utf-8"));
+    const indexMap = JSON.parse(fs27.readFileSync(indexMapPath, "utf-8"));
     const entry = indexMap[mainPlatformId];
     if (!entry || !entry.file) return null;
-    const basename8 = path28.basename(entry.file).replace(/\.jsonl$/, "");
+    const basename8 = path29.basename(entry.file).replace(/\.jsonl$/, "");
     return basename8;
   } catch {
     return null;
@@ -20329,13 +20625,13 @@ function readMainEngineUuid(agentsDir) {
 }
 function collectRecentSessions(agentsDir, _days = 7) {
   const files = [];
-  if (!fs26.existsSync(agentsDir)) return files;
+  if (!fs27.existsSync(agentsDir)) return files;
   const sessionGroups = /* @__PURE__ */ new Map();
   function scanSessionsDir(dir) {
     try {
-      const entries2 = fs26.readdirSync(dir, { withFileTypes: true });
+      const entries2 = fs27.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries2) {
-        const fullPath = path28.join(dir, entry.name);
+        const fullPath = path29.join(dir, entry.name);
         if (entry.isDirectory()) {
           scanSessionsDir(fullPath);
           continue;
@@ -20359,7 +20655,7 @@ function collectRecentSessions(agentsDir, _days = 7) {
         if (entry.name.endsWith(".jsonl")) {
           group.jsonl = fullPath;
         } else {
-          const stat4 = fs26.statSync(fullPath);
+          const stat4 = fs27.statSync(fullPath);
           group.archived.push({ file: fullPath, mtime: stat4.mtimeMs });
         }
       }
@@ -20378,37 +20674,37 @@ function collectRecentSessions(agentsDir, _days = 7) {
 }
 async function doExport(opts) {
   const { agentName, stateDir, note, dryRun: dryRun2 } = opts;
-  const workspace = (opts.workspace || path28.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
-  const engineHome = path28.join(os4.homedir(), ".engine7").replace(/[/\\]+$/, "");
+  const workspace = (opts.workspace || path29.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
+  const engineHome = path29.join(os4.homedir(), ".engine7").replace(/[/\\]+$/, "");
   console.log(`\u{1F4E6} engine7 export`);
   console.log(`   agent: ${agentName}`);
   console.log(`   state: ${stateDir}`);
   console.log(`   workspace: ${workspace}`);
-  if (!fs26.existsSync(workspace)) {
+  if (!fs27.existsSync(workspace)) {
     console.error(`\u274C workspace \u4E0D\u5B58\u5728: ${workspace}`);
     process.exit(1);
   }
   const dirs = { workspace, stateDir, engineHome };
   const wsFiles = collectFiles(workspace, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL);
-  const sessionFiles = collectRecentSessions(path28.join(stateDir, "agents"), 7);
-  const configsDir = path28.join(stateDir, "configs");
+  const sessionFiles = collectRecentSessions(path29.join(stateDir, "agents"), 7);
+  const configsDir = path29.join(stateDir, "configs");
   const configFiles = [];
-  if (fs26.existsSync(configsDir)) {
+  if (fs27.existsSync(configsDir)) {
     for (const f of collectAllFiles(configsDir)) {
-      if (shouldExclude(path28.basename(f))) continue;
+      if (shouldExclude(path29.basename(f))) continue;
       configFiles.push(f);
     }
   }
   const EVEROS_SKIP = /* @__PURE__ */ new Set([".tmp", ".lock", "import.log", "import_progress.json"]);
-  const everosDir = path28.join(stateDir, ".everos");
+  const everosDir = path29.join(stateDir, ".everos");
   const everosFiles = [];
-  if (fs26.existsSync(everosDir)) {
+  if (fs27.existsSync(everosDir)) {
     for (const f of collectAllFiles(everosDir)) {
-      if (EVEROS_SKIP.has(path28.basename(f))) continue;
+      if (EVEROS_SKIP.has(path29.basename(f))) continue;
       everosFiles.push(f);
     }
-    const walFile = path28.join(everosDir, ".index", "sqlite", "system.db-wal");
-    if (fs26.existsSync(walFile) && fs26.statSync(walFile).size > 0) {
+    const walFile = path29.join(everosDir, ".index", "sqlite", "system.db-wal");
+    if (fs27.existsSync(walFile) && fs27.statSync(walFile).size > 0) {
       console.warn(`\u26A0\uFE0F  .everos/system.db-wal \u975E\u7A7A\u2014\u2014everos \u670D\u52A1\u53EF\u80FD\u6B63\u5728\u5199\u5165\uFF0C\u5FEB\u7167\u53EF\u80FD\u4E0D\u4E00\u81F4`);
       console.warn(`   \u5EFA\u8BAE: \u5148\u505C everos \u670D\u52A1\u518D export\uFF0C\u6216 import \u540E\u91CD\u5EFA\u7D22\u5F15`);
     }
@@ -20416,16 +20712,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 + fs26.statSync(f).size, 0) / 1024 / 1024).toFixed(1)} MB)`);
+  console.log(`   everos: ${everosFiles.length} (${(everosFiles.reduce((s, f) => s + fs27.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(`   ${path28.relative(workspace, f)}`));
+    wsFiles.slice(0, 20).forEach((f) => console.log(`   ${path29.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(`   ${path28.relative(stateDir, f)}`));
+      everosFiles.slice(0, 10).forEach((f) => console.log(`   ${path29.relative(stateDir, f)}`));
       if (everosFiles.length > 10) console.log(`   ... \u8FD8\u6709 ${everosFiles.length - 10} \u4E2A\u6587\u4EF6`);
     }
     console.log(`
@@ -20434,46 +20730,46 @@ async function doExport(opts) {
   }
   const now = /* @__PURE__ */ new Date();
   const version = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
-  const tmpDir = path28.join(os4.tmpdir(), `engine7-export-${agentName}-${version}`);
-  fs26.mkdirSync(tmpDir, { recursive: true });
-  const stagingDir = path28.join(tmpDir, agentName);
-  fs26.mkdirSync(stagingDir, { recursive: true });
+  const tmpDir = path29.join(os4.tmpdir(), `engine7-export-${agentName}-${version}`);
+  fs27.mkdirSync(tmpDir, { recursive: true });
+  const stagingDir = path29.join(tmpDir, agentName);
+  fs27.mkdirSync(stagingDir, { recursive: true });
   let fileCount = 0;
   let totalSize = 0;
   let copyFail = 0;
   const copyOne = (srcFile, relRoot, destRoot) => {
-    const relPath = path28.relative(relRoot, srcFile);
-    const destFile = path28.join(destRoot, relPath);
-    fs26.mkdirSync(path28.dirname(destFile), { recursive: true });
+    const relPath = path29.relative(relRoot, srcFile);
+    const destFile = path29.join(destRoot, relPath);
+    fs27.mkdirSync(path29.dirname(destFile), { recursive: true });
     try {
       if (isTextFile(srcFile)) {
-        const content = fs26.readFileSync(srcFile, "utf-8");
-        fs26.writeFileSync(destFile, sanitizeContent(content, dirs));
+        const content = fs27.readFileSync(srcFile, "utf-8");
+        fs27.writeFileSync(destFile, sanitizeContent(content, dirs));
       } else {
-        fs26.copyFileSync(srcFile, destFile);
+        fs27.copyFileSync(srcFile, destFile);
       }
       fileCount++;
-      totalSize += fs26.statSync(srcFile).size;
+      totalSize += fs27.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, path28.join(stagingDir, "workspace"));
+  for (const srcFile of wsFiles) copyOne(srcFile, workspace, path29.join(stagingDir, "workspace"));
   for (const srcFile of sessionFiles) {
-    const relPath = path28.relative(stateDir, srcFile);
-    const destFile = path28.join(stagingDir, relPath);
-    fs26.mkdirSync(path28.dirname(destFile), { recursive: true });
+    const relPath = path29.relative(stateDir, srcFile);
+    const destFile = path29.join(stagingDir, relPath);
+    fs27.mkdirSync(path29.dirname(destFile), { recursive: true });
     try {
-      let content = fs26.readFileSync(srcFile, "utf-8");
+      let content = fs27.readFileSync(srcFile, "utf-8");
       content = sanitizeContent(content, dirs);
-      const baseName = path28.basename(srcFile);
+      const baseName = path29.basename(srcFile);
       if (baseName === "session-index.json" || baseName === "platform-map.json") {
         content = content.split("\\\\").join("/");
       }
-      fs26.writeFileSync(destFile, content);
+      fs27.writeFileSync(destFile, content);
       fileCount++;
-      totalSize += fs26.statSync(srcFile).size;
+      totalSize += fs27.statSync(srcFile).size;
     } catch (e) {
       copyFail++;
       console.warn(`   \u26A0\uFE0F \u62F7\u8D1D\u5931\u8D25: ${relPath} (${e.code || e.message})`);
@@ -20495,13 +20791,13 @@ async function doExport(opts) {
     totalSize,
     note
   };
-  fs26.writeFileSync(path28.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  const archiveFile = path28.join(tmpDir, `${agentName}-${version}.tar.gz`);
+  fs27.writeFileSync(path29.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  const archiveFile = path29.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 = fs26.statSync(archiveFile).size;
+  const archiveSize = fs27.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) {
@@ -20524,8 +20820,8 @@ async function doImport(opts) {
     console.error(`   \u914D\u7F6E: \u7F16\u8F91 ${CONFIG_PATH}`);
     process.exit(1);
   }
-  const tmpDir = path28.join(os4.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
-  fs26.mkdirSync(tmpDir, { recursive: true });
+  const tmpDir = path29.join(os4.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
+  fs27.mkdirSync(tmpDir, { recursive: true });
   const archiveFile = await downloadFromGitHub(cfg, agentName, version, tmpDir);
   console.log(`\u2705 \u4E0B\u8F7D\u5B8C\u6210: ${archiveFile}`);
   if (dryRun2) {
@@ -20536,99 +20832,99 @@ 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 "${archiveFile}" -C "${tmpDir}"`, { stdio: "pipe" });
-  const stagingDir = path28.join(tmpDir, agentName);
-  const manifestPath = path28.join(stagingDir, "manifest.json");
-  if (!fs26.existsSync(manifestPath)) {
+  const stagingDir = path29.join(tmpDir, agentName);
+  const manifestPath = path29.join(stagingDir, "manifest.json");
+  if (!fs27.existsSync(manifestPath)) {
     console.error(`\u274C manifest.json \u4E0D\u5B58\u5728\uFF0C\u6587\u4EF6\u53EF\u80FD\u635F\u574F`);
     process.exit(1);
   }
-  const manifest = JSON.parse(fs26.readFileSync(manifestPath, "utf-8"));
-  const workspace = path28.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
-  const engineHome = path28.join(os4.homedir(), ".engine7").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const manifest = JSON.parse(fs27.readFileSync(manifestPath, "utf-8"));
+  const workspace = path29.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const engineHome = path29.join(os4.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 = path28.join(stagingDir, "workspace");
+  const wsStaging = path29.join(stagingDir, "workspace");
   let restoredCount = 0;
   let skipCount = 0;
-  if (fs26.existsSync(wsStaging)) {
+  if (fs27.existsSync(wsStaging)) {
     const allFiles = collectAllFiles(wsStaging);
     for (const srcFile of allFiles) {
-      const relPath = path28.relative(wsStaging, srcFile);
-      const destFile = path28.join(workspace, relPath);
-      fs26.mkdirSync(path28.dirname(destFile), { recursive: true });
+      const relPath = path29.relative(wsStaging, srcFile);
+      const destFile = path29.join(workspace, relPath);
+      fs27.mkdirSync(path29.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs26.readFileSync(srcFile, "utf-8");
-          fs26.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs27.readFileSync(srcFile, "utf-8");
+          fs27.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs26.copyFileSync(srcFile, destFile);
+          fs27.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path28.relative(wsStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path29.relative(wsStaging, srcFile)} (${e.code || e.message})`);
       }
     }
   }
-  const agentsStaging = path28.join(stagingDir, "agents");
-  if (fs26.existsSync(agentsStaging)) {
+  const agentsStaging = path29.join(stagingDir, "agents");
+  if (fs27.existsSync(agentsStaging)) {
     const sessionFiles = collectAllFiles(agentsStaging);
     for (const srcFile of sessionFiles) {
-      const relPath = path28.relative(stagingDir, srcFile);
-      const destFile = path28.join(stateDir, relPath);
-      fs26.mkdirSync(path28.dirname(destFile), { recursive: true });
-      const content = fs26.readFileSync(srcFile, "utf-8");
-      fs26.writeFileSync(destFile, restoreContent(content, dirs));
+      const relPath = path29.relative(stagingDir, srcFile);
+      const destFile = path29.join(stateDir, relPath);
+      fs27.mkdirSync(path29.dirname(destFile), { recursive: true });
+      const content = fs27.readFileSync(srcFile, "utf-8");
+      fs27.writeFileSync(destFile, restoreContent(content, dirs));
       restoredCount++;
     }
   }
-  const configsStaging = path28.join(stagingDir, "configs");
-  if (fs26.existsSync(configsStaging)) {
+  const configsStaging = path29.join(stagingDir, "configs");
+  if (fs27.existsSync(configsStaging)) {
     const cfgFiles = collectAllFiles(configsStaging);
     for (const srcFile of cfgFiles) {
-      const relPath = path28.relative(stagingDir, srcFile);
-      const destFile = path28.join(stateDir, relPath);
-      fs26.mkdirSync(path28.dirname(destFile), { recursive: true });
+      const relPath = path29.relative(stagingDir, srcFile);
+      const destFile = path29.join(stateDir, relPath);
+      fs27.mkdirSync(path29.dirname(destFile), { recursive: true });
       if (isTextFile(srcFile)) {
-        const content = fs26.readFileSync(srcFile, "utf-8");
-        fs26.writeFileSync(destFile, restoreContent(content, dirs));
+        const content = fs27.readFileSync(srcFile, "utf-8");
+        fs27.writeFileSync(destFile, restoreContent(content, dirs));
       } else {
-        fs26.copyFileSync(srcFile, destFile);
+        fs27.copyFileSync(srcFile, destFile);
       }
       restoredCount++;
     }
   }
-  const everosStaging = path28.join(stagingDir, ".everos");
-  if (fs26.existsSync(everosStaging)) {
+  const everosStaging = path29.join(stagingDir, ".everos");
+  if (fs27.existsSync(everosStaging)) {
     const everosFiles = collectAllFiles(everosStaging);
     for (const srcFile of everosFiles) {
-      const relPath = path28.relative(stagingDir, srcFile);
-      const destFile = path28.join(stateDir, relPath);
-      fs26.mkdirSync(path28.dirname(destFile), { recursive: true });
+      const relPath = path29.relative(stagingDir, srcFile);
+      const destFile = path29.join(stateDir, relPath);
+      fs27.mkdirSync(path29.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs26.readFileSync(srcFile, "utf-8");
-          fs26.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs27.readFileSync(srcFile, "utf-8");
+          fs27.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs26.copyFileSync(srcFile, destFile);
+          fs27.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path28.relative(everosStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path29.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 = path28.join(stateDir, "configs", platformConfigName);
-  const configToUse = fs26.existsSync(restoredConfigPath) ? restoredConfigPath : path28.join(stateDir, "configs", "xiaoke.json");
+  const restoredConfigPath = path29.join(stateDir, "configs", platformConfigName);
+  const configToUse = fs27.existsSync(restoredConfigPath) ? restoredConfigPath : path29.join(stateDir, "configs", "xiaoke.json");
   console.log(`
 \u{1F4A1} \u4E0B\u4E00\u6B65: engine7 start --config "${configToUse}"`);
-  fs26.rmSync(tmpDir, { recursive: true, force: true });
+  fs27.rmSync(tmpDir, { recursive: true, force: true });
 }
 async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
   const repo = `${cfg.githubOwner}/${cfg.repoName}`;
@@ -20658,8 +20954,8 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     }
     const release2 = await createRes.json();
     const uploadUrl = release2.upload_url.replace("{?name,label}", "");
-    const fileBuffer = fs26.readFileSync(archiveFile);
-    const fileName = path28.basename(archiveFile);
+    const fileBuffer = fs27.readFileSync(archiveFile);
+    const fileName = path29.basename(archiveFile);
     const uploadRes = await fetch(`${uploadUrl}?name=${fileName}`, {
       method: "POST",
       headers: {
@@ -20682,7 +20978,7 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     throw e;
   }
   try {
-    fs26.rmSync(path28.dirname(archiveFile), { recursive: true, force: true });
+    fs27.rmSync(path29.dirname(archiveFile), { recursive: true, force: true });
   } catch {
   }
 }
@@ -20714,8 +21010,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 = path28.join(destDir, asset.name);
-  fs26.writeFileSync(archiveFile, buffer);
+  const archiveFile = path29.join(destDir, asset.name);
+  fs27.writeFileSync(archiveFile, buffer);
   return archiveFile;
 }
 async function getLatestReleaseTag(cfg, agentName) {
@@ -20740,7 +21036,7 @@ var CONFIG_PATH, PATH_PLACEHOLDERS, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL, WORKS
 var init_cli_travel = __esm({
   "src/cli-travel.ts"() {
     "use strict";
-    CONFIG_PATH = path28.join(os4.homedir(), ".engine7-travel.json");
+    CONFIG_PATH = path29.join(os4.homedir(), ".engine7-travel.json");
     PATH_PLACEHOLDERS = [
       { placeholder: "{{WORKSPACE}}", getOriginal: (d) => d.workspace },
       { placeholder: "{{ENGINE_HOME}}", getOriginal: (d) => d.engineHome },
@@ -20816,8 +21112,8 @@ var init_cli_travel = __esm({
 init_feishu_quick_register();
 init_wechat();
 init_qr_render();
-import * as path29 from "node:path";
-import * as fs27 from "node:fs";
+import * as path30 from "node:path";
+import * as fs28 from "node:fs";
 import * as readline3 from "node:readline";
 import { fileURLToPath } from "node:url";
 var origEmitWarning = process.emitWarning.bind(process);
@@ -20828,7 +21124,7 @@ process.emitWarning = (warning, ...rest) => {
   return origEmitWarning(warning, ...rest);
 };
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path29.dirname(__filename);
+var __dirname = path30.dirname(__filename);
 var SCHEMA_VERSION = 1;
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -20853,10 +21149,10 @@ function parseArgs() {
     }
   }
   if (!stateDir) {
-    stateDir = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    stateDir = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
     console.log(`   \u4F7F\u7528\u9ED8\u8BA4\u76EE\u5F55: ${stateDir}`);
   }
-  stateDir = path29.resolve(stateDir);
+  stateDir = path30.resolve(stateDir);
   return { stateDir, quick, dryRun: dryRun2, force };
 }
 function printHelp() {
@@ -20957,10 +21253,10 @@ function getDefaultValues(stateDir) {
   };
 }
 function loadExistingValues(stateDir) {
-  const configPath = path29.join(stateDir, "configs", "main7.json");
+  const configPath = path30.join(stateDir, "configs", "main7.json");
   try {
-    if (!fs27.existsSync(configPath)) return {};
-    const j = JSON.parse(fs27.readFileSync(configPath, "utf8"));
+    if (!fs28.existsSync(configPath)) return {};
+    const j = JSON.parse(fs28.readFileSync(configPath, "utf8"));
     const out = {};
     if (j.agents?.defaults?.name) out.agentName = j.agents.defaults.name;
     const providers = j.models?.providers || {};
@@ -21015,15 +21311,15 @@ function loadExistingValues(stateDir) {
 }
 function readSecretsValue(stateDir, envName) {
   try {
-    const secretsDir = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
-    const cfgBase = path29.basename(stateDir) === ".engine7" ? "main7" : path29.basename(stateDir);
+    const secretsDir = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
+    const cfgBase = path30.basename(stateDir) === ".engine7" ? "main7" : path30.basename(stateDir);
     const candidates = [
-      path29.join(secretsDir, `${cfgBase}.env`),
-      path29.join(stateDir, "configs", `.env.${cfgBase}`)
+      path30.join(secretsDir, `${cfgBase}.env`),
+      path30.join(stateDir, "configs", `.env.${cfgBase}`)
     ];
     for (const p of candidates) {
-      if (fs27.existsSync(p)) {
-        for (const line of fs27.readFileSync(p, "utf8").split("\n")) {
+      if (fs28.existsSync(p)) {
+        for (const line of fs28.readFileSync(p, "utf8").split("\n")) {
           const eq = line.indexOf("=");
           if (eq > 0 && line.slice(0, eq).trim() === envName) {
             return line.slice(eq + 1).trim();
@@ -21249,7 +21545,7 @@ async function configureWechat(rl, v) {
   }
 }
 function generateConfig(v) {
-  const workspace = path29.join(v.stateDir, "workspace").replace(/\\/g, "/");
+  const workspace = path30.join(v.stateDir, "workspace").replace(/\\/g, "/");
   const config = {
     schemaVersion: SCHEMA_VERSION,
     stateDir: v.stateDir.replace(/\\/g, "/"),
@@ -21399,45 +21695,45 @@ function generateConfig(v) {
 }
 function buildDirTree(v) {
   const d = v.stateDir;
-  const w = path29.join(d, "workspace");
+  const w = path30.join(d, "workspace");
   const now = (/* @__PURE__ */ new Date()).toLocaleString("sv-SE", { timeZone: "Asia/Shanghai", hour12: false });
   return [
     // 目录
-    { path: path29.join(d, "configs"), type: "dir" },
-    { path: path29.join(d, "state", "agents", "main", "sessions"), type: "dir" },
-    { path: path29.join(w, "prompts"), type: "dir" },
-    { path: path29.join(w, "memory", "daily"), type: "dir" },
-    { path: path29.join(w, "docs", "research"), type: "dir" },
-    { path: path29.join(w, "docs", "todo"), type: "dir" },
-    { path: path29.join(w, "docs", "decisions"), type: "dir" },
-    { path: path29.join(w, "docs", "knowledge"), type: "dir" },
-    { path: path29.join(w, "docs", "sop"), type: "dir" },
-    { path: path29.join(d, "logs"), type: "dir" },
-    { path: path29.join(d, "media", "inbound"), type: "dir" },
+    { path: path30.join(d, "configs"), type: "dir" },
+    { path: path30.join(d, "state", "agents", "main", "sessions"), type: "dir" },
+    { path: path30.join(w, "prompts"), type: "dir" },
+    { path: path30.join(w, "memory", "daily"), type: "dir" },
+    { path: path30.join(w, "docs", "research"), type: "dir" },
+    { path: path30.join(w, "docs", "todo"), type: "dir" },
+    { path: path30.join(w, "docs", "decisions"), type: "dir" },
+    { path: path30.join(w, "docs", "knowledge"), type: "dir" },
+    { path: path30.join(w, "docs", "sop"), type: "dir" },
+    { path: path30.join(d, "logs"), type: "dir" },
+    { path: path30.join(d, "media", "inbound"), type: "dir" },
     // workspace 文件
     {
-      path: path29.join(w, "SESSION-STATE.md"),
+      path: path30.join(w, "SESSION-STATE.md"),
       type: "file",
       content: readTemplate("workspace/SESSION-STATE.md").replace("{{CURRENT_TIME}}", now)
     },
-    { path: path29.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
+    { path: path30.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
     {
-      path: path29.join(w, "SOUL.md"),
+      path: path30.join(w, "SOUL.md"),
       type: "file",
       content: readTemplate("workspace/SOUL.md").replace(/\{\{AGENT_NAME\}\}/g, v.agentName)
     },
-    { path: path29.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
+    { path: path30.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
     {
-      path: path29.join(w, "prompts", "contacts.md"),
+      path: path30.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: path29.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
-    { path: path29.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: path29.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: path30.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
+    { path: path30.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: path30.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" },
     // package.json — 让 agent 目录成为独立 npm 项目根，防止 npm hoisting
     {
-      path: path29.join(d, "package.json"),
+      path: path30.join(d, "package.json"),
       type: "file",
       content: JSON.stringify({
         name: v.agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-") || "agent",
@@ -21448,7 +21744,7 @@ function buildDirTree(v) {
     },
     // 启动脚本（根据 OS 生成）
     ...process.platform === "win32" ? [{
-      path: path29.join(d, "start.cmd"),
+      path: path30.join(d, "start.cmd"),
       type: "file",
       content: `@echo off
 rem Engine 7 startup script
@@ -21480,7 +21776,7 @@ if %ERRORLEVEL% NEQ 0 (
 )
 `
     }] : [{
-      path: path29.join(d, "start.sh"),
+      path: path30.join(d, "start.sh"),
       type: "file",
       content: `#!/bin/bash
 # Engine 7 startup script
@@ -21513,13 +21809,13 @@ node "$ENGINE7_BIN" --engine-config configs/main7.json
 }
 function readTemplate(relativePath) {
   const candidates = [
-    path29.join(__dirname, "..", "templates", relativePath),
-    path29.join(__dirname, "..", "..", "templates", relativePath),
-    path29.join(process.cwd(), "templates", relativePath)
+    path30.join(__dirname, "..", "templates", relativePath),
+    path30.join(__dirname, "..", "..", "templates", relativePath),
+    path30.join(process.cwd(), "templates", relativePath)
   ];
   for (const p of candidates) {
-    if (fs27.existsSync(p)) {
-      return fs27.readFileSync(p, "utf-8");
+    if (fs28.existsSync(p)) {
+      return fs28.readFileSync(p, "utf-8");
     }
   }
   throw new Error(`\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${relativePath}\uFF08\u627E\u4E86: ${candidates.join(", ")}\uFF09`);
@@ -21534,11 +21830,11 @@ function dryRun(entries2) {
 function execute(entries2) {
   for (const e of entries2) {
     if (e.type === "dir") {
-      fs27.mkdirSync(e.path, { recursive: true });
+      fs28.mkdirSync(e.path, { recursive: true });
       console.log(`  \u{1F4C1} ${e.path}`);
     } else {
-      fs27.mkdirSync(path29.dirname(e.path), { recursive: true });
-      fs27.writeFileSync(e.path, e.content || "", "utf-8");
+      fs28.mkdirSync(path30.dirname(e.path), { recursive: true });
+      fs28.writeFileSync(e.path, e.content || "", "utf-8");
       console.log(`  \u{1F4C4} ${e.path}`);
     }
   }
@@ -21572,8 +21868,8 @@ async function main() {
   if (subcommand === "--version" || subcommand === "-v") {
     let ver = "unknown";
     try {
-      const pkgPath = path29.join(path29.dirname(__filename), "..", "package.json");
-      ver = JSON.parse(fs27.readFileSync(pkgPath, "utf8")).version || "unknown";
+      const pkgPath = path30.join(path30.dirname(__filename), "..", "package.json");
+      ver = JSON.parse(fs28.readFileSync(pkgPath, "utf8")).version || "unknown";
     } catch {
     }
     console.log(`engine7 ${ver}`);
@@ -21591,18 +21887,18 @@ async function main() {
       else if (args[i] === "--config" && args[i + 1]) configName = args[++i].trim();
     }
     if (!stateDir) {
-      const cwd = path29.resolve(process.cwd());
-      if (fs27.existsSync(path29.join(cwd, "configs"))) {
+      const cwd = path30.resolve(process.cwd());
+      if (fs28.existsSync(path30.join(cwd, "configs"))) {
         stateDir = cwd;
       } else {
-        const pointer = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
-        if (fs27.existsSync(pointer)) {
+        const pointer = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+        if (fs28.existsSync(pointer)) {
           try {
-            stateDir = JSON.parse(fs27.readFileSync(pointer, "utf8")).stateDir || "";
+            stateDir = JSON.parse(fs28.readFileSync(pointer, "utf8")).stateDir || "";
           } catch {
           }
         }
-        if (!stateDir) stateDir = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+        if (!stateDir) stateDir = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
       }
     }
     if (!target && !isLegacyAddchannel) {
@@ -21622,12 +21918,12 @@ async function main() {
       process.exit(0);
     }
     if (channel === "channels") {
-      const configsDir = path29.join(stateDir, "configs");
-      if (fs27.existsSync(configsDir)) {
-        const files = fs27.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
+      const configsDir = path30.join(stateDir, "configs");
+      if (fs28.existsSync(configsDir)) {
+        const files = fs28.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
         for (const f of files) {
           try {
-            const j = JSON.parse(fs27.readFileSync(path29.join(configsDir, f), "utf8"));
+            const j = JSON.parse(fs28.readFileSync(path30.join(configsDir, f), "utf8"));
             if (!j.channels) continue;
             console.log(`
 \u{1F4C4} ${f}:`);
@@ -21673,14 +21969,14 @@ async function main() {
         console.error("\u274C \u626B\u7801\u8D85\u65F6\u6216\u5931\u8D25");
         process.exit(1);
       }
-      const configsDir2 = path29.join(stateDir, "configs");
-      let configFile2 = configName ? path29.join(configsDir2, configName) : "";
-      if (!configFile2 || !fs27.existsSync(configFile2)) {
-        if (fs27.existsSync(configsDir2)) {
-          for (const f of fs27.readdirSync(configsDir2).filter((f2) => f2.endsWith(".json"))) {
-            const full = path29.join(configsDir2, f);
+      const configsDir2 = path30.join(stateDir, "configs");
+      let configFile2 = configName ? path30.join(configsDir2, configName) : "";
+      if (!configFile2 || !fs28.existsSync(configFile2)) {
+        if (fs28.existsSync(configsDir2)) {
+          for (const f of fs28.readdirSync(configsDir2).filter((f2) => f2.endsWith(".json"))) {
+            const full = path30.join(configsDir2, f);
             try {
-              if (JSON.parse(fs27.readFileSync(full, "utf8")).channels) {
+              if (JSON.parse(fs28.readFileSync(full, "utf8")).channels) {
                 configFile2 = full;
                 break;
               }
@@ -21689,11 +21985,11 @@ async function main() {
           }
         }
       }
-      if (configFile2 && fs27.existsSync(configFile2)) {
-        const j = JSON.parse(fs27.readFileSync(configFile2, "utf8"));
+      if (configFile2 && fs28.existsSync(configFile2)) {
+        const j = JSON.parse(fs28.readFileSync(configFile2, "utf8"));
         j.channels = j.channels || {};
         j.channels.feishu = { enabled: true, appId: result2.appId, appSecret: result2.appSecret, connectionMode: "websocket", dmPolicy: "pairing", groupPolicy: "open" };
-        fs27.writeFileSync(configFile2, JSON.stringify(j, null, 2), "utf8");
+        fs28.writeFileSync(configFile2, JSON.stringify(j, null, 2), "utf8");
         console.log("\u2705 \u98DE\u4E66\u901A\u9053\u5DF2\u5199\u5165: " + configFile2);
         console.log("\u91CD\u542F\u751F\u6548: engine7 restart");
       } else {
@@ -21711,16 +22007,16 @@ async function main() {
         console.error("\u274C \u626B\u7801\u8D85\u65F6\u6216\u5931\u8D25\uFF0C\u672A\u4FEE\u6539\u4EFB\u4F55\u914D\u7F6E");
         process.exit(1);
       }
-      const configsDir = path29.join(stateDir, "configs");
+      const configsDir = path30.join(stateDir, "configs");
       let configFile = "";
       if (configName) {
-        configFile = path29.join(configsDir, configName);
-      } else if (fs27.existsSync(configsDir)) {
-        const candidates = fs27.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
+        configFile = path30.join(configsDir, configName);
+      } else if (fs28.existsSync(configsDir)) {
+        const candidates = fs28.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
         for (const f of candidates) {
-          const full = path29.join(configsDir, f);
+          const full = path30.join(configsDir, f);
           try {
-            const j2 = JSON.parse(fs27.readFileSync(full, "utf8"));
+            const j2 = JSON.parse(fs28.readFileSync(full, "utf8"));
             if (j2.channels) {
               configFile = full;
               break;
@@ -21728,14 +22024,14 @@ async function main() {
           } catch {
           }
         }
-        if (!configFile && candidates.length) configFile = path29.join(configsDir, candidates[0]);
+        if (!configFile && candidates.length) configFile = path30.join(configsDir, candidates[0]);
       }
-      if (!configFile || !fs27.existsSync(configFile)) {
+      if (!configFile || !fs28.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));
         process.exit(0);
       }
-      const j = JSON.parse(fs27.readFileSync(configFile, "utf8"));
+      const j = JSON.parse(fs28.readFileSync(configFile, "utf8"));
       j.channels = j.channels || {};
       j.channels.wechat = {
         enabled: true,
@@ -21744,7 +22040,7 @@ async function main() {
         dmPolicy: "pairing",
         group: { policy: "disabled" }
       };
-      fs27.writeFileSync(configFile, JSON.stringify(j, null, 2), "utf8");
+      fs28.writeFileSync(configFile, JSON.stringify(j, null, 2), "utf8");
       console.log(`
 \u2705 \u5FAE\u4FE1\u901A\u9053\u5DF2\u5199\u5165: ${configFile}`);
       console.log(`   accountId: ${cred.accountId}`);
@@ -21772,8 +22068,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 = path29.resolve(process.cwd());
-    if (!agentName) agentName = path29.basename(exportStateDir);
+    if (!exportStateDir) exportStateDir = path30.resolve(process.cwd());
+    if (!agentName) agentName = path30.basename(exportStateDir);
     await doExport2({ agentName, stateDir: exportStateDir, note, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -21793,7 +22089,7 @@ async function main() {
       console.error("\u274C import \u9700\u8981 --state-dir <path>");
       process.exit(1);
     }
-    if (!agentName) agentName = path29.basename(importStateDir);
+    if (!agentName) agentName = path30.basename(importStateDir);
     await doImport2({ agentName, stateDir: importStateDir, version, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -21818,18 +22114,18 @@ engine7 start \u2014 \u542F\u52A8 Engine
       }
     }
     if (!configPath2) {
-      const defaultCfg = path29.join("configs", "main7.json");
-      const homeCfg = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs27.existsSync(defaultCfg)) {
+      const defaultCfg = path30.join("configs", "main7.json");
+      const homeCfg = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs28.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs27.existsSync(homeCfg)) {
+      } else if (fs28.existsSync(homeCfg)) {
         configPath2 = homeCfg;
         console.log(`   \u4F7F\u7528\u9ED8\u8BA4 config: ${homeCfg}`);
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path29.join(ptr.stateDir, "configs", "main7.json");
-          if (fs27.existsSync(ptrCfg)) {
+          const ptrCfg = path30.join(ptr.stateDir, "configs", "main7.json");
+          if (fs28.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             console.log(`   \u4F7F\u7528 config: ${ptrCfg}`);
           }
@@ -21844,19 +22140,19 @@ engine7 start \u2014 \u542F\u52A8 Engine
     }
     const { execSync: execSync3, spawn: spawn5 } = await import("node:child_process");
     let enginePath;
-    const localPath = path29.join("node_modules", "engine7", "dist", "main.mjs");
-    if (fs27.existsSync(localPath)) {
+    const localPath = path30.join("node_modules", "engine7", "dist", "main.mjs");
+    if (fs28.existsSync(localPath)) {
       enginePath = localPath;
     } else {
-      const cliPath = path29.resolve(process.argv[1]);
-      const distDir = path29.dirname(cliPath);
-      const candidate = path29.join(distDir, "main.mjs");
-      if (fs27.existsSync(candidate)) {
+      const cliPath = path30.resolve(process.argv[1]);
+      const distDir = path30.dirname(cliPath);
+      const candidate = path30.join(distDir, "main.mjs");
+      if (fs28.existsSync(candidate)) {
         enginePath = candidate;
       } else {
         try {
           const globalRoot = execSync3("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-          enginePath = path29.join(globalRoot, "engine7", "dist", "main.mjs");
+          enginePath = path30.join(globalRoot, "engine7", "dist", "main.mjs");
         } catch {
           console.error("\u274C \u627E\u4E0D\u5230 engine7 main.mjs");
           process.exit(1);
@@ -21866,7 +22162,7 @@ engine7 start \u2014 \u542F\u52A8 Engine
     console.log(label);
     console.log(`   config: ${configPath2}`);
     console.log(`   engine: ${enginePath}`);
-    const configName = path29.basename(configPath2);
+    const configName = path30.basename(configPath2);
     const myPid = process.pid;
     try {
       if (process.platform === "win32") {
@@ -21884,16 +22180,16 @@ engine7 start \u2014 \u542F\u52A8 Engine
     }
     console.log("");
     const envForChild = { ...process.env };
-    const secretsDir = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
-    const cfgBase = path29.basename(configPath2, ".json");
+    const secretsDir = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
+    const cfgBase = path30.basename(configPath2, ".json");
     const secretCandidates = [
-      path29.join(secretsDir, `${cfgBase}.env`),
-      path29.join(path29.dirname(configPath2), `.env.${cfgBase}`),
-      path29.join(path29.dirname(configPath2), ".env")
+      path30.join(secretsDir, `${cfgBase}.env`),
+      path30.join(path30.dirname(configPath2), `.env.${cfgBase}`),
+      path30.join(path30.dirname(configPath2), ".env")
     ];
     for (const secretPath of secretCandidates) {
-      if (fs27.existsSync(secretPath)) {
-        const content = fs27.readFileSync(secretPath, "utf-8");
+      if (fs28.existsSync(secretPath)) {
+        const content = fs28.readFileSync(secretPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -21968,14 +22264,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(fs27.readFileSync(configPath2, "utf-8"));
+      const configRaw = JSON.parse(fs28.readFileSync(configPath2, "utf-8"));
       const stateDir = configRaw.stateDir;
       if (!stateDir) {
         console.error("\u274C config \u91CC\u6CA1\u6709 stateDir");
         process.exit(1);
       }
-      const sessionsDir = path29.join(stateDir, "agents", "main", "sessions");
-      if (!fs27.existsSync(sessionsDir)) {
+      const sessionsDir = path30.join(stateDir, "agents", "main", "sessions");
+      if (!fs28.existsSync(sessionsDir)) {
         console.error(`\u274C sessions \u76EE\u5F55\u4E0D\u5B58\u5728: ${sessionsDir}`);
         process.exit(1);
       }
@@ -21983,37 +22279,37 @@ 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 = path29.join(sessionsDir, "platform-map.json");
-      const indexPath = path29.join(sessionsDir, "session-index.json");
+      const platformMapPath = path30.join(sessionsDir, "platform-map.json");
+      const indexPath = path30.join(sessionsDir, "session-index.json");
       let sessionFileUUID = null;
-      if (fs27.existsSync(indexPath)) {
-        const index = JSON.parse(fs27.readFileSync(indexPath, "utf-8"));
+      if (fs28.existsSync(indexPath)) {
+        const index = JSON.parse(fs28.readFileSync(indexPath, "utf-8"));
         const entries2 = Object.values(index);
         if (entries2.length > 0) {
           const fileVal = entries2[0].file || "";
-          sessionFileUUID = path29.isAbsolute(fileVal) ? path29.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
+          sessionFileUUID = path30.isAbsolute(fileVal) ? path30.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
         }
       }
       if (!sessionFileUUID) {
-        const jsonlFiles = fs27.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs27.statSync(path29.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+        const jsonlFiles = fs28.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs28.statSync(path30.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 = path29.join(sessionsDir, `${sessionFileUUID}.jsonl`);
-      if (!fs27.existsSync(jsonlPath)) {
-        const jsonlFiles = fs27.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs27.statSync(path29.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+      let jsonlPath = path30.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+      if (!fs28.existsSync(jsonlPath)) {
+        const jsonlFiles = fs28.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs28.statSync(path30.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 = path29.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+        jsonlPath = path30.join(sessionsDir, `${sessionFileUUID}.jsonl`);
       }
       console.log(`   file:   ${jsonlPath}`);
-      const configName = path29.basename(configPath2);
+      const configName = path30.basename(configPath2);
       if (autoRestart) {
         try {
           const myPid = process.pid;
@@ -22029,10 +22325,10 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         }
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const { readFileSync: readFileSync29, writeFileSync: writeFileSync20, renameSync: renameSync4 } = fs27;
+      const { readFileSync: readFileSync29, writeFileSync: writeFileSync20, renameSync: renameSync5 } = fs28;
       if (mode === "archive") {
         const archiveName = `${sessionFileUUID}.jsonl.archived.${timestamp}`;
-        renameSync4(jsonlPath, path29.join(sessionsDir, archiveName));
+        renameSync5(jsonlPath, path30.join(sessionsDir, archiveName));
         console.log(`
 \u2705 \u5F52\u6863\u5B8C\u6210: ${archiveName}`);
         console.log(`   \u91CD\u542F\u540E\u5C06\u4ECE\u7A7A\u767D\u4F1A\u8BDD\u5F00\u59CB`);
@@ -22107,12 +22403,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 = fs27.realpathSync(process.argv[1]);
-        const cliDir = path29.dirname(realCliPath);
-        const pkgRoot = path29.resolve(cliDir, "..");
-        let enginePath = path29.join(pkgRoot, "dist", "main.mjs");
-        if (!fs27.existsSync(enginePath)) {
-          enginePath = path29.join(cliDir, "main.mjs");
+        const realCliPath = fs28.realpathSync(process.argv[1]);
+        const cliDir = path30.dirname(realCliPath);
+        const pkgRoot = path30.resolve(cliDir, "..");
+        let enginePath = path30.join(pkgRoot, "dist", "main.mjs");
+        if (!fs28.existsSync(enginePath)) {
+          enginePath = path30.join(cliDir, "main.mjs");
         }
         console.log(`
 \u{1F680} \u62C9\u8D77 engine...`);
@@ -22155,18 +22451,18 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
       else if (args[i] === "--cwd" && args[i + 1]) cwd = args[++i];
     }
     if (!configPath2) {
-      const defaultCfg = path29.join(cwd, "configs", "main7.json");
-      const homeCfg = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs27.existsSync(defaultCfg)) {
+      const defaultCfg = path30.join(cwd, "configs", "main7.json");
+      const homeCfg = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs28.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs27.existsSync(homeCfg)) {
+      } else if (fs28.existsSync(homeCfg)) {
         configPath2 = homeCfg;
-        cwd = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+        cwd = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path29.join(ptr.stateDir, "configs", "main7.json");
-          if (fs27.existsSync(ptrCfg)) {
+          const ptrCfg = path30.join(ptr.stateDir, "configs", "main7.json");
+          if (fs28.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             cwd = ptr.stateDir;
           }
@@ -22185,14 +22481,14 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
       if (process.platform === "win32") {
         const taskName = "Engine7";
         const nodeExe = process.execPath;
-        const cliMjs = path29.resolve(engine7Bin);
-        const absConfig = path29.resolve(configPath2);
-        const wrapperPath = path29.join(cwd, "engine7-start.cmd");
+        const cliMjs = path30.resolve(engine7Bin);
+        const absConfig = path30.resolve(configPath2);
+        const wrapperPath = path30.join(cwd, "engine7-start.cmd");
         const wrapperContent = `@echo off\r
 cd /d "${cwd}"\r
 "${nodeExe}" "${cliMjs}" start --config "${absConfig}"\r
 `;
-        fs27.writeFileSync(wrapperPath, wrapperContent);
+        fs28.writeFileSync(wrapperPath, wrapperContent);
         try {
           execSync3(`schtasks /create /tn "${taskName}" /tr "${wrapperPath}" /sc onlogon /rl highest /f`, { stdio: "inherit", shell: true });
           console.log(`\u2705 Windows \u8BA1\u5212\u4EFB\u52A1 "${taskName}" \u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
@@ -22203,11 +22499,11 @@ cd /d "${cwd}"\r
         }
       } else if (process.platform === "darwin") {
         const label = "com.engine7.agent";
-        const plistDir = path29.join(process.env.HOME, "Library", "LaunchAgents");
-        fs27.mkdirSync(plistDir, { recursive: true });
-        const plistPath = path29.join(plistDir, `${label}.plist`);
-        const localCli = path29.join("node_modules", "engine7", "dist", "cli.mjs");
-        const cliMjs = fs27.existsSync(localCli) ? path29.resolve(localCli) : path29.join(path29.dirname(path29.dirname(engine7Bin)), "lib", "node_modules", "engine7", "dist", "cli.mjs");
+        const plistDir = path30.join(process.env.HOME, "Library", "LaunchAgents");
+        fs28.mkdirSync(plistDir, { recursive: true });
+        const plistPath = path30.join(plistDir, `${label}.plist`);
+        const localCli = path30.join("node_modules", "engine7", "dist", "cli.mjs");
+        const cliMjs = fs28.existsSync(localCli) ? path30.resolve(localCli) : path30.join(path30.dirname(path30.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">
@@ -22219,14 +22515,14 @@ cd /d "${cwd}"\r
     <string>${cliMjs}</string>
     <string>start</string>
     <string>--config</string>
-    <string>${path29.resolve(configPath2)}</string>
+    <string>${path30.resolve(configPath2)}</string>
   </array>
   <key>WorkingDirectory</key><string>${cwd}</string>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
 </dict>
 </plist>`;
-        fs27.writeFileSync(plistPath, plist);
+        fs28.writeFileSync(plistPath, plist);
         try {
           execSync3(`launchctl load "${plistPath}"`, { stdio: "inherit" });
           console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
@@ -22237,9 +22533,9 @@ cd /d "${cwd}"\r
         }
       } else {
         const svcName = "engine7";
-        const svcDir = path29.join(process.env.HOME, ".config", "systemd", "user");
-        fs27.mkdirSync(svcDir, { recursive: true });
-        const svcPath = path29.join(svcDir, `${svcName}.service`);
+        const svcDir = path30.join(process.env.HOME, ".config", "systemd", "user");
+        fs28.mkdirSync(svcDir, { recursive: true });
+        const svcPath = path30.join(svcDir, `${svcName}.service`);
         const svc = `[Unit]
 Description=Engine 7 Agent
 After=network.target
@@ -22247,13 +22543,13 @@ After=network.target
 [Service]
 Type=simple
 WorkingDirectory=${cwd}
-ExecStart=${process.execPath} ${engine7Bin} start --config ${path29.resolve(configPath2)}
+ExecStart=${process.execPath} ${engine7Bin} start --config ${path30.resolve(configPath2)}
 Restart=on-failure
 RestartSec=10
 
 [Install]
 WantedBy=default.target`;
-        fs27.writeFileSync(svcPath, svc);
+        fs28.writeFileSync(svcPath, svc);
         try {
           execSync3(`systemctl --user daemon-reload`, { stdio: "inherit" });
           execSync3(`systemctl --user enable ${svcName}`, { stdio: "inherit" });
@@ -22274,13 +22570,13 @@ WantedBy=default.target`;
           process.exit(1);
         }
       } else if (process.platform === "darwin") {
-        const plistPath = path29.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        const plistPath = path30.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
         try {
           execSync3(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
         } catch {
         }
         try {
-          fs27.unlinkSync(plistPath);
+          fs28.unlinkSync(plistPath);
         } catch {
         }
         console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u5220\u9664`);
@@ -22289,9 +22585,9 @@ WantedBy=default.target`;
           execSync3(`systemctl --user disable engine7`, { stdio: "inherit" });
         } catch {
         }
-        const svcPath = path29.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
+        const svcPath = path30.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
         try {
-          fs27.unlinkSync(svcPath);
+          fs28.unlinkSync(svcPath);
         } catch {
         }
         try {
@@ -22308,8 +22604,8 @@ WantedBy=default.target`;
           console.log("\u274C \u672A\u5B89\u88C5");
         }
       } else if (process.platform === "darwin") {
-        const plistPath = path29.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
-        if (fs27.existsSync(plistPath)) {
+        const plistPath = path30.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        if (fs28.existsSync(plistPath)) {
           console.log("\u2705 \u5DF2\u5B89\u88C5\uFF08launchd\uFF09");
         } else {
           console.log("\u274C \u672A\u5B89\u88C5");
@@ -22332,16 +22628,16 @@ WantedBy=default.target`;
   console.log(`
 \u{1F680} engine7 init`);
   console.log(`   state-dir: ${opts.stateDir}`);
-  if (fs27.existsSync(opts.stateDir) && !opts.dryRun) {
-    const files = fs27.readdirSync(opts.stateDir);
+  if (fs28.existsSync(opts.stateDir) && !opts.dryRun) {
+    const files = fs28.readdirSync(opts.stateDir);
     if (files.length > 0) {
       if (opts.force) {
         console.log(`
 \u26A0\uFE0F --force: \u6E05\u7A7A\u5DF2\u6709\u76EE\u5F55 ${opts.stateDir}`);
-        fs27.rmSync(opts.stateDir, { recursive: true, force: true });
+        fs28.rmSync(opts.stateDir, { recursive: true, force: true });
       } else {
-        const existingConfig = path29.join(opts.stateDir, "configs", "main7.json");
-        if (fs27.existsSync(existingConfig)) {
+        const existingConfig = path30.join(opts.stateDir, "configs", "main7.json");
+        if (fs28.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`);
@@ -22365,7 +22661,7 @@ WantedBy=default.target`;
     rl.close();
   }
   const config = generateConfig(values);
-  const configPath = path29.join(opts.stateDir, "configs", "main7.json");
+  const configPath = path30.join(opts.stateDir, "configs", "main7.json");
   const tree = buildDirTree(values);
   tree.push({
     path: configPath,
@@ -22376,9 +22672,9 @@ WantedBy=default.target`;
     dryRun(tree);
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skills = fs27.readdirSync(skillsSrc);
+      const skills = fs28.readdirSync(skillsSrc);
       for (const s of skills) {
-        console.log(`  \u{1F4C1} ${path29.join(opts.stateDir, "workspace", "skills", s)}`);
+        console.log(`  \u{1F4C1} ${path30.join(opts.stateDir, "workspace", "skills", s)}`);
       }
     }
   } else {
@@ -22386,16 +22682,16 @@ WantedBy=default.target`;
     execute(tree);
     if (values.primaryApiKey && values.primaryApiKey.trim()) {
       const envName = values.primaryProvider.toUpperCase().replace(/[^A-Z0-9_]/g, "_") + "_API_KEY";
-      const secretsDir = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
-      if (!fs27.existsSync(secretsDir)) fs27.mkdirSync(secretsDir, { recursive: true });
-      const envFile = path29.join(secretsDir, "main7.env");
+      const secretsDir = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
+      if (!fs28.existsSync(secretsDir)) fs28.mkdirSync(secretsDir, { recursive: true });
+      const envFile = path30.join(secretsDir, "main7.env");
       let envContent = "";
-      if (fs27.existsSync(envFile)) envContent = fs27.readFileSync(envFile, "utf8");
+      if (fs28.existsSync(envFile)) envContent = fs28.readFileSync(envFile, "utf8");
       const lines = envContent.split("\n").filter((l) => l && !l.startsWith(envName + "="));
       lines.push(envName + "=" + values.primaryApiKey.trim());
-      fs27.writeFileSync(envFile, lines.join("\n") + "\n", "utf8");
+      fs28.writeFileSync(envFile, lines.join("\n") + "\n", "utf8");
       try {
-        fs27.chmodSync(envFile, 384);
+        fs28.chmodSync(envFile, 384);
       } catch {
       }
       console.log("\u{1F511} API key \u5DF2\u5B58\u5165: " + envFile);
@@ -22403,55 +22699,55 @@ WantedBy=default.target`;
     }
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skillsDest = path29.join(opts.stateDir, "workspace", "skills");
-      fs27.mkdirSync(skillsDest, { recursive: true });
-      const skills = fs27.readdirSync(skillsSrc);
+      const skillsDest = path30.join(opts.stateDir, "workspace", "skills");
+      fs28.mkdirSync(skillsDest, { recursive: true });
+      const skills = fs28.readdirSync(skillsSrc);
       for (const s of skills) {
-        copyDirRecursive(path29.join(skillsSrc, s), path29.join(skillsDest, s));
+        copyDirRecursive(path30.join(skillsSrc, s), path30.join(skillsDest, s));
         console.log(`  \u{1F4E6} skill: ${s}`);
       }
     }
     console.log(`
 \u2705 \u521D\u59CB\u5316\u5B8C\u6210\uFF01
 `);
-    const homePointer = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+    const homePointer = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
     const pointerData = { stateDir: opts.stateDir };
-    fs27.writeFileSync(homePointer, JSON.stringify(pointerData, null, 2) + "\n");
+    fs28.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: ${path29.join(opts.stateDir, "workspace")}`);
+    console.log(`  4. \u67E5\u770B workspace: ${path30.join(opts.stateDir, "workspace")}`);
   }
 }
 function copyDirRecursive(src, dest) {
-  fs27.mkdirSync(dest, { recursive: true });
-  for (const entry of fs27.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path29.join(src, entry.name);
-    const destPath = path29.join(dest, entry.name);
+  fs28.mkdirSync(dest, { recursive: true });
+  for (const entry of fs28.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path30.join(src, entry.name);
+    const destPath = path30.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs27.copyFileSync(srcPath, destPath);
+      fs28.copyFileSync(srcPath, destPath);
     }
   }
 }
 function findTemplateDir(name) {
   const candidates = [
-    path29.join(__dirname, "..", "templates", name),
-    path29.join(__dirname, "..", "..", "templates", name),
-    path29.join(process.cwd(), "templates", name)
+    path30.join(__dirname, "..", "templates", name),
+    path30.join(__dirname, "..", "..", "templates", name),
+    path30.join(process.cwd(), "templates", name)
   ];
   for (const p of candidates) {
-    if (fs27.existsSync(p)) return p;
+    if (fs28.existsSync(p)) return p;
   }
   return null;
 }
 function readHomePointer() {
-  const ptrPath = path29.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+  const ptrPath = path30.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
   try {
-    return JSON.parse(fs27.readFileSync(ptrPath, "utf-8"));
+    return JSON.parse(fs28.readFileSync(ptrPath, "utf-8"));
   } catch {
     return null;
   }
@@ -22462,4 +22758,3 @@ main().catch((err) => {
   console.error(err.stack);
   process.exit(1);
 });
-//# sourceMappingURL=cli.mjs.map