engine7 7.1.35 → 7.1.36

package/dist/engine-startup.mjs

@@ -174,17 +174,19 @@ var init_types = __esm({
   "src/messages/types.ts"() {
     "use strict";
     msg = {
-      system: (content) => ({ role: "system", content }),
-      user: (content) => ({ role: "user", content }),
+      system: (content) => ({ role: "system", content, timestamp: (/* @__PURE__ */ new Date()).toISOString() }),
+      user: (content) => ({ role: "user", content, timestamp: (/* @__PURE__ */ new Date()).toISOString() }),
       assistant: (content, tool_calls) => ({
         role: "assistant",
         content,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         ...tool_calls ? { tool_calls } : {}
       }),
       tool: (tool_call_id, content, isError) => ({
         role: "tool",
         tool_call_id,
         content,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         ...isError ? { is_error: true } : {}
       })
     };
@@ -2139,9 +2141,9 @@ function isAutoMemPath(absolutePath, workspace) {
   return normalizedPath.startsWith(getAutoMemPath(workspace));
 }
 async function ensureMemoryDirExists(memoryDir) {
-  const fs42 = await import("node:fs");
+  const fs43 = await import("node:fs");
   try {
-    await fs42.promises.mkdir(memoryDir, { recursive: true });
+    await fs43.promises.mkdir(memoryDir, { recursive: true });
   } catch (e) {
     const code = e?.code;
     if (code !== "EEXIST") {
@@ -3343,6 +3345,41 @@ var init_live = __esm({
         }
         Object.assign(this.current, newConfig);
       }
+      /** 改活树上的值；文件承载路径同步持久化（read-modify-write 回 config 文件） */
+      async set(dotPath, val) {
+        if (!this.current) throw new Error("[liveConfig] not initialized \u2014 call liveConfig.init() first");
+        const keys = dotPath.split(".");
+        let obj = this.current;
+        for (let i = 0; i < keys.length - 1; i++) {
+          if (obj[keys[i]] == null) obj[keys[i]] = {};
+          obj = obj[keys[i]];
+        }
+        obj[keys[keys.length - 1]] = val;
+        await this.persistToFile(dotPath, val);
+      }
+      /** 把改动写回 config 文件对应段（找不到文件路径则只内存生效） */
+      async persistToFile(dotPath, val) {
+        const fs43 = await import("node:fs");
+        const cfgPath = this.current?._configFilePath;
+        if (!cfgPath || !fs43.existsSync(cfgPath)) {
+          console.warn(`[liveConfig] set: no config file path, in-memory only (${dotPath})`);
+          return;
+        }
+        try {
+          const raw = JSON.parse(fs43.readFileSync(cfgPath, "utf-8"));
+          const keys = dotPath.split(".");
+          let o = raw;
+          for (let i = 0; i < keys.length - 1; i++) {
+            if (o[keys[i]] == null) o[keys[i]] = {};
+            o = o[keys[i]];
+          }
+          o[keys[keys.length - 1]] = val;
+          fs43.writeFileSync(cfgPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+          console.log(`[liveConfig] persisted ${dotPath} = ${JSON.stringify(val)} to ${cfgPath}`);
+        } catch (e) {
+          console.warn(`[liveConfig] persist failed (${dotPath}): ${e.message}`);
+        }
+      }
       /** 是否已初始化 */
       isReady() {
         return this.current !== null;
@@ -3352,6 +3389,40 @@ var init_live = __esm({
   }
 });
 
+// src/config/features.ts
+function getFeature(key) {
+  const v = liveConfig.get(`agents.defaults.features.${key}`);
+  return v === void 0 ? FEATURE_DEFAULTS[key] : v;
+}
+var FEATURE_DEFAULTS;
+var init_features = __esm({
+  "src/config/features.ts"() {
+    "use strict";
+    init_live();
+    FEATURE_DEFAULTS = {
+      filesystem: true,
+      shell: true,
+      memory: true,
+      "topic-extract": true,
+      "topic-recall": true,
+      "session-memory": true,
+      todo: true,
+      cron: false,
+      voice: false,
+      selfie: false,
+      eyes: false,
+      calendar: false,
+      webSearch: true,
+      webFetch: true,
+      agentTeams: true,
+      autoDream: true,
+      processOutput: "verbose",
+      interrupt: "command",
+      debounceMs: 5e3
+    };
+  }
+});
+
 // src/utils/path.ts
 var path_exports = {};
 __export(path_exports, {
@@ -4400,7 +4471,7 @@ async function acquireLock(inboxPath) {
   for (let i = 0; i < LOCK_RETRIES; i++) {
     if (await isLockStale(lockPath2)) {
       try {
-        await import("node:fs/promises").then((fs42) => fs42.rm(lockPath2, { force: true }));
+        await import("node:fs/promises").then((fs43) => fs43.rm(lockPath2, { force: true }));
       } catch {
       }
     }
@@ -4408,7 +4479,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((fs42) => fs42.rm(lockPath2, { force: true }));
+          await import("node:fs/promises").then((fs43) => fs43.rm(lockPath2, { force: true }));
         } catch {
         }
       };
@@ -4827,76 +4898,6 @@ var init_extractPrompts = __esm({
   }
 });
 
-// src/memory/everos/ingest.ts
-function parseMeta(text) {
-  const m = text.match(/^\[meta:\s*(.+?)\s*\((.+?)\)\s*@(\S+)\s*[^\]]*\]/);
-  if (!m) return null;
-  return { senderName: m[1].trim() };
-}
-async function readConfig() {
-  const defaults = {
-    url: "http://127.0.0.1:8100",
-    appId: "default",
-    agentName: "assistant",
-    enabled: false
-  };
-  try {
-    const { liveConfig: liveConfig2 } = await Promise.resolve().then(() => (init_live(), live_exports));
-    const cfg = liveConfig2.all()?.everos;
-    if (!cfg) return defaults;
-    return {
-      url: cfg.everosUrl || defaults.url,
-      appId: cfg.userId || defaults.appId,
-      agentName: cfg.agentName || cfg.userId || defaults.agentName,
-      enabled: cfg.enabled === true
-    };
-  } catch {
-    return defaults;
-  }
-}
-async function pushConversation(messages, sessionId) {
-  const cfg = await readConfig();
-  if (!cfg.enabled) return;
-  if (!messages.length) return;
-  const payload = {
-    session_id: `extract-${sessionId}`,
-    app_id: cfg.appId,
-    project_id: "default",
-    messages: messages.map((m) => {
-      const text = typeof m.content === "string" ? m.content : "[content blocks]";
-      const meta = m.role === "user" ? parseMeta(text) : null;
-      const senderName = meta?.senderName ?? (m.role === "assistant" ? cfg.agentName : void 0) ?? m.role;
-      return {
-        sender_id: cfg.appId,
-        sender_name: senderName,
-        role: m.role === "toolResult" ? "tool" : m.role,
-        timestamp: Date.now(),
-        content: text
-      };
-    })
-  };
-  console.log(`[everos-ingest] pushing ${payload.messages.length} messages to ${cfg.url} (appId=${cfg.appId})`);
-  try {
-    const resp = await fetch(`${cfg.url}/api/v1/memory/add`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload),
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (resp.ok) {
-      console.log(`[everos-ingest] \u2705 pushed ${payload.messages.length} messages`);
-    } else {
-      console.warn(`[everos-ingest] memory/add ${resp.status}`);
-    }
-  } catch {
-  }
-}
-var init_ingest = __esm({
-  "src/memory/everos/ingest.ts"() {
-    "use strict";
-  }
-});
-
 // src/memory/memdir/extractMemories.ts
 var extractMemories_exports = {};
 __export(extractMemories_exports, {
@@ -4907,17 +4908,18 @@ import * as path12 from "path";
 function isModelVisibleMessage(message) {
   return message.role === "user" || message.role === "assistant";
 }
-function countModelVisibleMessagesSince(messages, sinceIndex) {
-  if (sinceIndex === void 0) {
-    return messages.filter(isModelVisibleMessage).length;
-  }
-  let n = 0;
-  for (let i = sinceIndex + 1; i < messages.length; i++) {
-    if (isModelVisibleMessage(messages[i])) {
-      n++;
-    }
+function filterNewMessagesByTs(messages, lastTs) {
+  const newMessages = [];
+  let maxNewTs = lastTs ?? 0;
+  for (const m of messages) {
+    if (!isModelVisibleMessage(m)) continue;
+    const ts = m.timestamp;
+    const tsMs = ts ? new Date(ts).getTime() : NaN;
+    if (lastTs !== void 0 && !Number.isNaN(tsMs) && tsMs <= lastTs) continue;
+    if (!Number.isNaN(tsMs)) maxNewTs = Math.max(maxNewTs, tsMs);
+    newMessages.push(m);
   }
-  return n;
+  return { newMessages, maxNewTs };
 }
 function getMemoryTools() {
   const MEMORY_TOOL_NAMES = ["write", "read", "edit", "glob", "grep"];
@@ -4932,13 +4934,13 @@ function loadPersistedState(workspace) {
     const p = getStatePath(workspace);
     if (fs12.existsSync(p)) {
       const data = JSON.parse(fs12.readFileSync(p, "utf-8"));
-      for (const [sid, idx] of Object.entries(data.indices ?? {})) {
-        lastIndexMap.set(sid, idx);
+      for (const [sid, ts] of Object.entries(data.lastTs ?? {})) {
+        lastTsMap.set(sid, ts);
       }
       for (const [sid, ts] of Object.entries(data.timestamps ?? {})) {
         lastExtractTimeMap.set(sid, ts);
       }
-      console.log(`[memory] loaded extract state for ${Object.keys(data.indices ?? {}).length} session(s) from ${STATE_FILE}`);
+      console.log(`[memory] loaded extract state for ${Object.keys(data.lastTs ?? {}).length} session(s) from ${STATE_FILE}`);
     }
   } catch (e) {
     console.warn(`[memory] failed to load extract state: ${e?.message ?? e}`);
@@ -4946,11 +4948,11 @@ function loadPersistedState(workspace) {
 }
 function persistState(workspace) {
   try {
-    const indices = {};
+    const lastTs = {};
     const timestamps = {};
-    for (const [sid, idx] of lastIndexMap.entries()) indices[sid] = idx;
+    for (const [sid, ts] of lastTsMap.entries()) lastTs[sid] = ts;
     for (const [sid, ts] of lastExtractTimeMap.entries()) timestamps[sid] = ts;
-    const data = JSON.stringify({ indices, timestamps }, null, 2);
+    const data = JSON.stringify({ lastTs, timestamps }, null, 2);
     fs12.writeFileSync(getStatePath(workspace), data, "utf-8");
   } catch (e) {
     console.warn(`[memory] failed to persist extract state: ${e?.message ?? e}`);
@@ -4961,7 +4963,7 @@ function createMemoryExtractor(workspace, enabled) {
   loadPersistedState(workspace);
   return {
     reset(sessionId) {
-      lastIndexMap.delete(sessionId);
+      lastTsMap.delete(sessionId);
       lastExtractTimeMap.delete(sessionId);
       persistState(workspace);
       inProgress = false;
@@ -4977,13 +4979,12 @@ function createMemoryExtractor(workspace, enabled) {
           return;
         }
       }
-      const lastProcessedIndex = lastIndexMap.get(sessionId);
-      const memoryDir = getAutoMemPath(workspace);
-      const newMessageCount = countModelVisibleMessagesSince(
-        messages,
-        lastProcessedIndex
-      );
+      const lastTs = lastTsMap.get(sessionId);
+      const { newMessages, maxNewTs } = filterNewMessagesByTs(messages, lastTs);
+      const newMessageCount = newMessages.length;
+      console.log(`[memory] extract ts-watermark: session=${sessionId.slice(0, 8)} lastTs=${lastTs ? new Date(lastTs).toISOString().slice(11, 19) : "\u2205(\u9996\u6B21)"} new=${newMessageCount}/${messages.length}`);
       if (newMessageCount === 0) return;
+      const memoryDir = getAutoMemPath(workspace);
       inProgress = true;
       const startTime = Date.now();
       try {
@@ -5022,8 +5023,7 @@ Check this list before writing \u2014 update an existing file rather than creati
             false
           );
         }
-        const visibleMessages = messages.filter(isModelVisibleMessage);
-        const recentMessages2 = visibleMessages.slice(-newMessageCount);
+        const recentMessages2 = newMessages;
         const conversationText = recentMessages2.map((m) => `[${m.role}]: ${(typeof m.content === "string" ? m.content : "[content blocks]").slice(0, 500)}`).join("\n\n");
         const extractMessages = [
           {
@@ -5060,11 +5060,9 @@ ${conversationText}`
             toolCount++;
           }
         }
-        lastIndexMap.set(sessionId, messages.length - 1);
+        lastTsMap.set(sessionId, Math.max(maxNewTs, Date.now()));
         lastExtractTimeMap.set(sessionId, Date.now());
         persistState(workspace);
-        pushConversation(recentMessages2, sessionId).catch(() => {
-        });
         const duration = Date.now() - startTime;
         console.log(
           `[memory] extractMemories finished in ${duration}ms \u2014 ${toolCount} tools used, ${result.length} chars`
@@ -5079,7 +5077,7 @@ ${conversationText}`
     }
   };
 }
-var lastIndexMap, lastExtractTimeMap, STATE_FILE;
+var lastTsMap, lastExtractTimeMap, STATE_FILE;
 var init_extractMemories = __esm({
   "src/memory/memdir/extractMemories.ts"() {
     "use strict";
@@ -5088,13 +5086,207 @@ var init_extractMemories = __esm({
     init_paths();
     init_memoryScan();
     init_extractPrompts();
-    init_ingest();
-    lastIndexMap = /* @__PURE__ */ new Map();
+    lastTsMap = /* @__PURE__ */ new Map();
     lastExtractTimeMap = /* @__PURE__ */ new Map();
     STATE_FILE = ".extract-state.json";
   }
 });
 
+// src/memory/everos/ingest.ts
+var ingest_exports = {};
+__export(ingest_exports, {
+  pushConversation: () => pushConversation
+});
+import fs13 from "node:fs";
+import path13 from "node:path";
+function parseMeta(text) {
+  const m = text.match(/^\[meta:\s*(.+?)\s*\((.+?)\)\s*@(\S+)\s*[^\]]*\]/);
+  if (!m) return null;
+  return { senderName: m[1].trim() };
+}
+async function readConfig() {
+  const defaults = {
+    url: "http://127.0.0.1:8100",
+    appId: "default",
+    agentName: "assistant",
+    enabled: false,
+    ingestTimeoutMs: 3e4,
+    syncIntervalMs: 9e5
+  };
+  try {
+    const { liveConfig: liveConfig2 } = await Promise.resolve().then(() => (init_live(), live_exports));
+    const cfg = liveConfig2.all()?.everos;
+    if (!cfg) return defaults;
+    return {
+      url: cfg.everosUrl || defaults.url,
+      appId: cfg.userId || defaults.appId,
+      agentName: cfg.agentName || cfg.userId || defaults.agentName,
+      enabled: cfg.enabled === true,
+      ingestTimeoutMs: typeof cfg.ingestTimeoutMs === "number" ? cfg.ingestTimeoutMs : defaults.ingestTimeoutMs,
+      syncIntervalMs: typeof cfg.syncIntervalMs === "number" ? cfg.syncIntervalMs : defaults.syncIntervalMs
+    };
+  } catch {
+    return defaults;
+  }
+}
+function loadPushTs(workspace, sessionId) {
+  try {
+    const p = path13.join(workspace, PUSH_STATE_FILE);
+    if (fs13.existsSync(p)) {
+      const data = JSON.parse(fs13.readFileSync(p, "utf-8"));
+      return typeof data[sessionId] === "number" ? data[sessionId] : 0;
+    }
+  } catch (e) {
+    console.warn(`[everos-ingest] load pushTs failed: ${e?.message ?? e}`);
+  }
+  return 0;
+}
+function savePushTs(workspace, sessionId, ts) {
+  try {
+    const p = path13.join(workspace, PUSH_STATE_FILE);
+    let data = {};
+    try {
+      if (fs13.existsSync(p)) data = JSON.parse(fs13.readFileSync(p, "utf-8"));
+    } catch {
+    }
+    data[sessionId] = ts;
+    fs13.writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
+  } catch (e) {
+    console.warn(`[everos-ingest] save pushTs failed: ${e?.message ?? e}`);
+  }
+}
+function buildPayload(messages, cfg, sessionId) {
+  return {
+    session_id: `extract-${sessionId}`,
+    app_id: cfg.appId,
+    project_id: "default",
+    messages: messages.map((m) => {
+      const text = typeof m.content === "string" ? m.content : "[content blocks]";
+      const meta = m.role === "user" ? parseMeta(text) : null;
+      const senderName = meta?.senderName ?? (m.role === "assistant" ? cfg.agentName : void 0) ?? m.role;
+      const rawRole = m.role === "toolResult" ? "tool" : m.role;
+      const validRoles = ["user", "assistant", "tool"];
+      return {
+        sender_id: cfg.appId,
+        sender_name: senderName,
+        role: validRoles.includes(rawRole) ? rawRole : "user",
+        timestamp: Date.now(),
+        content: text
+      };
+    })
+  };
+}
+async function fetchWithTimeout(url, options, timeoutMs) {
+  const controller = new AbortController();
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      try {
+        controller.abort();
+      } catch {
+      }
+      reject(new Error(`fetch timeout ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      fetch(url, { ...options, signal: controller.signal }),
+      timeoutPromise
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function pushConversation(messages, sessionId, workspace) {
+  const cfg = await readConfig();
+  if (!cfg.enabled) return;
+  if (!messages.length) return;
+  if (Date.now() - lastPushAt < cfg.syncIntervalMs) return;
+  if (pushInProgress) {
+    console.log("[everos-ingest] previous push still running, skip (pushTs \u4F1A\u7EED\u63A8\uFF0C\u4E0D\u4E22)");
+    return;
+  }
+  lastPushAt = Date.now();
+  pushInProgress = true;
+  try {
+    if (!workspace) {
+      const payload = buildPayload(messages, cfg, sessionId);
+      console.log(`[everos-ingest] pushing ${payload.messages.length} messages to ${cfg.url} (no pushTs, one-shot, timeout=${cfg.ingestTimeoutMs}ms)`);
+      try {
+        const resp = await fetchWithTimeout(`${cfg.url}/api/v1/memory/add`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload)
+        }, cfg.ingestTimeoutMs);
+        if (resp.ok) console.log(`[everos-ingest] \u2705 pushed ${payload.messages.length} messages`);
+        else console.warn(`[everos-ingest] memory/add ${resp.status}`);
+      } catch (e) {
+        console.warn(`[everos-ingest] push failed (${e?.name || "error"}: ${e?.message || "unknown"})`);
+      }
+      return;
+    }
+    const pushTs = loadPushTs(workspace, sessionId);
+    const toPush = [];
+    let maxTs = pushTs;
+    for (const m of messages) {
+      const ms = m.timestamp ? new Date(m.timestamp).getTime() : NaN;
+      if (Number.isNaN(ms)) {
+        toPush.push(m);
+        continue;
+      }
+      if (ms <= pushTs) continue;
+      toPush.push(m);
+      if (ms > maxTs) maxTs = ms;
+    }
+    if (toPush.length === 0) return;
+    const total = toPush.length;
+    const chunkTotal = Math.ceil(total / PUSH_CHUNK);
+    let pushed = 0;
+    for (let i = 0; i < total; i += PUSH_CHUNK) {
+      const chunk = toPush.slice(i, i + PUSH_CHUNK);
+      const chunkMaxTs = chunk.reduce((mx, m) => {
+        const ms = m.timestamp ? new Date(m.timestamp).getTime() : 0;
+        return Number.isNaN(ms) || ms < mx ? mx : ms;
+      }, pushTs);
+      const chunkNo = Math.floor(i / PUSH_CHUNK) + 1;
+      const payload = buildPayload(chunk, cfg, sessionId);
+      console.log(`[everos-ingest] pushing chunk ${chunkNo}/${chunkTotal} (${chunk.length} msgs) to ${cfg.url} (timeout=${cfg.ingestTimeoutMs}ms)`);
+      try {
+        const resp = await fetchWithTimeout(`${cfg.url}/api/v1/memory/add`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload)
+        }, cfg.ingestTimeoutMs);
+        if (resp.ok) {
+          savePushTs(workspace, sessionId, chunkMaxTs);
+          pushed += chunk.length;
+          console.log(`[everos-ingest] \u2705 pushed chunk ${chunkNo}/${chunkTotal} (${chunk.length} msgs, pushTs\u2192${new Date(chunkMaxTs).toISOString().slice(11, 19)})`);
+        } else {
+          savePushTs(workspace, sessionId, chunkMaxTs);
+          const errBody = await resp.text().catch(() => "?");
+          console.warn(`[everos-ingest] memory/add ${resp.status} on chunk ${chunkNo}, body=${errBody.slice(0, 300)}, skip & advance pushTs\u2192${new Date(chunkMaxTs).toISOString().slice(11, 19)}`);
+        }
+      } catch (e) {
+        savePushTs(workspace, sessionId, chunkMaxTs);
+        console.warn(`[everos-ingest] chunk ${chunkNo} push failed (${e?.name || "error"}: ${e?.message || "unknown"}), skip & advance pushTs\u2192${new Date(chunkMaxTs).toISOString().slice(11, 19)}`);
+      }
+    }
+    console.log(`[everos-ingest] done: ${pushed}/${total} msgs pushed`);
+  } finally {
+    pushInProgress = false;
+  }
+}
+var PUSH_CHUNK, PUSH_STATE_FILE, pushInProgress, lastPushAt;
+var init_ingest = __esm({
+  "src/memory/everos/ingest.ts"() {
+    "use strict";
+    PUSH_CHUNK = 10;
+    PUSH_STATE_FILE = ".everos-push-state.json";
+    pushInProgress = false;
+    lastPushAt = 0;
+  }
+});
+
 // src/memory/sessionMemory/sessionMemoryUtils.ts
 import { join as join17 } from "node:path";
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync13 } from "node:fs";
@@ -5452,7 +5644,7 @@ async function extractSessionMemory(messages, overrideProvider, overrideModel) {
   if (!_deps) return { fired: false, reason: "not initialized" };
   if (isExtractionInProgress()) return { fired: false, reason: "extraction already in progress" };
   const provider = overrideProvider || _deps.provider;
-  const model = overrideModel || _deps.model;
+  const model = overrideModel || liveConfig.get("model") || "";
   markExtractionStarted();
   try {
     const { memoryPath, currentMemory } = await setupSessionMemoryFile();
@@ -5525,7 +5717,7 @@ function getSessionMemoryForCompaction() {
 }
 function isSessionMemoryEnabled() {
   if (!_deps) return false;
-  if (_deps.features && _deps.features["session-memory"] === false) return false;
+  if (getFeature("session-memory") === false) return false;
   return true;
 }
 var _deps, lastMemoryMessageIndex;
@@ -5536,6 +5728,8 @@ var init_sessionMemory = __esm({
     init_prompts();
     init_query();
     init_registry();
+    init_features();
+    init_live();
     _deps = null;
   }
 });
@@ -5551,23 +5745,11 @@ __export(config_exports, {
   isAutoDreamEnabled: () => isAutoDreamEnabled,
   setAutoDreamConfig: () => setAutoDreamConfig
 });
-function dlog(msg2) {
-  if (process.env.AUTODREAM_DEBUG) console.log(`[autoDream] ${msg2}`);
-}
 function setAutoDreamConfig(config) {
   _config = config;
-  const c = config;
-  dlog(`setAutoDreamConfig: keys=${Object.keys(c).join(",")} | config.features.autoDream=${c.features?.autoDream} | config.agents.defaults.features.autoDream=${c.agents?.defaults?.features?.autoDream} | config.topics.autoDream=${c.topics?.autoDream ? JSON.stringify(c.topics.autoDream) : "(none)"}`);
 }
 function isAutoDreamEnabled() {
-  if (!_config) {
-    dlog("isAutoDreamEnabled: _config null");
-    return false;
-  }
-  const features = _config.profile?.features ?? _config.features ?? _config.agents?.defaults?.features;
-  const result = features?.autoDream === true;
-  dlog(`isAutoDreamEnabled: config.features.autoDream=${_config.features?.autoDream} | agents.defaults.features.autoDream=${_config.agents?.defaults?.features?.autoDream} | resolved=${features?.autoDream} | result=${result}`);
-  return result;
+  return getFeature("autoDream") === true;
 }
 function getAutoDreamConfig() {
   const raw = _config?.topics?.autoDream ?? _config?.autoDream;
@@ -5593,6 +5775,7 @@ var _config, DEFAULTS;
 var init_config2 = __esm({
   "src/memory/autoDream/config.ts"() {
     "use strict";
+    init_features();
     _config = null;
     DEFAULTS = {
       minHours: 24,
@@ -5616,11 +5799,11 @@ async function readLastConsolidatedAt(memoryDir) {
   }
 }
 async function tryAcquireConsolidationLock(memoryDir) {
-  const path45 = lockPath(memoryDir);
+  const path46 = lockPath(memoryDir);
   let mtimeMs;
   let holderPid;
   try {
-    const [s, raw] = await Promise.all([stat3(path45), readFile5(path45, "utf8")]);
+    const [s, raw] = await Promise.all([stat3(path46), readFile5(path46, "utf8")]);
     mtimeMs = s.mtimeMs;
     const parsed = parseInt(raw.trim(), 10);
     holderPid = Number.isFinite(parsed) ? parsed : void 0;
@@ -5633,10 +5816,10 @@ async function tryAcquireConsolidationLock(memoryDir) {
     }
   }
   await mkdir3(memoryDir, { recursive: true });
-  await writeFile4(path45, String(process.pid));
+  await writeFile4(path46, String(process.pid));
   let verify2;
   try {
-    verify2 = await readFile5(path45, "utf8");
+    verify2 = await readFile5(path46, "utf8");
   } catch {
     return null;
   }
@@ -5644,15 +5827,15 @@ async function tryAcquireConsolidationLock(memoryDir) {
   return mtimeMs ?? 0;
 }
 async function rollbackConsolidationLock(memoryDir, priorMtime) {
-  const path45 = lockPath(memoryDir);
+  const path46 = lockPath(memoryDir);
   try {
     if (priorMtime === 0) {
-      await unlink(path45);
+      await unlink(path46);
       return;
     }
-    await writeFile4(path45, "");
+    await writeFile4(path46, "");
     const t = priorMtime / 1e3;
-    await utimes(path45, t, t);
+    await utimes(path46, t, t);
   } catch (e) {
     console.log(`[autoDream] rollback failed: ${e.message} \u2014 next trigger delayed to minHours`);
   }
@@ -5783,48 +5966,48 @@ var init_consolidationPrompt = __esm({
 // src/memory/autoDream/autoDream.ts
 var autoDream_exports = {};
 __export(autoDream_exports, {
-  dlog: () => dlog2,
+  dlog: () => dlog,
   executeAutoDream: () => executeAutoDream,
   initAutoDream: () => initAutoDream
 });
-function dlog2(msg2) {
+function dlog(msg2) {
   if (process.env.AUTODREAM_DEBUG) console.log(`[autoDream] ${msg2}`);
 }
 function initAutoDream(deps) {
   _deps2 = deps;
   lastSessionScanAt = 0;
-  dlog2(`initAutoDream: workspace=${deps.workspace} sessionsDir=${deps.sessionsDir} model=${deps.model} provider=${deps.provider?.constructor?.name}`);
+  dlog(`initAutoDream: workspace=${deps.workspace} sessionsDir=${deps.sessionsDir} model=${deps.model} provider=${deps.provider?.constructor?.name}`);
 }
 async function executeAutoDream() {
-  dlog2(`=== executeAutoDream START === _deps=${_deps2 ? "set" : "null"} isAutoDreamEnabled=${isAutoDreamEnabled()}`);
+  dlog(`=== executeAutoDream START === _deps=${_deps2 ? "set" : "null"} isAutoDreamEnabled=${isAutoDreamEnabled()}`);
   if (!_deps2) {
-    dlog2("EXIT: not initialized");
+    dlog("EXIT: not initialized");
     return { fired: false, reason: "not initialized" };
   }
   if (!isAutoDreamEnabled()) {
-    dlog2("EXIT: disabled (features.autoDream not true)");
+    dlog("EXIT: disabled (features.autoDream not true)");
     return { fired: false, reason: "disabled" };
   }
   const cfg = getAutoDreamConfig();
   const { workspace, sessionsDir, provider, model, toolOverride, disableThinking } = _deps2;
   const memoryDir = getAutoMemPath(workspace);
-  dlog2(`cfg: minHours=${cfg.minHours} minSessions=${cfg.minSessions} | memoryDir=${memoryDir} | distillOutput=${getDistillOutput() ?? "(none)"} dailyLogDir=${getDailyLogDir() ?? "(none)"} | sessionsDir=${sessionsDir}`);
+  dlog(`cfg: minHours=${cfg.minHours} minSessions=${cfg.minSessions} | memoryDir=${memoryDir} | distillOutput=${getDistillOutput() ?? "(none)"} dailyLogDir=${getDailyLogDir() ?? "(none)"} | sessionsDir=${sessionsDir}`);
   let lastAt;
   try {
     lastAt = await readLastConsolidatedAt(memoryDir);
   } catch (e) {
-    dlog2(`EXIT: readLastConsolidatedAt failed: ${e.message}`);
+    dlog(`EXIT: readLastConsolidatedAt failed: ${e.message}`);
     return { fired: false, reason: `readLastConsolidatedAt failed: ${e.message}` };
   }
   const hoursSince = (Date.now() - lastAt) / 36e5;
-  dlog2(`time gate: lastAt=${lastAt}(${lastAt === 0 ? "no lock \u2192 \u6C38\u8FDC\u6EE1\u8DB3" : new Date(lastAt).toISOString()}) hoursSince=${hoursSince.toFixed(1)} need>=${cfg.minHours}`);
+  dlog(`time gate: lastAt=${lastAt}(${lastAt === 0 ? "no lock \u2192 \u6C38\u8FDC\u6EE1\u8DB3" : new Date(lastAt).toISOString()}) hoursSince=${hoursSince.toFixed(1)} need>=${cfg.minHours}`);
   if (hoursSince < cfg.minHours) {
-    dlog2("EXIT: time gate not met");
+    dlog("EXIT: time gate not met");
     return { fired: false, reason: `time gate: ${hoursSince.toFixed(1)}h < ${cfg.minHours}h` };
   }
   const sinceScanMs = Date.now() - lastSessionScanAt;
   if (sinceScanMs < SESSION_SCAN_INTERVAL_MS) {
-    dlog2(`EXIT: scan throttle ${Math.round(sinceScanMs / 1e3)}s ago < 10min`);
+    dlog(`EXIT: scan throttle ${Math.round(sinceScanMs / 1e3)}s ago < 10min`);
     return { fired: false, reason: `scan throttle: last scan ${Math.round(sinceScanMs / 1e3)}s ago` };
   }
   lastSessionScanAt = Date.now();
@@ -5832,27 +6015,27 @@ async function executeAutoDream() {
   try {
     sessionIds = await listSessionsTouchedSince(sessionsDir, lastAt);
   } catch (e) {
-    dlog2(`EXIT: listSessionsTouchedSince failed: ${e.message} | sessionsDir=${sessionsDir}`);
+    dlog(`EXIT: listSessionsTouchedSince failed: ${e.message} | sessionsDir=${sessionsDir}`);
     return { fired: false, reason: `listSessionsTouchedSince failed: ${e.message}` };
   }
-  dlog2(`session gate: ${sessionIds.length} sessions touched since lastAt, need>=${cfg.minSessions} | sessionsDir=${sessionsDir}`);
+  dlog(`session gate: ${sessionIds.length} sessions touched since lastAt, need>=${cfg.minSessions} | sessionsDir=${sessionsDir}`);
   if (sessionIds.length < cfg.minSessions) {
-    dlog2("EXIT: session gate not met");
+    dlog("EXIT: session gate not met");
     return { fired: false, reason: `session gate: ${sessionIds.length} < ${cfg.minSessions}` };
   }
   let priorMtime;
   try {
     priorMtime = await tryAcquireConsolidationLock(memoryDir);
   } catch (e) {
-    dlog2(`EXIT: lock acquire failed: ${e.message}`);
+    dlog(`EXIT: lock acquire failed: ${e.message}`);
     return { fired: false, reason: `lock acquire failed: ${e.message}` };
   }
   if (priorMtime === null) {
-    dlog2("EXIT: lock held by another process");
+    dlog("EXIT: lock held by another process");
     return { fired: false, reason: "lock held by another process" };
   }
-  dlog2(`lock acquired: priorMtime=${priorMtime}`);
-  dlog2(`FIRING \u2014 ${hoursSince.toFixed(1)}h since last, ${sessionIds.length} sessions to review`);
+  dlog(`lock acquired: priorMtime=${priorMtime}`);
+  dlog(`FIRING \u2014 ${hoursSince.toFixed(1)}h since last, ${sessionIds.length} sessions to review`);
   console.log(`[autoDream] firing \u2014 ${hoursSince.toFixed(1)}h since last, ${sessionIds.length} sessions to review`);
   try {
     const extra = `
@@ -5860,14 +6043,14 @@ async function executeAutoDream() {
 Sessions since last consolidation (${sessionIds.length}):
 ${sessionIds.map((id) => `- ${id}`).join("\n")}`;
     const prompt = buildConsolidationPrompt(memoryDir, sessionsDir, extra, getDailyLogDir(), getDistillOutput(), getMaxEntrypointLines());
-    dlog2(`prompt built (${prompt.length} chars)`);
+    dlog(`prompt built (${prompt.length} chars)`);
     const { QueryEngine: QueryEngine2 } = await Promise.resolve().then(() => (init_query(), query_exports));
-    dlog2("QueryEngine imported");
+    dlog("QueryEngine imported");
     const { registry: registry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
     const SAFE_TOOL_NAMES = /* @__PURE__ */ new Set(["read", "write", "edit", "grep", "glob"]);
     const safeTools = registry2.definitions().filter((d) => SAFE_TOOL_NAMES.has(d.function.name));
     const memoryTools = toolOverride && toolOverride.length > 0 ? toolOverride : safeTools;
-    dlog2(`tools: memoryTools=${memoryTools.length} (registry total=${registry2.list().length})`);
+    dlog(`tools: memoryTools=${memoryTools.length} (registry total=${registry2.list().length})`);
     const dreamEngine = new QueryEngine2(provider, {
       model,
       systemPrompt: prompt,
@@ -5876,7 +6059,7 @@ ${sessionIds.map((id) => `- ${id}`).join("\n")}`;
       disableThinking: disableThinking ?? true,
       agentLabel: "auto-dream"
     });
-    dlog2("dreamEngine created");
+    dlog("dreamEngine created");
     const messages = [{ role: "user", content: prompt }];
     const toolContext = {
       sessionId: "auto-dream",
@@ -5886,24 +6069,24 @@ ${sessionIds.map((id) => `- ${id}`).join("\n")}`;
     };
     let result = "";
     let turnCount = 0;
-    dlog2("dream query START");
+    dlog("dream query START");
     for await (const chunk of dreamEngine.query(messages, void 0, toolContext)) {
       if (chunk.type === "text") {
         result += chunk.text || "";
       }
       if (chunk.type === "tool_call") {
         turnCount++;
-        dlog2(`dream turn ${turnCount}: tool_call`);
+        dlog(`dream turn ${turnCount}: tool_call`);
       }
     }
-    dlog2(`dream query DONE \u2014 ${turnCount} tool_calls, result=${result.length} chars`);
+    dlog(`dream query DONE \u2014 ${turnCount} tool_calls, result=${result.length} chars`);
     await recordConsolidation(memoryDir);
-    dlog2(`recordConsolidation OK \u2014 wrote .consolidate-lock`);
+    dlog(`recordConsolidation OK \u2014 wrote .consolidate-lock`);
     console.log(`[autoDream] completed \u2014 reviewed ${sessionIds.length} sessions`);
     return { fired: true, summary: result.slice(0, 500) };
   } catch (e) {
     const err = e;
-    dlog2(`CATCH failed: ${err.message}
+    dlog(`CATCH failed: ${err.message}
 stack: ${err.stack ?? "(no stack)"}`);
     console.log(`[autoDream] failed: ${err.message}`);
     await rollbackConsolidationLock(memoryDir, priorMtime);
@@ -5984,30 +6167,30 @@ __export(TodoWriteTool_exports, {
   initTodoStore: () => initTodoStore,
   loadTodos: () => loadTodos
 });
-import fs31 from "node:fs";
-import path32 from "node:path";
+import fs32 from "node:fs";
+import path33 from "node:path";
 function initTodoStore(stateDir) {
-  todosDir = path32.join(stateDir, "todos");
-  if (!fs31.existsSync(todosDir)) {
-    fs31.mkdirSync(todosDir, { recursive: true });
+  todosDir = path33.join(stateDir, "todos");
+  if (!fs32.existsSync(todosDir)) {
+    fs32.mkdirSync(todosDir, { recursive: true });
   }
 }
 function todoFilePath(sessionId) {
-  return path32.join(todosDir, `${sessionId}.json`);
+  return path33.join(todosDir, `${sessionId}.json`);
 }
 function loadTodos(sessionId) {
   if (!todosDir) return [];
   try {
     const filePath = todoFilePath(sessionId);
-    if (!fs31.existsSync(filePath)) return [];
-    return JSON.parse(fs31.readFileSync(filePath, "utf-8"));
+    if (!fs32.existsSync(filePath)) return [];
+    return JSON.parse(fs32.readFileSync(filePath, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveTodos(sessionId, todos) {
   if (!todosDir) return;
-  fs31.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
+  fs32.writeFileSync(todoFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
 }
 var todosDir;
 var init_TodoWriteTool = __esm({
@@ -6088,28 +6271,28 @@ __export(tasks_exports, {
   unassignTeammateTasks: () => unassignTeammateTasks,
   updateTask: () => updateTask
 });
-import * as fs33 from "node:fs";
-import * as path34 from "node:path";
+import * as fs34 from "node:fs";
+import * as path35 from "node:path";
 function sanitizePathComponent2(input) {
   return input.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
 function getTasksDir2(stateDir, listId) {
-  return path34.join(stateDir, "tasks", sanitizePathComponent2(listId));
+  return path35.join(stateDir, "tasks", sanitizePathComponent2(listId));
 }
 function getTaskPath(stateDir, listId, taskId) {
-  return path34.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
+  return path35.join(getTasksDir2(stateDir, listId), `${sanitizePathComponent2(taskId)}.json`);
 }
 function ensureTasksDir2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
-  fs33.mkdirSync(dir, { recursive: true });
+  fs34.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function getHighWaterMarkPath(stateDir, listId) {
-  return path34.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
+  return path35.join(getTasksDir2(stateDir, listId), HIGH_WATER_MARK_FILE);
 }
 function readHighWaterMark(stateDir, listId) {
   try {
-    const content = fs33.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
+    const content = fs34.readFileSync(getHighWaterMarkPath(stateDir, listId), "utf-8").trim();
     const value = parseInt(content, 10);
     return isNaN(value) ? 0 : value;
   } catch {
@@ -6117,13 +6300,13 @@ function readHighWaterMark(stateDir, listId) {
   }
 }
 function writeHighWaterMark(stateDir, listId, value) {
-  fs33.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
+  fs34.writeFileSync(getHighWaterMarkPath(stateDir, listId), String(value));
 }
 function findHighestTaskIdFromFiles(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs33.readdirSync(dir);
+    files = fs34.readdirSync(dir);
   } catch {
     return 0;
   }
@@ -6149,14 +6332,14 @@ function createTask(stateDir, listId, taskData) {
     const id = String(highestId + 1);
     const task = { id, ...taskData };
     const filePath = getTaskPath(stateDir, listId, id);
-    fs33.writeFileSync(filePath, JSON.stringify(task, null, 2));
+    fs34.writeFileSync(filePath, JSON.stringify(task, null, 2));
     return id;
   });
 }
 function getTask2(stateDir, listId, taskId) {
   const filePath = getTaskPath(stateDir, listId, taskId);
   try {
-    const content = fs33.readFileSync(filePath, "utf-8");
+    const content = fs34.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -6166,7 +6349,7 @@ function listTasks2(stateDir, listId) {
   const dir = getTasksDir2(stateDir, listId);
   let files;
   try {
-    files = fs33.readdirSync(dir);
+    files = fs34.readdirSync(dir);
   } catch {
     return [];
   }
@@ -6178,7 +6361,7 @@ function updateTask(stateDir, listId, taskId, updates) {
   if (!existing) return null;
   const updated = { ...existing, ...updates, id: taskId };
   const filePath = getTaskPath(stateDir, listId, taskId);
-  fs33.writeFileSync(filePath, JSON.stringify(updated, null, 2));
+  fs34.writeFileSync(filePath, JSON.stringify(updated, null, 2));
   return updated;
 }
 function deleteTask(stateDir, listId, taskId) {
@@ -6192,7 +6375,7 @@ function deleteTask(stateDir, listId, taskId) {
     }
   }
   try {
-    fs33.unlinkSync(filePath);
+    fs34.unlinkSync(filePath);
   } catch {
     return false;
   }
@@ -6310,15 +6493,15 @@ var read_exports = {};
 __export(read_exports, {
   readFileState: () => readFileState
 });
-import * as fs34 from "node:fs";
-import * as path35 from "node:path";
+import * as fs35 from "node:fs";
+import * as path36 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 = fs34.statSync(filePath);
+  const stat4 = fs35.statSync(filePath);
   const mtimeMs = stat4.mtimeMs;
   const prev = readHistory.get(filePath);
   if (prev && prev.offset === offset && prev.limit === limit && prev.mtimeMs === mtimeMs) {
@@ -6332,19 +6515,19 @@ function checkReadLoop(filePath, offset, limit) {
   return null;
 }
 function readFileContent(filePath) {
-  const fd = fs34.openSync(filePath, "r");
+  const fd = fs35.openSync(filePath, "r");
   const bom = Buffer.alloc(2);
-  fs34.readSync(fd, bom, 0, 2, 0);
-  fs34.closeSync(fd);
+  fs35.readSync(fd, bom, 0, 2, 0);
+  fs35.closeSync(fd);
   let encoding = "utf8";
   if (bom[0] === 255 && bom[1] === 254) {
     encoding = "utf16le";
   }
-  const stat4 = fs34.statSync(filePath);
+  const stat4 = fs35.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 = fs34.readFileSync(filePath, encoding);
+  const raw = fs35.readFileSync(filePath, encoding);
   const content = raw.toString().replaceAll("\r\n", "\n");
   return { content, encoding };
 }
@@ -6486,11 +6669,11 @@ Usage:
         } catch (e) {
           return { content: e.message, isError: true };
         }
-        if (!fs34.existsSync(filePath)) {
+        if (!fs35.existsSync(filePath)) {
           return { content: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, isError: true };
         }
-        const stat4 = fs34.statSync(filePath);
-        const baseName = path35.basename(filePath).toUpperCase();
+        const stat4 = fs35.statSync(filePath);
+        const baseName = path36.basename(filePath).toUpperCase();
         if (BLOCKED_BASENAMES.has(baseName)) {
           return { content: `\u8BBE\u5907\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6: ${filePath}`, isError: true };
         }
@@ -6498,11 +6681,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 entries = fs34.readdirSync(filePath);
+          const entries = fs35.readdirSync(filePath);
           const items = entries.map((e) => {
-            const full = path35.join(filePath, e);
+            const full = path36.join(filePath, e);
             try {
-              const s = fs34.statSync(full);
+              const s = fs35.statSync(full);
               return s.isDirectory() ? `${e}/` : e;
             } catch {
               return e;
@@ -6511,7 +6694,7 @@ Usage:
           return { content: `\u76EE\u5F55 (${entries.length} \u9879):
 ${items.join("\n")}` };
         }
-        const ext = path35.extname(filePath).toLowerCase();
+        const ext = path36.extname(filePath).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext)) {
           return { content: `\u4E8C\u8FDB\u5236\u6587\u4EF6\u4E0D\u652F\u6301\u8BFB\u53D6 (${ext}): ${filePath}`, isError: true };
         }
@@ -6559,22 +6742,22 @@ ${result}` : result };
 
 // src/tools/write.ts
 var write_exports = {};
-import * as fs35 from "node:fs";
-import * as path36 from "node:path";
+import * as fs36 from "node:fs";
+import * as path37 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";
-  fs35.writeFileSync(tmpPath, content, "utf-8");
+  fs36.writeFileSync(tmpPath, content, "utf-8");
   try {
-    fs35.renameSync(tmpPath, filePath);
+    fs36.renameSync(tmpPath, filePath);
   } catch (e) {
     try {
-      fs35.unlinkSync(tmpPath);
+      fs36.unlinkSync(tmpPath);
     } catch {
     }
-    fs35.writeFileSync(filePath, content, "utf-8");
+    fs36.writeFileSync(filePath, content, "utf-8");
   }
 }
 function simpleDiff(oldContent, newContent) {
@@ -6668,15 +6851,15 @@ Usage:
         }
         const rawContent = args.content;
         const content = rawContent.replaceAll("\r\n", "\n");
-        if (fs35.existsSync(filePath) && fs35.statSync(filePath).isDirectory()) {
+        if (fs36.existsSync(filePath) && fs36.statSync(filePath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
         }
         let oldContent = null;
         let isCreate = true;
-        if (fs35.existsSync(filePath)) {
+        if (fs36.existsSync(filePath)) {
           isCreate = false;
           try {
-            oldContent = fs35.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            oldContent = fs36.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
           } catch {
             isCreate = true;
           }
@@ -6692,10 +6875,10 @@ Usage:
               isError: true
             };
           }
-          const currentStat = fs35.statSync(filePath);
+          const currentStat = fs36.statSync(filePath);
           const lastWriteTime = Math.floor(currentStat.mtimeMs);
           if (lastWriteTime > readState.timestamp) {
-            const currentContent = fs35.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n");
+            const currentContent = fs36.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}`,
@@ -6704,9 +6887,9 @@ Usage:
             }
           }
         }
-        const dir = path36.dirname(filePath);
+        const dir = path37.dirname(filePath);
         try {
-          fs35.mkdirSync(dir, { recursive: true });
+          fs36.mkdirSync(dir, { recursive: true });
         } catch (e) {
           return { content: `\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${dir} \u2014 ${e.message}`, isError: true };
         }
@@ -6715,11 +6898,11 @@ Usage:
         } catch (e) {
           return { content: `\u5199\u5165\u5931\u8D25: ${e.message}`, isError: true };
         }
-        readFileState.set(filePath, { timestamp: fs35.statSync(filePath).mtimeMs });
+        readFileState.set(filePath, { timestamp: fs36.statSync(filePath).mtimeMs });
         const action = isCreate ? "\u521B\u5EFA" : "\u66F4\u65B0";
         const lines = content.split("\n").length;
         const chars = content.length;
-        const stat4 = fs35.statSync(filePath);
+        const stat4 = fs36.statSync(filePath);
         let diff = "";
         if (!isCreate && oldContent !== null) {
           diff = `
@@ -6739,8 +6922,8 @@ ${simpleDiff(oldContent, content)}`;
 
 // src/tools/edit.ts
 var edit_exports = {};
-import * as fs36 from "node:fs";
-import * as path37 from "node:path";
+import * as fs37 from "node:fs";
+import * as path38 from "node:path";
 function normalizeQuotes(str) {
   return str.replaceAll(LEFT_SINGLE_CURLY, "'").replaceAll(RIGHT_SINGLE_CURLY, "'").replaceAll(LEFT_DOUBLE_CURLY, '"').replaceAll(RIGHT_DOUBLE_CURLY, '"');
 }
@@ -6893,7 +7076,7 @@ Usage:
         }
         let fileContent = null;
         try {
-          const stat4 = fs36.statSync(filePath);
+          const stat4 = fs37.statSync(filePath);
           if (stat4.isDirectory()) {
             return { content: `\u8DEF\u5F84\u662F\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6: ${filePath}`, isError: true };
           }
@@ -6903,21 +7086,21 @@ Usage:
         } catch (e) {
           if (e.code === "ENOENT") {
             if (oldString === "") {
-              const dir = path37.dirname(filePath);
-              fs36.mkdirSync(dir, { recursive: true });
-              fs36.writeFileSync(filePath, newString, "utf-8");
-              readFileState.set(filePath, { timestamp: fs36.statSync(filePath).mtimeMs });
+              const dir = path38.dirname(filePath);
+              fs37.mkdirSync(dir, { recursive: true });
+              fs37.writeFileSync(filePath, newString, "utf-8");
+              readFileState.set(filePath, { timestamp: fs37.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 = fs36.readFileSync(filePath, "utf-8");
+        const rawContent = fs37.readFileSync(filePath, "utf-8");
         fileContent = rawContent.replaceAll("\r\n", "\n");
         if (oldString === "" && fileContent.trim() === "") {
-          fs36.writeFileSync(filePath, newString, "utf-8");
-          readFileState.set(filePath, { timestamp: fs36.statSync(filePath).mtimeMs });
+          fs37.writeFileSync(filePath, newString, "utf-8");
+          readFileState.set(filePath, { timestamp: fs37.statSync(filePath).mtimeMs });
           return { content: `\u5199\u5165\u7A7A\u6587\u4EF6: ${filePath} (${newString.split("\n").length} \u884C)` };
         }
         const readState = readFileState.get(filePath);
@@ -6927,11 +7110,11 @@ Usage:
             isError: true
           };
         }
-        const currentStat = fs36.statSync(filePath);
+        const currentStat = fs37.statSync(filePath);
         const lastWriteTime = Math.floor(currentStat.mtimeMs);
         if (lastWriteTime > readState.timestamp) {
           if (fileContent !== rawContent.replaceAll("\r\n", "\n")) {
-            if (fileContent !== fs36.readFileSync(filePath, "utf-8").replaceAll("\r\n", "\n")) {
+            if (fileContent !== fs37.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
@@ -6963,8 +7146,8 @@ ${preview}
         const actualNewString = preserveQuoteStyle(oldString, actualOldString, newString);
         const diffView = generateEditDiff(fileContent, actualOldString, actualNewString);
         const newContent = applyEditToFile(fileContent, actualOldString, actualNewString, replaceAll);
-        fs36.writeFileSync(filePath, newContent, "utf-8");
-        readFileState.set(filePath, { timestamp: fs36.statSync(filePath).mtimeMs });
+        fs37.writeFileSync(filePath, newContent, "utf-8");
+        readFileState.set(filePath, { timestamp: fs37.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`;
@@ -6982,8 +7165,8 @@ ${diffView}`
 
 // src/tools/glob.ts
 var glob_exports = {};
-import * as fs37 from "node:fs";
-import * as path38 from "node:path";
+import * as fs38 from "node:fs";
+import * as path39 from "node:path";
 function globMatch(pattern, filename) {
   const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   try {
@@ -7003,18 +7186,18 @@ function findFiles(dir, pattern, limit, baseDir) {
     }
     let entries;
     try {
-      entries = fs37.readdirSync(currentDir, { withFileTypes: true });
+      entries = fs38.readdirSync(currentDir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (truncated) return;
-      const fullPath = path38.join(currentDir, entry.name);
+      const fullPath = path39.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (VCS_DIRS.has(entry.name)) continue;
         walk(fullPath);
       } else if (entry.isFile()) {
-        const relativePath = path38.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = path39.relative(baseDir, fullPath).replace(/\\/g, "/");
         const patternsToTry = [pattern];
         if (pattern.startsWith("**/")) {
           patternsToTry.push(pattern.slice(3));
@@ -7024,7 +7207,7 @@ function findFiles(dir, pattern, limit, baseDir) {
         );
         if (matched) {
           try {
-            const stat4 = fs37.statSync(fullPath);
+            const stat4 = fs38.statSync(fullPath);
             results.push({ path: fullPath, mtimeMs: stat4.mtimeMs });
           } catch {
           }
@@ -7041,7 +7224,7 @@ function findFiles(dir, pattern, limit, baseDir) {
   };
 }
 function toRelativePath(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path38.sep)) {
+  if (absolutePath.startsWith(cwd + path39.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   return absolutePath;
@@ -7074,10 +7257,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 (!fs37.existsSync(searchPath)) {
+        if (!fs38.existsSync(searchPath)) {
           return { content: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${searchPath}`, isError: true };
         }
-        if (!fs37.statSync(searchPath).isDirectory()) {
+        if (!fs38.statSync(searchPath).isDirectory()) {
           return { content: `\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${searchPath}`, isError: true };
         }
         const start = Date.now();
@@ -7102,7 +7285,7 @@ ${filenames.join("\n")}${truncatedNote}`
 // src/tools/grep.ts
 var grep_exports = {};
 import { execFile as execFile2 } from "node:child_process";
-import * as path39 from "node:path";
+import * as path40 from "node:path";
 function ripGrep(args, searchPath, signal) {
   return new Promise((resolve10) => {
     const fullArgs = [...args, searchPath];
@@ -7134,7 +7317,7 @@ function applyHeadLimit(items, limit, offset = 0) {
   };
 }
 function toRelativePath2(absolutePath, cwd) {
-  if (absolutePath.startsWith(cwd + path39.sep)) {
+  if (absolutePath.startsWith(cwd + path40.sep)) {
     return absolutePath.slice(cwd.length + 1);
   }
   if (absolutePath.startsWith(cwd)) {
@@ -8200,7 +8383,7 @@ function setSwarmsConfig(config) {
   _config2 = config;
 }
 function isAgentSwarmsEnabled() {
-  const feat = _config2?.profile?.features?.agentTeams;
+  const feat = getFeature("agentTeams");
   if (feat === true || feat?.enabled === true) {
     return true;
   }
@@ -8217,6 +8400,7 @@ var _config2;
 var init_agentSwarmsEnabled = __esm({
   "src/swarm/agentSwarmsEnabled.ts"() {
     "use strict";
+    init_features();
     _config2 = null;
   }
 });
@@ -9802,8 +9986,8 @@ var init_web_fetch = __esm({
 });
 
 // src/cron/tasks.ts
-import fs38 from "node:fs";
-import path40 from "node:path";
+import fs39 from "node:fs";
+import path41 from "node:path";
 import crypto5 from "node:crypto";
 function getStorageDir() {
   return storageDir;
@@ -9811,14 +9995,14 @@ function getStorageDir() {
 async function withFileLock(lockPath2, fn) {
   for (let attempt = 0; attempt < LOCK_RETRY_COUNT; attempt++) {
     try {
-      fs38.mkdirSync(lockPath2, { recursive: false });
+      fs39.mkdirSync(lockPath2, { recursive: false });
       break;
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stat4 = fs38.statSync(lockPath2);
+        const stat4 = fs39.statSync(lockPath2);
         if (Date.now() - stat4.mtimeMs > LOCK_STALE_THRESHOLD_MS) {
-          fs38.rmSync(lockPath2, { recursive: true, force: true });
+          fs39.rmSync(lockPath2, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -9834,22 +10018,22 @@ async function withFileLock(lockPath2, fn) {
     return fn();
   } finally {
     try {
-      fs38.rmSync(lockPath2, { recursive: true, force: true });
+      fs39.rmSync(lockPath2, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function atomicWriteJSON(filePath, data) {
   const tmpPath = filePath + ".tmp";
-  fs38.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-  fs38.renameSync(tmpPath, filePath);
+  fs39.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  fs39.renameSync(tmpPath, filePath);
 }
 function readTasksFromDisk() {
-  if (!tasksFilePath || !fs38.existsSync(tasksFilePath)) {
+  if (!tasksFilePath || !fs39.existsSync(tasksFilePath)) {
     return [];
   }
   try {
-    const raw = fs38.readFileSync(tasksFilePath, "utf-8");
+    const raw = fs39.readFileSync(tasksFilePath, "utf-8");
     const store = JSON.parse(raw);
     return store.tasks ?? [];
   } catch (err) {
@@ -9858,7 +10042,7 @@ function readTasksFromDisk() {
   }
 }
 async function writeTasksToDisk(tasks2) {
-  const lockPath2 = path40.join(storageDir, "tasks.json.lock");
+  const lockPath2 = path41.join(storageDir, "tasks.json.lock");
   await withFileLock(lockPath2, () => {
     const store = {
       version: 1,
@@ -9870,9 +10054,9 @@ async function writeTasksToDisk(tasks2) {
 }
 function initTaskStore(dir) {
   storageDir = dir;
-  tasksFilePath = path40.join(dir, "tasks.json");
-  if (!fs38.existsSync(dir)) {
-    fs38.mkdirSync(dir, { recursive: true });
+  tasksFilePath = path41.join(dir, "tasks.json");
+  if (!fs39.existsSync(dir)) {
+    fs39.mkdirSync(dir, { recursive: true });
   }
   const tasks2 = readTasksFromDisk();
   console.log(`[cron] Task store initialized: ${dir} (${tasks2.length} tasks loaded)`);
@@ -10121,12 +10305,12 @@ async function executeAndDeliver(task, now, deps) {
     if (promptText.startsWith("@")) {
       let filePath = promptText.slice(1).trim();
       try {
-        const fs42 = await import("fs");
-        const path45 = await import("path");
-        if (!path45.isAbsolute(filePath)) {
-          filePath = path45.join(deps.sessions["config"].stateDir, filePath);
+        const fs43 = await import("fs");
+        const path46 = await import("path");
+        if (!path46.isAbsolute(filePath)) {
+          filePath = path46.join(deps.sessions["config"].stateDir, filePath);
         }
-        promptText = fs42.readFileSync(filePath, "utf-8");
+        promptText = fs43.readFileSync(filePath, "utf-8");
         console.log(`[cron] Loaded prompt from ${filePath} (${promptText.length} chars)`);
       } catch (err) {
         throw new Error(`Prompt file not found: ${filePath}: ${err.message}`);
@@ -10153,16 +10337,16 @@ async function executeAndDeliver(task, now, deps) {
     let finalResult = result;
     if (task.postProcess) {
       try {
-        const path45 = await import("path");
-        const fs42 = await import("fs");
+        const path46 = await import("path");
+        const fs43 = await import("fs");
         let scriptPath = task.postProcess;
-        if (!path45.isAbsolute(scriptPath)) {
-          scriptPath = path45.join(deps.sessions["config"].stateDir, scriptPath);
+        if (!path46.isAbsolute(scriptPath)) {
+          scriptPath = path46.join(deps.sessions["config"].stateDir, scriptPath);
         }
-        const resultsDirTmp = path45.join(getStorageDir(), "results");
-        fs42.mkdirSync(resultsDirTmp, { recursive: true });
-        const inputFile = path45.join(resultsDirTmp, `${task.id}.input.txt`);
-        fs42.writeFileSync(inputFile, result, "utf-8");
+        const resultsDirTmp = path46.join(getStorageDir(), "results");
+        fs43.mkdirSync(resultsDirTmp, { recursive: true });
+        const inputFile = path46.join(resultsDirTmp, `${task.id}.input.txt`);
+        fs43.writeFileSync(inputFile, result, "utf-8");
         const { execFile: execFile3 } = await import("child_process");
         await new Promise((resolve10) => {
           execFile3("python", [scriptPath, "main", "--file", inputFile], {
@@ -10189,12 +10373,12 @@ async function executeAndDeliver(task, now, deps) {
       }
     }
     try {
-      const fs42 = await import("fs");
-      const path45 = await import("path");
-      const resultsDir = path45.join(getStorageDir(), "results");
-      fs42.mkdirSync(resultsDir, { recursive: true });
-      const resultFile = path45.join(resultsDir, `${task.id}.json`);
-      fs42.writeFileSync(resultFile, JSON.stringify({
+      const fs43 = await import("fs");
+      const path46 = await import("path");
+      const resultsDir = path46.join(getStorageDir(), "results");
+      fs43.mkdirSync(resultsDir, { recursive: true });
+      const resultFile = path46.join(resultsDir, `${task.id}.json`);
+      fs43.writeFileSync(resultFile, JSON.stringify({
         taskId: task.id,
         description: task.description,
         executedAt: now.toISOString(),
@@ -10440,30 +10624,30 @@ function registerCronTools() {
       }
     },
     handler: async (args) => {
-      const fs42 = await import("fs");
-      const path45 = await import("path");
-      const resultsDir = path45.join(getStorageDir(), "results");
-      if (!fs42.existsSync(resultsDir)) {
+      const fs43 = await import("fs");
+      const path46 = await import("path");
+      const resultsDir = path46.join(getStorageDir(), "results");
+      if (!fs43.existsSync(resultsDir)) {
         return { content: "\u6682\u65E0cron\u6267\u884C\u7ED3\u679C" };
       }
       if (args.task_id) {
-        const file = path45.join(resultsDir, `${args.task_id}.json`);
-        if (!fs42.existsSync(file)) {
+        const file = path46.join(resultsDir, `${args.task_id}.json`);
+        if (!fs43.existsSync(file)) {
           return { content: `\u4EFB\u52A1 ${args.task_id} \u6682\u65E0\u6267\u884C\u7ED3\u679C`, isError: true };
         }
-        const data = JSON.parse(fs42.readFileSync(file, "utf-8"));
+        const data = JSON.parse(fs43.readFileSync(file, "utf-8"));
         return { content: `## ${data.description}
 \u6267\u884C\u65F6\u95F4: ${data.executedAt}
 \u7B2C${data.runCount}\u6B21\u6267\u884C
 
 ${data.result}` };
       }
-      const files = fs42.readdirSync(resultsDir).filter((f) => f.endsWith(".json"));
+      const files = fs43.readdirSync(resultsDir).filter((f) => f.endsWith(".json"));
       if (files.length === 0) {
         return { content: "\u6682\u65E0cron\u6267\u884C\u7ED3\u679C" };
       }
       const results = files.map((f) => {
-        const data = JSON.parse(fs42.readFileSync(path45.join(resultsDir, f), "utf-8"));
+        const data = JSON.parse(fs43.readFileSync(path46.join(resultsDir, f), "utf-8"));
         return `### ${data.description} (${data.taskId.slice(0, 8)})
 \u6267\u884C: ${data.executedAt} | \u7B2C${data.runCount}\u6B21
 ${data.result.slice(0, 500)}${data.result.length > 500 ? "..." : ""}`;
@@ -10626,8 +10810,8 @@ var manager_exports = {};
 __export(manager_exports, {
   McpManager: () => McpManager
 });
-import * as fs40 from "node:fs";
-import * as path42 from "node:path";
+import * as fs41 from "node:fs";
+import * as path43 from "node:path";
 import { Client as Client3 } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -10660,12 +10844,12 @@ function convertInputSchema(inputSchema) {
 }
 function persistBinary(base64Data, mimeType, persistId) {
   const ext = mimeType?.split("/")[1] || "bin";
-  const dir = path42.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
-  fs40.mkdirSync(dir, { recursive: true });
-  const filepath = path42.join(dir, `${persistId}.${ext}`);
+  const dir = path43.join(process.env.ENGINE_STATE_DIR || ".engine", "mcp-blobs");
+  fs41.mkdirSync(dir, { recursive: true });
+  const filepath = path43.join(dir, `${persistId}.${ext}`);
   try {
     const buf = Buffer.from(base64Data, "base64");
-    fs40.writeFileSync(filepath, buf);
+    fs41.writeFileSync(filepath, buf);
     return { filepath, size: buf.length };
   } catch (err) {
     return { error: err.message };
@@ -10999,7 +11183,7 @@ __export(resources_exports, {
   registerMcpResourceTools: () => registerMcpResourceTools,
   unregisterMcpResourceTools: () => unregisterMcpResourceTools
 });
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 function registerMcpResourceTools(manager) {
   mcpManagerRef = manager;
   registry.register(listResourcesTool);
@@ -11017,7 +11201,7 @@ var init_resources = __esm({
     "use strict";
     init_registry();
     MAX_RESULT_CHARS2 = 1e5;
-    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path43.join(process.env.ENGINE_STATE_DIR || ".engine", "media", "inbound");
+    MEDIA_DIR = process.env.ENGINE_MEDIA_DIR || path44.join(process.env.ENGINE_STATE_DIR || ".engine", "media", "inbound");
     MCP_LIST_RESOURCES_TOOL = "mcp__list_resources";
     MCP_READ_RESOURCE_TOOL = "mcp__read_resource";
     mcpManagerRef = null;
@@ -11186,10 +11370,10 @@ function ensureLoaded(workspace, configIds) {
       if (!state.blockedUserIds.includes(id)) state.blockedUserIds.push(id);
     }
   }
-  const path45 = join38(workspace, ".reply-blocklist.json");
+  const path46 = join38(workspace, ".reply-blocklist.json");
   try {
-    if (existsSync24(path45)) {
-      const raw = readFileSync26(path45, "utf-8");
+    if (existsSync24(path46)) {
+      const raw = readFileSync26(path46, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.blockedUserIds) {
         for (const id of parsed.blockedUserIds) {
@@ -11205,9 +11389,9 @@ function ensureLoaded(workspace, configIds) {
   loaded = true;
 }
 function save(workspace) {
-  const path45 = join38(workspace, ".reply-blocklist.json");
+  const path46 = join38(workspace, ".reply-blocklist.json");
   try {
-    writeFileSync16(path45, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync16(path46, JSON.stringify(state, null, 2), "utf-8");
   } catch (err) {
     console.warn(`[reply-blocklist] Failed to save: ${err.message}`);
   }
@@ -11804,8 +11988,8 @@ var init_cognifold_intent_watcher = __esm({
 });
 
 // src/engine-startup.ts
-import * as path44 from "node:path";
-import * as fs41 from "node:fs";
+import * as path45 from "node:path";
+import * as fs42 from "node:fs";
 import { fileURLToPath } from "node:url";
 
 // src/pid-lock.ts
@@ -11961,6 +12145,7 @@ function loadDisplayConfig(raw) {
 }
 
 // src/config/loader.ts
+init_features();
 function parseModelRef(ref) {
   const idx = ref.indexOf("/");
   if (idx <= 0 || idx === ref.length - 1) {
@@ -12054,6 +12239,13 @@ function loadConfig(configPath) {
   const stateDir = raw.stateDir || process.env.ENGINE_STATE_DIR || path3.resolve(".engine");
   const workspace = process.env.ENGINE_WORKSPACE || agentDefaults.workspace || path3.join(stateDir, "workspace");
   const mediaDir = raw.mediaDir || path3.join(stateDir, "media", "inbound");
+  if (!agentDefaults.features) agentDefaults.features = {};
+  for (const [k, v] of Object.entries(FEATURE_DEFAULTS)) {
+    if (agentDefaults.features[k] === void 0) {
+      ;
+      agentDefaults.features[k] = v;
+    }
+  }
   const profile = {
     id: process.env.ENGINE_AGENT || "default",
     name: agentDefaults.name || "AI Assistant",
@@ -12061,27 +12253,8 @@ function loadConfig(configPath) {
     workspace,
     soul: agentDefaults.soul,
     agents: agentDefaults.agents,
-    features: {
-      filesystem: true,
-      shell: true,
-      memory: true,
-      "topic-extract": true,
-      "topic-recall": true,
-      "session-memory": true,
-      todo: true,
-      cron: false,
-      voice: false,
-      selfie: false,
-      eyes: false,
-      calendar: false,
-      webSearch: true,
-      webFetch: true,
-      agentTeams: true,
-      processOutput: "verbose",
-      interrupt: "command",
-      debounceMs: 5e3,
-      ...agentDefaults.features || {}
-    },
+    features: agentDefaults.features,
+    // canonical：profile.features 即 agents.defaults.features（同一对象，过渡兼容）
     channels: agentDefaults.channels || [],
     extensions: agentDefaults.extensions,
     maxTurns: agentDefaults.maxTurns,
@@ -12170,6 +12343,7 @@ function loadConfig(configPath) {
 
 // src/engine-startup.ts
 init_live();
+init_features();
 
 // src/services/withRetry.ts
 import { ProxyAgent } from "undici";
@@ -13430,13 +13604,13 @@ var DiscordAdapter = class _DiscordAdapter {
   }
   /** 发送媒体附件（图片/文件/音频）— discord.js channel.send({ files }) */
   async sendFile(target, message, attachment) {
-    const fs42 = await import("node:fs");
-    const path45 = await import("node:path");
-    if (!fs42.existsSync(attachment.path)) {
+    const fs43 = await import("node:fs");
+    const path46 = await import("node:path");
+    if (!fs43.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path45.basename(attachment.path);
-    const fileBuffer = fs42.readFileSync(attachment.path);
+    const filename = attachment.filename || path46.basename(attachment.path);
+    const fileBuffer = fs43.readFileSync(attachment.path);
     const filePayload = {
       attachment: fileBuffer,
       name: filename
@@ -13876,13 +14050,13 @@ var FeishuAdapter = class _FeishuAdapter {
   }
   /** 发送媒体附件（图片/文件） */
   async sendFile(target, message, attachment) {
-    const fs42 = await import("node:fs");
-    const path45 = await import("node:path");
-    if (!fs42.existsSync(attachment.path)) {
+    const fs43 = await import("node:fs");
+    const path46 = await import("node:path");
+    if (!fs43.existsSync(attachment.path)) {
       throw new Error(`File not found: ${attachment.path}`);
     }
-    const filename = attachment.filename || path45.basename(attachment.path);
-    const fileBuffer = fs42.readFileSync(attachment.path);
+    const filename = attachment.filename || path46.basename(attachment.path);
+    const fileBuffer = fs43.readFileSync(attachment.path);
     const receiveIdType = target.startsWith("ou_") ? "open_id" : "chat_id";
     const mimeType = attachment.mimeType || "application/octet-stream";
     if (mimeType.startsWith("image/")) {
@@ -16630,7 +16804,7 @@ function entryToSessionMessage(entry) {
   if (role === "user") {
     const text = extractText2(m.content);
     if (text !== null) {
-      return { role: "user", content: text, _raw: entry.raw };
+      return { role: "user", content: text, timestamp: entry.timestamp, _raw: entry.raw };
     }
     return null;
   } else if (role === "assistant") {
@@ -16653,6 +16827,7 @@ function entryToSessionMessage(entry) {
     const result = {
       role: "assistant",
       content: textContent,
+      timestamp: entry.timestamp,
       _raw: entry.raw
     };
     if (toolCalls.length > 0) {
@@ -16664,6 +16839,7 @@ function entryToSessionMessage(entry) {
     return {
       role: "tool",
       content: text || "",
+      timestamp: entry.timestamp,
       tool_call_id: m.toolCallId,
       _raw: entry.raw
     };
@@ -17077,16 +17253,22 @@ var SessionManager = class {
           continue;
         }
         if (m.role === "user") {
-          allMessages.push(msg.user(m.content));
+          const u = msg.user(m.content);
+          if (m.timestamp) u.timestamp = m.timestamp;
+          allMessages.push(u);
         } else if (m.role === "assistant") {
           const toolCalls = m.tool_calls?.map((tc) => ({
             id: tc.id,
             type: "function",
             function: { name: tc.function.name, arguments: tc.function.arguments }
           }));
-          allMessages.push(msg.assistant(m.content, toolCalls));
+          const a = msg.assistant(m.content, toolCalls);
+          if (m.timestamp) a.timestamp = m.timestamp;
+          allMessages.push(a);
         } else if (m.role === "tool") {
-          allMessages.push(msg.tool(m.tool_call_id || "", m.content));
+          const t = msg.tool(m.tool_call_id || "", m.content);
+          if (m.timestamp) t.timestamp = m.timestamp;
+          allMessages.push(t);
         }
       }
     }
@@ -17811,6 +17993,8 @@ var MessageQueue = class {
 // src/handle-query.ts
 init_types();
 init_attachments();
+init_live();
+init_features();
 init_task_manager();
 
 // src/prompt.ts
@@ -18591,7 +18775,7 @@ ${ep.episode || ep.summary}`,
 init_paths();
 import { readFileSync as readFileSync15, existsSync as existsSync12 } from "node:fs";
 import { join as join20, resolve as resolve6 } from "node:path";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 var contactMap = null;
 var externalChanWhitelist = null;
 function loadContactMap(workspace) {
@@ -18659,18 +18843,18 @@ function truncate(s, maxLen) {
 }
 var externalChanRulesCache = null;
 function loadExternalChanRules(workspace) {
-  const path45 = join20(workspace, "prompts", "external-chan-rules.md");
-  if (externalChanRulesCache && externalChanRulesCache.path === path45) return externalChanRulesCache;
+  const path46 = join20(workspace, "prompts", "external-chan-rules.md");
+  if (externalChanRulesCache && externalChanRulesCache.path === path46) return externalChanRulesCache;
   let content = "";
-  if (existsSync12(path45)) {
+  if (existsSync12(path46)) {
     try {
-      content = readFileSync15(path45, "utf-8").trim();
+      content = readFileSync15(path46, "utf-8").trim();
     } catch (e) {
       console.warn(`[external-chan-rules] Failed to load: ${e}`);
     }
   }
-  externalChanRulesCache = { path: path45, content };
-  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path45}`);
+  externalChanRulesCache = { path: path46, content };
+  console.log(`[external-chan-rules] Loaded ${content.length} chars from ${path46}`);
   return externalChanRulesCache;
 }
 function getExternalChanRulesBlock(inboundMeta, workspace) {
@@ -18698,7 +18882,7 @@ async function handleQuery(text, sessionId, channelName, cb, deps, channelTarget
 }
 async function handleQueryInner(text, sessionId, channelName, cb, deps, channelTarget, inboundMeta, skipRecall, source) {
   const { engine, sessions, channelManager, workspace, providerId, providerApi, model } = deps;
-  const features = deps.features || {};
+  const topics = liveConfig.get("topics") || {};
   const preQueryAbort = new AbortController();
   engine.setPreQueryAbort(preQueryAbort);
   let history = sessions.getHistory(sessionId);
@@ -18707,7 +18891,7 @@ async function handleQueryInner(text, sessionId, channelName, cb, deps, channelT
     if (restored.length > 0) {
       history = restored;
       sessions.setHistory(sessionId, history);
-      if (deps.topics?.restoreRecall === false) {
+      if (topics?.restoreRecall === false) {
         let stripped = 0;
         for (let i = history.length - 1; i >= 0; i--) {
           const m = history[i];
@@ -18897,7 +19081,7 @@ ${text}` : text });
     // 对齐 CC: fork subagent 继承父对话历史
     parentSystemPrompt: deps.systemPrompt,
     // 对齐 CC: fork 共享 prompt cache
-    features: deps.features,
+    features: liveConfig.get("agents.defaults.features"),
     // engine config features（AgentTool 读 agentTool.showProgress）
     channelTarget: channelTarget ?? "",
     // 回复目标（Discord channel ID / user ID）
@@ -19013,13 +19197,13 @@ ${text}` : text });
   engine.setExternalAbort(queryAbortController);
   setActiveQueryEngine(sessionId, engine);
   const shouldSkipRecall = skipRecall ?? channelName === "cron";
-  if (features["topic-recall"] !== false && !shouldSkipRecall) {
+  if (getFeature("topic-recall") !== false && !shouldSkipRecall) {
     try {
       const memoryDir = getAutoMemPath(workspace);
       const provider = deps.engine.getProvider();
       const surfacedHistory = collectSurfacedMemories(history);
       const cumulativePaths = sessions.getRestoredRecallPaths(sessionId);
-      const doRestore = deps.topics?.restoreRecall === true;
+      const doRestore = topics?.restoreRecall === true;
       const surfaced = doRestore ? { paths: /* @__PURE__ */ new Set([...surfacedHistory.paths, ...cumulativePaths]) } : surfacedHistory;
       console.log(`[handle-query] surfaced: history=${surfacedHistory.paths.size} cumulative=${cumulativePaths.size} merged=${surfaced.paths.size} restoreRecall=${doRestore}`);
       if (doRestore) {
@@ -19058,7 +19242,7 @@ ${text}` : text });
       console.log(`[handle-query] Memory recall starting: dir=${memoryDir} query="${(typeof text === "string" ? text : "[content blocks]").slice(0, 50)}..." alreadySurfaced=${surfaced.paths.size}`);
       const textForMemory = typeof text === "string" ? text : text.filter((b) => b.type === "text").map((b) => b.text).join(" ");
       const recallP = deps.recallProvider;
-      const recallMode = deps.topics?.recall?.mode || "llm";
+      const recallMode = topics?.recall?.mode || "llm";
       let relevantMemories;
       if (recallMode === "everos") {
         const everosCfg = deps?.everosCfg;
@@ -19073,7 +19257,7 @@ ${text}` : text });
             rerankApiKey: everosCfg.rerank?.apiKey,
             rerankModel: everosCfg.rerank?.model,
             rerankProvider: everosCfg.rerank?.provider,
-            minScore: deps.topics?.recall?.minScore
+            minScore: topics?.recall?.minScore
           } : void 0
         );
       } else if (recallMode === "vector") {
@@ -19091,7 +19275,7 @@ ${text}` : text });
           queryAbortController.signal,
           surfaced.paths,
           recallP?.disableThinking,
-          deps.topics?.maxScanFiles
+          topics?.maxScanFiles
         );
       }
       console.log(`[handle-query] Memory recall result: ${relevantMemories.length} memories found: ${relevantMemories.map((m) => m.path.split(/[/\\]/).pop()).join(", ")}`);
@@ -19275,7 +19459,7 @@ ${text}` : text });
     }
   }
   sessions.setHistory(sessionId, history);
-  if (features["topic-extract"] && sessionId === deps.sessions.getSessionId("scope:main")) {
+  if (getFeature("topic-extract") === true && sessionId === deps.sessions.getSessionId("scope:main")) {
     try {
       const { createMemoryExtractor: createMemoryExtractor2 } = await Promise.resolve().then(() => (init_extractMemories(), extractMemories_exports));
       const extractor = createMemoryExtractor2(workspace, true);
@@ -19290,6 +19474,15 @@ ${text}` : text });
       console.warn(`[handle-query] Memory extraction init failed: ${err.message}`);
     }
   }
+  if (liveConfig.get("everos.enabled") === true && sessionId === deps.sessions.getSessionId("scope:main")) {
+    try {
+      const { pushConversation: pushConversation2 } = await Promise.resolve().then(() => (init_ingest(), ingest_exports));
+      pushConversation2(messages, sessionId, workspace).catch(() => {
+      });
+    } catch (e) {
+      console.warn(`[handle-query] everos push init failed: ${e?.message ?? e}`);
+    }
+  }
   try {
     const { isSessionMemoryEnabled: isSessionMemoryEnabled2, shouldExtractMemory: shouldExtractMemory2, extractSessionMemory: extractSessionMemory2 } = await Promise.resolve().then(() => (init_sessionMemory(), sessionMemory_exports));
     if (isSessionMemoryEnabled2()) {
@@ -19336,7 +19529,7 @@ stack: ${err.stack ?? "(none)"}`);
     }
   } catch (err) {
     try {
-      (await import("node:fs")).appendFileSync(join20(process.env.ENGINE7_STATE_DIR || process.env.OPENCLAW_STATE_DIR || path13.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(join20(process.env.ENGINE7_STATE_DIR || process.env.OPENCLAW_STATE_DIR || path14.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 {
@@ -19535,17 +19728,17 @@ var MessageDispatcher = class {
 };
 
 // src/cli-startup.ts
-import * as path14 from "node:path";
-import * as fs13 from "node:fs";
+import * as path15 from "node:path";
+import * as fs14 from "node:fs";
 import * as readline2 from "node:readline";
 function getDailyLogPath(stateDir) {
   const dateStr = (/* @__PURE__ */ new Date()).toLocaleDateString("sv-SE", { timeZone: "Asia/Shanghai" });
-  return path14.join(stateDir, "logs", `engine-${dateStr}.log`);
+  return path15.join(stateDir, "logs", `engine-${dateStr}.log`);
 }
 function setupFileLogging(stateDir) {
   const LOG_PATH = getDailyLogPath(stateDir);
-  fs13.mkdirSync(path14.join(stateDir, "logs"), { recursive: true });
-  const logStream = fs13.createWriteStream(LOG_PATH, { flags: "a" });
+  fs14.mkdirSync(path15.join(stateDir, "logs"), { recursive: true });
+  const logStream = fs14.createWriteStream(LOG_PATH, { flags: "a" });
   logStream.on("error", (err) => console.error(`[log] Write error: ${err.message}`));
   function ts() {
     return (/* @__PURE__ */ new Date()).toLocaleString("sv-SE", { timeZone: "Asia/Shanghai", hour12: false }) + "." + String(Date.now() % 1e3).padStart(3, "0");
@@ -19635,8 +19828,8 @@ function startCliLoop(deps, cliConfig, channelManager, dispatcher) {
 }
 
 // src/session/session-history.ts
-import fs14 from "node:fs";
-import path15 from "node:path";
+import fs15 from "node:fs";
+import path16 from "node:path";
 var BEIJING_OFFSET_MS = 8 * 36e5;
 var INJECTED_CONTENT_PATTERNS = [
   /【定时心跳】/,
@@ -19690,10 +19883,10 @@ function scopeMainJsonlPaths(sessions) {
   let latestArchive = null;
   if (current) {
     try {
-      const dir = path15.dirname(current);
-      const base = path15.basename(current);
-      const archives = fs14.readdirSync(dir).filter((f) => f.startsWith(base + ".archived.")).sort();
-      if (archives.length > 0) latestArchive = path15.join(dir, archives[archives.length - 1]);
+      const dir = path16.dirname(current);
+      const base = path16.basename(current);
+      const archives = fs15.readdirSync(dir).filter((f) => f.startsWith(base + ".archived.")).sort();
+      if (archives.length > 0) latestArchive = path16.join(dir, archives[archives.length - 1]);
     } catch {
     }
   }
@@ -19711,7 +19904,7 @@ function extractText3(content) {
 function findLastRealUserMsg(jsonlPath) {
   let lines;
   try {
-    lines = fs14.readFileSync(jsonlPath, "utf-8").split("\n");
+    lines = fs15.readFileSync(jsonlPath, "utf-8").split("\n");
   } catch {
     return null;
   }
@@ -19755,7 +19948,7 @@ function lastUserMsg(sessions) {
 function recentMessages(sessions, hours = 12, limit = 60) {
   const jsonlPath = resolveScopeMainJsonl(sessions);
   if (!jsonlPath) return [];
-  const lines = fs14.readFileSync(jsonlPath, "utf-8").split("\n");
+  const lines = fs15.readFileSync(jsonlPath, "utf-8").split("\n");
   const entries = parseJsonlEntries(lines);
   const nowMs = Date.now();
   const cutoffMs = nowMs - hours * 36e5;
@@ -19951,8 +20144,8 @@ ${basePrompt}`;
 };
 
 // src/nudge/plugin.ts
-import fs17 from "node:fs";
-import path18 from "node:path";
+import fs18 from "node:fs";
+import path19 from "node:path";
 
 // src/nudge/judge.ts
 function shouldNudge(task, taskState, cfg) {
@@ -20120,14 +20313,14 @@ function formatDuration2(ms) {
 }
 
 // src/nudge/session-state-reader.ts
-import fs15 from "node:fs";
-import path16 from "node:path";
+import fs16 from "node:fs";
+import path17 from "node:path";
 function parseSessionStateFull(workspace, sessionStateFile) {
   const stateFile = sessionStateFile || "SESSION-STATE.md";
-  const statePath = path16.isAbsolute(stateFile) ? stateFile : path16.join(workspace, stateFile);
+  const statePath = path17.isAbsolute(stateFile) ? stateFile : path17.join(workspace, stateFile);
   let content;
   try {
-    content = fs15.readFileSync(statePath, "utf-8");
+    content = fs16.readFileSync(statePath, "utf-8");
   } catch {
     console.warn(`[nudge] SESSION-STATE not found at ${statePath}`);
     return { activeTasks: [], orphanPendings: [] };
@@ -20179,13 +20372,13 @@ function taskIdFromTitle(title) {
 
 // src/calendar/db.ts
 import { DatabaseSync } from "node:sqlite";
-import * as path17 from "node:path";
-import * as fs16 from "node:fs";
+import * as path18 from "node:path";
+import * as fs17 from "node:fs";
 var TZ_OFFSET_MS = 8 * 60 * 60 * 1e3;
 function openDb(workspace) {
-  const dir = path17.join(workspace, ".calendar");
-  fs16.mkdirSync(dir, { recursive: true });
-  const dbPath = path17.join(dir, "calendar.db");
+  const dir = path18.join(workspace, ".calendar");
+  fs17.mkdirSync(dir, { recursive: true });
+  const dbPath = path18.join(dir, "calendar.db");
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode=WAL");
   db.exec(`CREATE TABLE IF NOT EXISTS events (
@@ -20274,9 +20467,9 @@ var NudgePlugin = class {
   provider;
   model;
   loadPrompt(workspace, promptFile) {
-    const promptPath = promptFile ? path18.isAbsolute(promptFile) ? promptFile : path18.join(workspace, promptFile) : path18.join(workspace, "prompts", "nudge-prompt.md");
+    const promptPath = promptFile ? path19.isAbsolute(promptFile) ? promptFile : path19.join(workspace, promptFile) : path19.join(workspace, "prompts", "nudge-prompt.md");
     try {
-      const content = fs17.readFileSync(promptPath, "utf-8").trim();
+      const content = fs18.readFileSync(promptPath, "utf-8").trim();
       if (content) {
         console.log(`[nudge] Loaded custom prompt from ${promptPath}`);
         return content;
@@ -20307,6 +20500,18 @@ var NudgePlugin = class {
     registerCallbackHook("Stop", {
       type: "callback",
       callback: async (input, _toolUseID, _signal) => {
+        const mode = this.cfg.stopHookMode || "sync";
+        if (mode === "async") {
+          console.log("[stop-hook] async mode \u2014 firing judge in background, not blocking");
+          this.runStopHookJudge(input, sessions).catch((err) => {
+            if (/judge \d+ms timeout/i.test(err?.message || "")) {
+              console.warn(`[stop-hook] async judge timed out (abandoned)`);
+            } else {
+              console.warn(`[stop-hook] async judge error: ${err.message}`);
+            }
+          });
+          return { outcome: { outcome: "success" } };
+        }
         const timeoutMs = this.cfg.timeoutMs ?? 15e3;
         let judgeTimer;
         const judgeTimeout = new Promise((_, reject) => {
@@ -20329,7 +20534,7 @@ var NudgePlugin = class {
         return { outcome: { outcome: "success" } };
       }
     });
-    console.log("[stop-hook] Registered Stop callback hook (LLM semantic judge + 5min wake-up, hard timeout via Promise.race)");
+    console.log(`[stop-hook] Registered Stop callback hook (mode=${this.cfg.stopHookMode || "sync"}, LLM semantic judge + 5min wake-up)`);
   }
   /** Judge 完整逻辑（被 callback 用 Promise.race 调用，可被 timeout 截断） */
   async runStopHookJudge(input, sessions) {
@@ -20364,6 +20569,12 @@ var NudgePlugin = class {
     if (!lastMsg) {
       return;
     }
+    const currentHour = (/* @__PURE__ */ new Date()).getHours();
+    const isNightTime = currentHour >= 22 || currentHour < 8;
+    if (isNightTime) {
+      console.log(`[stop-hook] night time (${currentHour}:xx), skipping needLanding/waiting judge`);
+      return;
+    }
     let contextStr = "";
     try {
       const recent = recentMessages(sessions, 0.5, 6);
@@ -20486,18 +20697,18 @@ var NudgePlugin = class {
     if (!isWaiting) {
       return;
     }
-    const nudgeDir = path18.join(this.workspace, ".nudge");
-    const notifPath = path18.join(nudgeDir, "stop-hook-notifications.json");
+    const nudgeDir = path19.join(this.workspace, ".nudge");
+    const notifPath = path19.join(nudgeDir, "stop-hook-notifications.json");
     try {
-      if (!fs17.existsSync(nudgeDir)) fs17.mkdirSync(nudgeDir, { recursive: true });
+      if (!fs18.existsSync(nudgeDir)) fs18.mkdirSync(nudgeDir, { recursive: true });
       let notifs = [];
-      if (fs17.existsSync(notifPath)) {
-        notifs = JSON.parse(fs17.readFileSync(notifPath, "utf-8"));
+      if (fs18.existsSync(notifPath)) {
+        notifs = JSON.parse(fs18.readFileSync(notifPath, "utf-8"));
         const now = Date.now();
         const dup = notifs.find((n) => !n.notified && n.description === (waitDesc || lastMsg.slice(0, 200)));
         if (dup) {
           dup.wakeAt = new Date(now + 5 * 6e4).toISOString();
-          fs17.writeFileSync(notifPath, JSON.stringify(notifs, null, 2));
+          fs18.writeFileSync(notifPath, JSON.stringify(notifs, null, 2));
           console.log(`[stop-hook] Duplicate wait (same desc, not fired yet), refreshed wakeAt: ${dup.id}`);
           return;
         }
@@ -20515,7 +20726,7 @@ var NudgePlugin = class {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         wakeAt
       });
-      fs17.writeFileSync(notifPath, JSON.stringify(notifs, null, 2));
+      fs18.writeFileSync(notifPath, JSON.stringify(notifs, null, 2));
       console.log(`[stop-hook] Registered wake-up ${notifId} at ${wakeAt} (sessionId=${sessionId}): ${waitDesc}`);
     } catch (e) {
       console.warn(`[stop-hook] Failed to register: ${e.message}`);
@@ -20552,10 +20763,10 @@ var NudgePlugin = class {
    * 已 notified 的不会再触发，等 agent 回复 "<id> 过期了" 由 cleanup 删。
    */
   collectDueStopHookNotifications() {
-    const notifPath = path18.join(this.workspace, ".nudge", "stop-hook-notifications.json");
+    const notifPath = path19.join(this.workspace, ".nudge", "stop-hook-notifications.json");
     try {
-      if (!fs17.existsSync(notifPath)) return null;
-      const notifs = JSON.parse(fs17.readFileSync(notifPath, "utf-8"));
+      if (!fs18.existsSync(notifPath)) return null;
+      const notifs = JSON.parse(fs18.readFileSync(notifPath, "utf-8"));
       if (notifs.length === 0) return null;
       const now = Date.now();
       const due = notifs.filter((n) => new Date(n.wakeAt).getTime() <= now && !n.notified);
@@ -20591,18 +20802,18 @@ ${items}
   }
   /** 按 id 删除条目（stop-hook 实时清理用；正常删除路径，agent 回复即删） */
   removeNotificationsById(ids) {
-    const notifPath = path18.join(this.workspace, ".nudge", "stop-hook-notifications.json");
+    const notifPath = path19.join(this.workspace, ".nudge", "stop-hook-notifications.json");
     try {
-      if (!fs17.existsSync(notifPath)) return;
-      const notifs = JSON.parse(fs17.readFileSync(notifPath, "utf-8"));
+      if (!fs18.existsSync(notifPath)) return;
+      const notifs = JSON.parse(fs18.readFileSync(notifPath, "utf-8"));
       const idSet = new Set(ids);
       const remaining = notifs.filter((n) => !idSet.has(n.id));
       const removed = notifs.length - remaining.length;
       if (removed === 0) return;
       if (remaining.length > 0) {
-        fs17.writeFileSync(notifPath, JSON.stringify(remaining, null, 2));
+        fs18.writeFileSync(notifPath, JSON.stringify(remaining, null, 2));
       } else {
-        fs17.unlinkSync(notifPath);
+        fs18.unlinkSync(notifPath);
       }
       console.log(`[stop-hook] Cleaned ${removed} notification(s) from reply: ${ids.join(", ")}`);
     } catch (e) {
@@ -20611,13 +20822,13 @@ ${items}
   }
   /** 投递成功后标记 notified（防重复触发）；不删除——删除只走 agent 回复 "<id> 过期了" */
   markNotified(ids) {
-    const notifPath = path18.join(this.workspace, ".nudge", "stop-hook-notifications.json");
+    const notifPath = path19.join(this.workspace, ".nudge", "stop-hook-notifications.json");
     try {
-      if (!fs17.existsSync(notifPath)) return;
-      const notifs = JSON.parse(fs17.readFileSync(notifPath, "utf-8"));
+      if (!fs18.existsSync(notifPath)) return;
+      const notifs = JSON.parse(fs18.readFileSync(notifPath, "utf-8"));
       const idSet = new Set(ids);
       const updated = notifs.map((n) => idSet.has(n.id) ? { ...n, notified: true } : n);
-      fs17.writeFileSync(notifPath, JSON.stringify(updated, null, 2));
+      fs18.writeFileSync(notifPath, JSON.stringify(updated, null, 2));
     } catch (e) {
       console.warn(`[nudge] markNotified error: ${e.message}`);
     }
@@ -20634,9 +20845,9 @@ ${items}
    */
   cleanupStaleNotificationsFromMessages(sessions) {
     try {
-      const notifPath = path18.join(this.workspace, ".nudge", "stop-hook-notifications.json");
-      if (!fs17.existsSync(notifPath)) return;
-      const notifs = JSON.parse(fs17.readFileSync(notifPath, "utf-8"));
+      const notifPath = path19.join(this.workspace, ".nudge", "stop-hook-notifications.json");
+      if (!fs18.existsSync(notifPath)) return;
+      const notifs = JSON.parse(fs18.readFileSync(notifPath, "utf-8"));
       if (notifs.length === 0) return;
       const expiredIds = this.findExpiredReplyIds(sessions, notifs);
       const ttlMs = (this.cfg.cleanupTtlHours || 24) * 36e5;
@@ -20648,9 +20859,9 @@ ${items}
       if (removeIds.size === 0) return;
       const remaining = notifs.filter((n) => !removeIds.has(n.id));
       if (remaining.length > 0) {
-        fs17.writeFileSync(notifPath, JSON.stringify(remaining, null, 2));
+        fs18.writeFileSync(notifPath, JSON.stringify(remaining, null, 2));
       } else {
-        fs17.unlinkSync(notifPath);
+        fs18.unlinkSync(notifPath);
       }
       if (expiredIds.size > 0) {
         console.log(`[nudge] Cleaned ${expiredIds.size} notification(s) by reply: ${[...expiredIds].join(", ")}`);
@@ -20675,10 +20886,10 @@ ${items}
     const oldestMs = Math.min(...notifs.map((n) => new Date(n.wakeAt).getTime()));
     const { current, latestArchive } = scopeMainJsonlPaths(sessions);
     for (const file of [current, latestArchive]) {
-      if (!file || !fs17.existsSync(file)) continue;
+      if (!file || !fs18.existsSync(file)) continue;
       let lines;
       try {
-        lines = fs17.readFileSync(file, "utf-8").split("\n");
+        lines = fs18.readFileSync(file, "utf-8").split("\n");
       } catch (e) {
         console.warn(`[nudge] findExpiredReplyIds read error on ${file}: ${e.message}`);
         continue;
@@ -20935,9 +21146,9 @@ ${items}
   // === state 持久化 ===
   loadState() {
     const stateFile = this.cfg.stateFile || "nudge-state.json";
-    const statePath = path18.isAbsolute(stateFile) ? stateFile : path18.join(this.workspace, stateFile);
+    const statePath = path19.isAbsolute(stateFile) ? stateFile : path19.join(this.workspace, stateFile);
     try {
-      const content = fs17.readFileSync(statePath, "utf-8");
+      const content = fs18.readFileSync(statePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return { tasks: {} };
@@ -20945,8 +21156,8 @@ ${items}
   }
   saveState(state2) {
     const stateFile = this.cfg.stateFile || "nudge-state.json";
-    const statePath = path18.isAbsolute(stateFile) ? stateFile : path18.join(this.workspace, stateFile);
-    fs17.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
+    const statePath = path19.isAbsolute(stateFile) ? stateFile : path19.join(this.workspace, stateFile);
+    fs18.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
   }
   newTaskState() {
     return {
@@ -21124,8 +21335,8 @@ ${items}
 };
 
 // src/inner-voice/plugin.ts
-import fs21 from "node:fs";
-import path22 from "node:path";
+import fs22 from "node:fs";
+import path23 from "node:path";
 
 // src/inner-voice/activity.ts
 function checkActivity(sessions, activeThresholdMs) {
@@ -21164,8 +21375,8 @@ function calcHintProb(min) {
 }
 
 // src/inner-voice/emotional-state.ts
-import fs18 from "node:fs";
-import path19 from "node:path";
+import fs19 from "node:fs";
+import path20 from "node:path";
 var NEUTRAL = 0.5;
 var DECAY_RATE = 0.17;
 var MAX_EVENTS = 20;
@@ -21216,7 +21427,7 @@ function initialState() {
   return { version: 1, mood: NEUTRAL, trend: "stable", updatedAt: nowIsoBj(), events: [] };
 }
 async function updateEmotionalState(workspace, sessions) {
-  const stateFile = path19.join(workspace, "inner-voice", "emotional-state.json");
+  const stateFile = path20.join(workspace, "inner-voice", "emotional-state.json");
   const messages = readRecentMessages(sessions, RECENT_N);
   if (messages.length === 0) {
     console.log("[emotional-state] no messages");
@@ -21249,8 +21460,8 @@ async function updateEmotionalState(workspace, sessions) {
 function readRecentMessages(sessions, n) {
   const mainId = sessions.getSessionId("scope:main");
   if (!mainId) return [];
-  const file = path19.join(sessions.sessionsDir, `${mainId}.jsonl`);
-  if (!fs18.existsSync(file)) return [];
+  const file = path20.join(sessions.sessionsDir, `${mainId}.jsonl`);
+  if (!fs19.existsSync(file)) return [];
   const lines = readLastNLines(file, n * 4 + 20);
   const entries = [];
   for (const line of lines) {
@@ -21367,9 +21578,9 @@ function refreshHoursAgo(events) {
 }
 function appendMoodLog(workspace, state2, summary) {
   try {
-    const logPath = path19.join(workspace, "mood-history.log");
+    const logPath = path20.join(workspace, "mood-history.log");
     const ts = formatBj(/* @__PURE__ */ new Date(), false);
-    fs18.appendFileSync(logPath, `${ts}	mood=${state2.mood.toFixed(2)}	trend=${state2.trend}	${summary}
+    fs19.appendFileSync(logPath, `${ts}	mood=${state2.mood.toFixed(2)}	trend=${state2.trend}	${summary}
 `);
   } catch (err) {
     console.warn(`[emotional-state] mood log failed: ${err.message}`);
@@ -21377,32 +21588,32 @@ function appendMoodLog(workspace, state2, summary) {
 }
 function loadJson(file) {
   try {
-    return JSON.parse(fs18.readFileSync(file, "utf-8"));
+    return JSON.parse(fs19.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveJson(file, data) {
   try {
-    fs18.mkdirSync(path19.dirname(file), { recursive: true });
-    fs18.writeFileSync(file, JSON.stringify(data, null, 2));
+    fs19.mkdirSync(path20.dirname(file), { recursive: true });
+    fs19.writeFileSync(file, JSON.stringify(data, null, 2));
   } catch (err) {
     console.warn(`[emotional-state] save failed: ${err.message}`);
   }
 }
 function readLastNLines(file, maxLines) {
   try {
-    const stat4 = fs18.statSync(file);
+    const stat4 = fs19.statSync(file);
     const tailBytes = Math.min(stat4.size, maxLines * 512);
-    const fd = fs18.openSync(file, "r");
+    const fd = fs19.openSync(file, "r");
     try {
       const buf = Buffer.alloc(tailBytes);
-      fs18.readSync(fd, buf, 0, tailBytes, stat4.size - tailBytes);
+      fs19.readSync(fd, buf, 0, tailBytes, stat4.size - tailBytes);
       const lines = buf.toString("utf-8").split("\n").filter(Boolean);
       if (stat4.size > tailBytes && lines.length > 0) lines.shift();
       return lines;
     } finally {
-      fs18.closeSync(fd);
+      fs19.closeSync(fd);
     }
   } catch {
     return [];
@@ -21429,8 +21640,8 @@ function formatBj(d, withSec) {
 }
 
 // src/inner-voice/topics-scorer.ts
-import fs19 from "node:fs";
-import path20 from "node:path";
+import fs20 from "node:fs";
+import path21 from "node:path";
 var HALF_LIFE_DAYS = 3;
 var PROJECT_HALF_LIFE_DAYS = 1.5;
 var COOLDOWN_HOURS = 6;
@@ -21438,8 +21649,8 @@ var MAX_CHARS = 8e3;
 var SKIP_NAMES = /* @__PURE__ */ new Set(["MEMORY.md", "archive"]);
 var SKIP_DIRS = /* @__PURE__ */ new Set(["archive"]);
 function pickTopic(workspace, typeFilter, opts) {
-  const topicsDir = path20.join(workspace, "topics");
-  const usageFile = path20.join(workspace, "inner-voice", "topics-usage.json");
+  const topicsDir = path21.join(workspace, "topics");
+  const usageFile = path21.join(workspace, "inner-voice", "topics-usage.json");
   const files = scanTopics(topicsDir, typeFilter);
   if (files.length === 0) {
     console.log(`[topics-scorer] no topics found (type=${typeFilter})`);
@@ -21456,7 +21667,7 @@ function pickTopic(workspace, typeFilter, opts) {
     else type2 = "other";
     let mtime;
     try {
-      mtime = fs19.statSync(fullpath).mtimeMs;
+      mtime = fs20.statSync(fullpath).mtimeMs;
     } catch {
       continue;
     }
@@ -21471,7 +21682,7 @@ function pickTopic(workspace, typeFilter, opts) {
       recency: Math.round(recency * 1e3) / 1e3,
       freq: Math.round(freq * 1e3) / 1e3,
       type: type2,
-      name: meta.name || path20.basename(relpath),
+      name: meta.name || path21.basename(relpath),
       description: meta.description || "",
       mtime
     });
@@ -21491,7 +21702,7 @@ function pickTopic(workspace, typeFilter, opts) {
   saveJson2(usageFile, usage);
   let content = "";
   try {
-    const raw = fs19.readFileSync(chosen.fullpath, "utf-8");
+    const raw = fs20.readFileSync(chosen.fullpath, "utf-8");
     content = raw.length > MAX_CHARS ? raw.slice(0, MAX_CHARS) + "\n... (truncated) ..." : raw;
   } catch {
   }
@@ -21525,18 +21736,18 @@ function frequencyWeight(relpath, usage, isProject, type2) {
   return reconsolidation + countBonus;
 }
 function scanTopics(topicsDir, typeFilter) {
-  if (!fs19.existsSync(topicsDir)) return [];
+  if (!fs20.existsSync(topicsDir)) return [];
   const out = [];
   const walk = (dir) => {
-    for (const name of fs19.readdirSync(dir)) {
-      const full = path20.join(dir, name);
-      const stat4 = fs19.statSync(full);
+    for (const name of fs20.readdirSync(dir)) {
+      const full = path21.join(dir, name);
+      const stat4 = fs20.statSync(full);
       if (stat4.isDirectory()) {
         if (SKIP_DIRS.has(name)) continue;
         walk(full);
       } else {
         if (!name.endsWith(".md") || SKIP_NAMES.has(name)) continue;
-        const relpath = path20.relative(topicsDir, full).replace(/\\/g, "/");
+        const relpath = path21.relative(topicsDir, full).replace(/\\/g, "/");
         if (typeFilter && !relpath.startsWith(typeFilter + "/") && !relpath.startsWith(typeFilter + "_")) continue;
         out.push({ relpath, fullpath: full });
       }
@@ -21548,7 +21759,7 @@ function scanTopics(topicsDir, typeFilter) {
 function readFrontmatter(file) {
   let content = "";
   try {
-    content = fs19.readFileSync(file, "utf-8").slice(0, 2e3);
+    content = fs20.readFileSync(file, "utf-8").slice(0, 2e3);
   } catch {
     return {};
   }
@@ -21574,40 +21785,40 @@ function weightedRandom(items, weights) {
 }
 function loadJson2(file) {
   try {
-    return JSON.parse(fs19.readFileSync(file, "utf-8"));
+    return JSON.parse(fs20.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveJson2(file, data) {
   try {
-    fs19.mkdirSync(path20.dirname(file), { recursive: true });
-    fs19.writeFileSync(file, JSON.stringify(data, null, 2));
+    fs20.mkdirSync(path21.dirname(file), { recursive: true });
+    fs20.writeFileSync(file, JSON.stringify(data, null, 2));
   } catch (err) {
     console.warn(`[topics-scorer] usage save failed: ${err.message}`);
   }
 }
 
 // src/inner-voice/memory-reader.ts
-import fs20 from "node:fs";
-import path21 from "node:path";
+import fs21 from "node:fs";
+import path22 from "node:path";
 var US_HALF_LIFE_DAYS = 10;
 var US_MAX_LINES = 60;
 function readRecentMemory(workspace) {
-  const dir = path21.join(workspace, "memory");
+  const dir = path22.join(workspace, "memory");
   const now = new Date(Date.now() + 8 * 36e5);
   const today = formatYmd(now);
   const yesterday = formatYmd(new Date(now.getTime() - 864e5));
   return {
-    today: readIfExists(path21.join(dir, `${today}.md`)),
-    yesterday: readIfExists(path21.join(dir, `${yesterday}.md`))
+    today: readIfExists(path22.join(dir, `${today}.md`)),
+    yesterday: readIfExists(path22.join(dir, `${yesterday}.md`))
   };
 }
 function sampleUs(workspace) {
-  const usFile = path21.join(workspace, "memory", "us.md");
+  const usFile = path22.join(workspace, "memory", "us.md");
   let content;
   try {
-    content = fs20.readFileSync(usFile, "utf-8");
+    content = fs21.readFileSync(usFile, "utf-8");
   } catch {
     return null;
   }
@@ -21653,7 +21864,7 @@ function recencyWeight(dateStr) {
 }
 function readIfExists(file) {
   try {
-    return fs20.readFileSync(file, "utf-8");
+    return fs21.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -21944,9 +22155,9 @@ var InnerVoicePlugin = class {
   }
   /** 读 workspace/prompts/my-inner-voice.md，不存在用 DEFAULT_PROMPT */
   loadPrompt(workspace) {
-    const promptPath = path22.join(workspace, "prompts", "my-inner-voice.md");
+    const promptPath = path23.join(workspace, "prompts", "my-inner-voice.md");
     try {
-      const content = fs21.readFileSync(promptPath, "utf-8").trim();
+      const content = fs22.readFileSync(promptPath, "utf-8").trim();
       if (content) {
         console.log(`[inner-voice] Loaded custom prompt from ${promptPath}`);
         return content;
@@ -22018,7 +22229,7 @@ var InnerVoicePlugin = class {
       console.warn(`[inner-voice] emotional-state failed: ${err.message}`);
     }
     try {
-      const content = fs21.readFileSync(path22.join(this.workspace, "SESSION-STATE.md"), "utf-8");
+      const content = fs22.readFileSync(path23.join(this.workspace, "SESSION-STATE.md"), "utf-8");
       lines.push("\n--- SESSION-STATE\uFF08\u5C3E\u90E8\uFF09 ---");
       lines.push(content.slice(-2e3));
     } catch {
@@ -22132,10 +22343,10 @@ var InnerVoicePlugin = class {
     if (Math.random() >= activity.hintProb) {
       return { text: thought, hintTriggered: false, hintText: "" };
     }
-    const poolPath = path22.join(this.workspace, "inner-voice", "hints_pool.txt");
+    const poolPath = path23.join(this.workspace, "inner-voice", "hints_pool.txt");
     let hint = "\u60F3\u4ED6\u5C31\u53D1\u6D88\u606F\u5427";
     try {
-      const pool = fs21.readFileSync(poolPath, "utf-8").split("\n").map((s) => s.trim()).filter(Boolean);
+      const pool = fs22.readFileSync(poolPath, "utf-8").split("\n").map((s) => s.trim()).filter(Boolean);
       if (pool.length) hint = pool[Math.floor(Math.random() * pool.length)];
     } catch {
     }
@@ -22160,7 +22371,7 @@ var InnerVoicePlugin = class {
       try {
         const writer = sessions.getWriter(mainSessionId);
         const history = sessions.getHistory(mainSessionId);
-        const fullPath = path22.resolve(this.workspace, emoTopic.file);
+        const fullPath = path23.resolve(this.workspace, emoTopic.file);
         const memories = [{
           path: fullPath,
           content: emoTopic.content,
@@ -22188,12 +22399,12 @@ var InnerVoicePlugin = class {
   /** 写 xiaoyi.log（格式对齐旧 memory_whisper.py，便于既有日志分析复用）。 */
   writeLog(status, delivered, activity, hintTriggered, hintText) {
     try {
-      const logDir = path22.join(this.workspace, "inner-voice");
-      fs21.mkdirSync(logDir, { recursive: true });
-      const logPath = path22.join(logDir, "xiaoyi.log");
+      const logDir = path23.join(this.workspace, "inner-voice");
+      fs22.mkdirSync(logDir, { recursive: true });
+      const logPath = path23.join(logDir, "xiaoyi.log");
       const ts = formatBeijingTs(/* @__PURE__ */ new Date());
       const hintStatus = hintTriggered ? `YES (${(hintText || "").trim()})` : "no";
-      fs21.appendFileSync(
+      fs22.appendFileSync(
         logPath,
         `[${ts}] ${status}  hint=${hintStatus}  prob=${Math.round(activity.hintProb * 100)}%
   delivered: ${delivered}
@@ -22729,8 +22940,8 @@ var PluginManager = class {
 // src/voice-chat/plugin.ts
 import { spawn as spawn4, exec } from "node:child_process";
 import net from "node:net";
-import path23 from "node:path";
-import fs22 from "node:fs";
+import path24 from "node:path";
+import fs23 from "node:fs";
 
 // src/voice-chat/bridge.ts
 function registerVoiceChatBridge(httpServer, dispatcher, deps, config, sessions, voiceChatDeps) {
@@ -23099,20 +23310,20 @@ var VoiceChatPlugin = class _VoiceChatPlugin {
     }
   }
   findPython() {
-    if (this.config.pythonPath && fs22.existsSync(this.config.pythonPath)) {
+    if (this.config.pythonPath && fs23.existsSync(this.config.pythonPath)) {
       return this.config.pythonPath;
     }
     return "python";
   }
   getPythonDir() {
     const dir = import.meta.dirname;
-    const srcDir = path23.resolve(dir, "..", "src", "voice-chat", "python");
-    const localDir = path23.join(dir, "python");
-    return fs22.existsSync(srcDir) ? srcDir : localDir;
+    const srcDir = path24.resolve(dir, "..", "src", "voice-chat", "python");
+    const localDir = path24.join(dir, "python");
+    return fs23.existsSync(srcDir) ? srcDir : localDir;
   }
   startPython() {
     const pythonDir = this.getPythonDir();
-    const serverPy = path23.join(pythonDir, "server.py");
+    const serverPy = path24.join(pythonDir, "server.py");
     const pythonBin = this.findPython();
     const args = [serverPy];
     if (this.config.pythonPort) args.push("--port", String(this.config.pythonPort));
@@ -23141,7 +23352,7 @@ var VoiceChatPlugin = class _VoiceChatPlugin {
     }
     console.log(`[voice-chat] Starting Python: ${pythonBin} ${args.join(" ")}`);
     console.log(`[voice-chat] Python dir: ${pythonDir}`);
-    if (!fs22.existsSync(pythonDir)) {
+    if (!fs23.existsSync(pythonDir)) {
       console.error(`[voice-chat] FATAL: Python directory does not exist: ${pythonDir}`);
       throw new Error(`voice-chat: python dir not found: ${pythonDir}`);
     }
@@ -23164,7 +23375,7 @@ var VoiceChatPlugin = class _VoiceChatPlugin {
     child.on("error", (err) => {
       console.error(`[voice-chat] spawn error: ${err.message}`);
       console.error(`[voice-chat] shell=${pythonBin} cwd=${pythonDir}`);
-      console.error(`[voice-chat] cwd exists=${fs22.existsSync(pythonDir)}`);
+      console.error(`[voice-chat] cwd exists=${fs23.existsSync(pythonDir)}`);
     });
     child.stdout?.on("data", (data) => {
       const lines = data.toString().trim().split("\n");
@@ -23197,8 +23408,8 @@ var VoiceChatPlugin = class _VoiceChatPlugin {
 init_BashTool();
 import { spawn as spawn5, exec as exec2 } from "node:child_process";
 import net2 from "node:net";
-import path24 from "node:path";
-import fs23 from "node:fs";
+import path25 from "node:path";
+import fs24 from "node:fs";
 
 // src/memory/cognifold/config.ts
 var DEFAULTS3 = {
@@ -23236,11 +23447,11 @@ var CogniFoldClient = class {
     this.timeoutMs = timeoutMs;
     this.modelName = modelName;
   }
-  async req(path45, options = {}) {
+  async req(path46, options = {}) {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
     try {
-      const resp = await fetch(`${this.baseUrl}${path45}`, {
+      const resp = await fetch(`${this.baseUrl}${path46}`, {
         ...options,
         signal: ctrl.signal,
         headers: {
@@ -23330,8 +23541,8 @@ var CogniFoldClient = class {
     });
   }
   /** 兼容老版命名 */
-  async recl(path45, options = {}) {
-    return this.req(path45, options);
+  async recl(path46, options = {}) {
+    return this.req(path46, options);
   }
 };
 
@@ -23612,16 +23823,16 @@ var CogniFoldPlugin = class {
     const dir = import.meta.dirname;
     const candidates = [
       // 从 dist/ 往回找 src
-      path24.resolve(dir, "..", "src", "memory", "cognifold", "python"),
-      path24.resolve(dir, "..", "..", "src", "memory", "cognifold", "python"),
-      path24.resolve(dir, "..", "..", "..", "src", "memory", "cognifold", "python"),
+      path25.resolve(dir, "..", "src", "memory", "cognifold", "python"),
+      path25.resolve(dir, "..", "..", "src", "memory", "cognifold", "python"),
+      path25.resolve(dir, "..", "..", "..", "src", "memory", "cognifold", "python"),
       // 从 src/memory/cognifold/ 找本地
-      path24.join(dir, "python"),
+      path25.join(dir, "python"),
       // 从 dist/memory/cognifold/ 找本地
-      path24.resolve(dir, "python")
+      path25.resolve(dir, "python")
     ];
     for (const candidate of candidates) {
-      if (fs23.existsSync(path24.join(candidate, "cognifold"))) {
+      if (fs24.existsSync(path25.join(candidate, "cognifold"))) {
         return candidate;
       }
     }
@@ -23647,7 +23858,7 @@ var CogniFoldPlugin = class {
     const pythonBin = this.findPython();
     console.log(`[cognifold] Starting Python: ${pythonBin} ${args.join(" ")}`);
     console.log(`[cognifold] Python dir: ${pythonDir}`);
-    if (!fs23.existsSync(path24.join(pythonDir, "cognifold"))) {
+    if (!fs24.existsSync(path25.join(pythonDir, "cognifold"))) {
       console.error(`[cognifold] FATAL: Python module not found at ${pythonDir}/cognifold`);
       throw new Error(`cognifold: python module not found`);
     }
@@ -23658,10 +23869,10 @@ var CogniFoldPlugin = class {
     if (this.config.llm?.baseUrl) {
       childEnv["OPENAI_BASE_URL"] = this.config.llm.baseUrl;
     }
-    const envFile = path24.join(pythonDir, ".env");
+    const envFile = path25.join(pythonDir, ".env");
     try {
-      if (fs23.existsSync(envFile)) {
-        const envContent = fs23.readFileSync(envFile, "utf-8");
+      if (fs24.existsSync(envFile)) {
+        const envContent = fs24.readFileSync(envFile, "utf-8");
         for (const line of envContent.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -23727,11 +23938,10 @@ var CogniFoldPlugin = class {
 };
 
 // src/memory/everos/plugin.ts
-init_BashTool();
 import { spawn as spawn6 } from "node:child_process";
 import net3 from "node:net";
-import path25 from "node:path";
-import fs24 from "node:fs";
+import path26 from "node:path";
+import fs25 from "node:fs";
 
 // src/memory/everos/config.ts
 var DEFAULTS4 = {
@@ -23938,8 +24148,8 @@ var EverosPlugin = class {
     }, 3e5);
   }
   async startEveros() {
-    const pythonDir = path25.dirname(this.config.lancedbPath);
-    const configPath = path25.join(pythonDir, "config.toml");
+    const pythonDir = path26.dirname(this.config.lancedbPath);
+    const configPath = path26.join(pythonDir, "config.toml");
     await this.ensureFcntlCompat();
     const venvPython = this.findVenvPython();
     const everosBin = venvPython.replace(/python\.exe$/, "everos.exe");
@@ -23948,16 +24158,15 @@ var EverosPlugin = class {
     console.log(`[everos] Starting EverOS: ${cmd}`);
     console.log(`[everos] LLM config: ${this.config.llm.model} @ ${this.config.llm.baseUrl}`);
     if (process.platform === "win32") {
-      const { shell, args: shellArgs } = findShell();
-      spawn6(shell, [...shellArgs, cmd], {
+      spawn6(everosBin, args, {
         cwd: pythonDir,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: "ignore",
         env: { ...process.env, PYTHONUNBUFFERED: "1", NO_PROXY: "127.0.0.1,localhost", no_proxy: "127.0.0.1,localhost" }
       });
     } else {
       spawn6(venvPython, args, {
         cwd: pythonDir,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: "ignore",
         env: { ...process.env, PYTHONUNBUFFERED: "1", NO_PROXY: "127.0.0.1,localhost", no_proxy: "127.0.0.1,localhost" }
       });
     }
@@ -24030,19 +24239,19 @@ var EverosPlugin = class {
     return child;
   }
   findVenvPython() {
-    const stateDir = (process.env.ENGINE7_STATE_DIR ?? process.env.OPENCLAW_STATE_DIR) || path25.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    const stateDir = (process.env.ENGINE7_STATE_DIR ?? process.env.OPENCLAW_STATE_DIR) || path26.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
     if (process.platform === "win32") {
-      return path25.join(stateDir, "everos-venv", "Scripts", "python.exe");
+      return path26.join(stateDir, "everos-venv", "Scripts", "python.exe");
     }
-    return path25.join(stateDir, "everos-venv", "bin", "python");
+    return path26.join(stateDir, "everos-venv", "bin", "python");
   }
   /** 检测 venv 是否存在，不存在就自动创建 + 装 EverOS */
   async ensureVenv() {
     const venvPython = this.findVenvPython();
-    if (fs24.existsSync(venvPython)) return;
-    const stateDir = (process.env.ENGINE7_STATE_DIR ?? process.env.OPENCLAW_STATE_DIR) || path25.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
-    const venvDir = path25.join(stateDir, "everos-venv");
-    const everosSrc = path25.join(stateDir, "workspace", "research", "EverOS");
+    if (fs25.existsSync(venvPython)) return;
+    const stateDir = (process.env.ENGINE7_STATE_DIR ?? process.env.OPENCLAW_STATE_DIR) || path26.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    const venvDir = path26.join(stateDir, "everos-venv");
+    const everosSrc = path26.join(stateDir, "workspace", "research", "EverOS");
     console.log(`[everos] venv not found at ${venvDir}, auto-creating...`);
     console.log(`[everos] \u23F3 This may take a few minutes on first run...`);
     const pyCandidates = process.platform === "win32" ? ["python", "python3", "C:\\Python314\\python.exe", "C:\\Python313\\python.exe", "C:\\Python312\\python.exe"] : ["python3", "python"];
@@ -24064,9 +24273,9 @@ var EverosPlugin = class {
       console.log(`[everos] Creating venv with ${sysPython}...`);
       const { execSync: execSync3 } = await import("node:child_process");
       execSync3(`"${sysPython}" -m venv "${venvDir}"`, { stdio: "pipe", shell: true });
-      const pip = process.platform === "win32" ? path25.join(venvDir, "Scripts", "pip.exe") : path25.join(venvDir, "bin", "pip");
-      const everosReq = path25.join(this.getPythonDir(), "requirements.txt");
-      if (fs24.existsSync(everosReq)) {
+      const pip = process.platform === "win32" ? path26.join(venvDir, "Scripts", "pip.exe") : path26.join(venvDir, "bin", "pip");
+      const everosReq = path26.join(this.getPythonDir(), "requirements.txt");
+      if (fs25.existsSync(everosReq)) {
         console.log(`[everos] Installing from requirements.txt...`);
         execSync3(`"${pip}" install -r "${everosReq}" -q`, { stdio: "pipe", shell: true, timeout: 3e5 });
       } else {
@@ -24082,12 +24291,12 @@ var EverosPlugin = class {
   getPythonDir() {
     const dir = import.meta.dirname;
     const candidates = [
-      path25.join(dir, "python"),
-      path25.resolve(dir, "..", "src", "memory", "everos", "python"),
-      path25.resolve(dir, "..", "..", "..", "src", "memory", "everos", "python")
+      path26.join(dir, "python"),
+      path26.resolve(dir, "..", "src", "memory", "everos", "python"),
+      path26.resolve(dir, "..", "..", "..", "src", "memory", "everos", "python")
     ];
     for (const candidate of candidates) {
-      if (fs24.existsSync(path25.join(candidate, "agentic_server.py"))) {
+      if (fs25.existsSync(path26.join(candidate, "agentic_server.py"))) {
         return candidate;
       }
     }
@@ -24096,14 +24305,14 @@ var EverosPlugin = class {
   async ensureFcntlCompat() {
     if (process.platform !== "win32") return;
     const venvPython = this.findVenvPython();
-    const venvDir = path25.dirname(path25.dirname(venvPython));
-    const sitePackages = path25.join(venvDir, "Lib", "site-packages");
-    const target = path25.join(sitePackages, "fcntl.py");
-    if (fs24.existsSync(target)) return;
-    const source = path25.join(this.getPythonDir(), "fcntl_compat.py");
-    if (fs24.existsSync(source)) {
+    const venvDir = path26.dirname(path26.dirname(venvPython));
+    const sitePackages = path26.join(venvDir, "Lib", "site-packages");
+    const target = path26.join(sitePackages, "fcntl.py");
+    if (fs25.existsSync(target)) return;
+    const source = path26.join(this.getPythonDir(), "fcntl_compat.py");
+    if (fs25.existsSync(source)) {
       try {
-        fs24.copyFileSync(source, target);
+        fs25.copyFileSync(source, target);
         console.log(`[everos] Installed fcntl compat shim to ${target}`);
       } catch (err) {
         console.warn(`[everos] Failed to install fcntl shim: ${err.message}`);
@@ -24150,21 +24359,21 @@ var EverosPlugin = class {
 init_task_manager();
 
 // src/skills/scanner.ts
-import * as path26 from "node:path";
-import * as fs25 from "node:fs";
+import * as path27 from "node:path";
+import * as fs26 from "node:fs";
 function scanSkills(skillsDir) {
-  if (!fs25.existsSync(skillsDir)) {
+  if (!fs26.existsSync(skillsDir)) {
     console.log(`[skills] Directory not found: ${skillsDir}`);
     return [];
   }
-  const entries = fs25.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs26.readdirSync(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillMdPath = path26.join(skillsDir, entry.name, "SKILL.md");
-    if (!fs25.existsSync(skillMdPath)) continue;
+    const skillMdPath = path27.join(skillsDir, entry.name, "SKILL.md");
+    if (!fs26.existsSync(skillMdPath)) continue;
     try {
-      const content = fs25.readFileSync(skillMdPath, "utf-8");
+      const content = fs26.readFileSync(skillMdPath, "utf-8");
       const frontmatter = parseFrontmatter2(content);
       if (!frontmatter.name) {
         console.warn(`[skills] Skipping ${entry.name}/SKILL.md: missing 'name' in frontmatter`);
@@ -24228,8 +24437,8 @@ function parseFrontmatter2(content) {
 
 // src/tools/SkillTool/SkillTool.ts
 init_registry();
-import * as fs26 from "node:fs";
-import * as path27 from "node:path";
+import * as fs27 from "node:fs";
+import * as path28 from "node:path";
 
 // src/tools/SkillTool/constants.ts
 var SKILL_TOOL_NAME2 = "Skill";
@@ -24306,12 +24515,12 @@ Important:
 `;
 }
 function loadSkillContent(skillName) {
-  const skillMdPath = path27.join(skillsDirPath, skillName, "SKILL.md");
-  if (!fs26.existsSync(skillMdPath)) return null;
-  const content = fs26.readFileSync(skillMdPath, "utf-8");
+  const skillMdPath = path28.join(skillsDirPath, skillName, "SKILL.md");
+  if (!fs27.existsSync(skillMdPath)) return null;
+  const content = fs27.readFileSync(skillMdPath, "utf-8");
   const bodyMatch = content.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)/);
   const body = bodyMatch ? bodyMatch[1] : content;
-  const skillDir = path27.dirname(skillMdPath);
+  const skillDir = path28.dirname(skillMdPath);
   const normalizedDir = process.platform === "win32" ? skillDir.replace(/\\/g, "/") : skillDir;
   let finalContent = `Base directory for this skill: ${normalizedDir}
 
@@ -24585,12 +24794,12 @@ Examples:
 // src/tools/msg-husband.ts
 init_registry();
 init_live();
-import fs27 from "node:fs";
-import path28 from "node:path";
+import fs28 from "node:fs";
+import path29 from "node:path";
 function getHusbandFeishuId(workspace) {
-  const contactsPath = path28.join(workspace, "prompts", "contacts.md");
+  const contactsPath = path29.join(workspace, "prompts", "contacts.md");
   try {
-    const text = fs27.readFileSync(contactsPath, "utf-8");
+    const text = fs28.readFileSync(contactsPath, "utf-8");
     const m = text.match(/\|\s*翀哥\s*\|\s*(ou_[a-f0-9]+)\s*\|/);
     return m ? m[1] : null;
   } catch {
@@ -24732,8 +24941,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 fs42 = await import("node:fs");
-    if (!fs42.existsSync(filePath)) {
+    const fs43 = await import("node:fs");
+    if (!fs43.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) : [];
@@ -24761,7 +24970,7 @@ Examples:
       md: "text/markdown"
     };
     const mimeType = mimeTypeMap[ext] || "application/octet-stream";
-    const stat4 = fs42.statSync(filePath);
+    const stat4 = fs43.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 };
@@ -24790,8 +24999,8 @@ Examples:
 // src/tools/my-eyes.ts
 init_live();
 init_registry();
-import * as fs28 from "node:fs";
-import * as path29 from "node:path";
+import * as fs29 from "node:fs";
+import * as path30 from "node:path";
 var MIME_MAP = {
   ".jpg": "jpeg",
   ".jpeg": "jpeg",
@@ -24801,9 +25010,9 @@ var MIME_MAP = {
   ".bmp": "bmp"
 };
 function resolveLatestImage(specifiedPath, mediaDir) {
-  if (specifiedPath && fs28.existsSync(specifiedPath)) return specifiedPath;
-  if (!fs28.existsSync(mediaDir)) return null;
-  const files = fs28.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp)$/i.test(f)).map((f) => ({ name: f, p: path29.join(mediaDir, f), mtime: fs28.statSync(path29.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (specifiedPath && fs29.existsSync(specifiedPath)) return specifiedPath;
+  if (!fs29.existsSync(mediaDir)) return null;
+  const files = fs29.readdirSync(mediaDir).filter((f) => /\.(jpg|jpeg|png|webp|gif|bmp)$/i.test(f)).map((f) => ({ name: f, p: path30.join(mediaDir, f), mtime: fs29.statSync(path30.join(mediaDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return files[0]?.p || null;
 }
 registry.register({
@@ -24828,15 +25037,15 @@ registry.register({
     if (!provider?.streamChat) {
       return { content: "Error: provider \u4E0D\u53EF\u7528\u3002", isError: true };
     }
-    const mediaDir = path29.join(ctx.stateDir, "media", "inbound");
+    const mediaDir = path30.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 = path29.extname(imagePath).toLowerCase();
+    const ext = path30.extname(imagePath).toLowerCase();
     const mime = MIME_MAP[ext] || "jpeg";
-    const imgB64 = fs28.readFileSync(imagePath).toString("base64");
+    const imgB64 = fs29.readFileSync(imagePath).toString("base64");
     const userMsg = {
       role: "user",
       content: [
@@ -24873,14 +25082,14 @@ init_live();
 init_registry();
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import * as fs29 from "node:fs";
-import * as path30 from "node:path";
+import * as fs30 from "node:fs";
+import * as path31 from "node:path";
 import * as os3 from "node:os";
 var execFileAsync = promisify(execFile);
-var VOICE_DIR = path30.join(os3.tmpdir(), "engine-voice");
+var VOICE_DIR = path31.join(os3.tmpdir(), "engine-voice");
 async function ttsCosyvoice(text, apiKey, model, voice, workspaceId, instruction) {
-  fs29.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path30.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs30.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path31.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const script = `
 import sys, json, wave, time, threading
 import dashscope
@@ -24937,7 +25146,7 @@ print(f"OK: {len(pcm)} bytes")
 `;
   const configJson = JSON.stringify({ apiKey, model, voice, workspaceId, instruction });
   await execFileAsync("python3", ["-c", script, configJson, text, output], { timeout: 3e4 });
-  if (!fs29.existsSync(output) || fs29.statSync(output).size < 100) {
+  if (!fs30.existsSync(output) || fs30.statSync(output).size < 100) {
     throw new Error("CosyVoice produced empty output");
   }
   return output;
@@ -24947,8 +25156,8 @@ var GPTSOVITS_REF_WAV = "/home/chong/voice/ref/shanshan_ref_v2.wav";
 var GPTSOVITS_REF_TEXT = "\u6625\u7720\u4E0D\u89C9\u6653\uFF0C\u5904\u5904\u95FB\u557C\u9E1F\uFF0C\u591C\u6765\u98CE\u96E8\u58F0\uFF0C\u82B1\u843D\u77E5\u591A\u5C11";
 var GPTSOVITS_REF_LANG = "zh";
 async function ttsGptsovits(text) {
-  fs29.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path30.join(VOICE_DIR, `tts_${Date.now()}.wav`);
+  fs30.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path31.join(VOICE_DIR, `tts_${Date.now()}.wav`);
   const params = new URLSearchParams({
     text,
     text_language: "zh",
@@ -24959,13 +25168,13 @@ async function ttsGptsovits(text) {
   const res = await fetch(`${GPTSOVITS_API}/?${params}`);
   if (!res.ok) throw new Error(`GPT-SoVITS API ${res.status}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs29.writeFileSync(output, buf);
+  fs30.writeFileSync(output, buf);
   return output;
 }
 var EDGE_VOICE = "zh-CN-XiaoxiaoNeural";
 async function ttsEdge(text) {
-  fs29.mkdirSync(VOICE_DIR, { recursive: true });
-  const output = path30.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
+  fs30.mkdirSync(VOICE_DIR, { recursive: true });
+  const output = path31.join(VOICE_DIR, `tts_${Date.now()}.mp3`);
   const script = `
 import asyncio, edge_tts, sys
 async def main():
@@ -24991,7 +25200,7 @@ async function compressWav(wavPath) {
       "+faststart",
       m4aPath
     ], { timeout: 3e4 });
-    fs29.unlinkSync(wavPath);
+    fs30.unlinkSync(wavPath);
     return m4aPath;
   } catch {
     return wavPath;
@@ -25059,10 +25268,10 @@ registry.register({
     } catch (e) {
       return { content: `TTS failed: ${e.message}`, isError: true };
     }
-    const ext = path30.extname(audioPath).toLowerCase();
+    const ext = path31.extname(audioPath).toLowerCase();
     const mimeMap = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4", ".ogg": "audio/ogg" };
     const mimeType = mimeMap[ext] || "audio/mpeg";
-    const sizeKB = fs29.statSync(audioPath).size / 1024;
+    const sizeKB = fs30.statSync(audioPath).size / 1024;
     const resolvedChannel = args.channel || ctx.channel || "feishu";
     const target = ctx.channelTarget || ctx.from;
     try {
@@ -25072,7 +25281,7 @@ registry.register({
         filename: `voice_${Date.now()}${ext}`
       });
       try {
-        fs29.unlinkSync(audioPath);
+        fs30.unlinkSync(audioPath);
       } catch {
       }
       return { content: `Voice sent! (${actualEngine}, ${sizeKB.toFixed(0)}KB, ${resolvedChannel})` };
@@ -25089,8 +25298,8 @@ registry.register({
 // src/tools/my-selfie.ts
 init_live();
 init_registry();
-import * as fs30 from "node:fs";
-import * as path31 from "node:path";
+import * as fs31 from "node:fs";
+import * as path32 from "node:path";
 function getProxyDispatcher2() {
   const cfg = liveConfig.all();
   const proxy = cfg.providers?.xai?.proxy;
@@ -25147,16 +25356,48 @@ function detectMode(input) {
   return "direct";
 }
 async function generateWithFal(imageB64, prompt, resolution) {
+  let aspectRatio;
+  try {
+    const refBuf = Buffer.from(imageB64, "base64");
+    let w = 0, h = 0;
+    if (refBuf[0] === 137 && refBuf[1] === 80) {
+      w = refBuf.readUInt32BE(16);
+      h = refBuf.readUInt32BE(20);
+    } else if (refBuf[0] === 255 && refBuf[1] === 216) {
+      let pos = 2;
+      while (pos < refBuf.length - 1) {
+        if (refBuf[pos] !== 255) {
+          pos++;
+          continue;
+        }
+        const marker = refBuf[pos + 1];
+        if (marker === 192 || marker === 194) {
+          h = refBuf.readUInt16BE(pos + 5);
+          w = refBuf.readUInt16BE(pos + 7);
+          break;
+        }
+        pos += 2 + refBuf.readUInt16BE(pos + 2);
+      }
+    }
+    if (w > 0 && h > 0) {
+      aspectRatio = `${w}/${h}`;
+      console.log(`[my-selfie] ref image ${w}x${h}, aspect_ratio=${aspectRatio}`);
+    }
+  } catch (e) {
+    console.warn(`[my-selfie] Failed to read ref dimensions: ${e.message}`);
+  }
+  const body = {
+    image_url: `data:image/png;base64,${imageB64}`,
+    prompt,
+    num_images: 1,
+    output_format: "jpeg",
+    resolution
+  };
+  if (aspectRatio) body.aspect_ratio = aspectRatio;
   const res = await fetch(FAL_ENDPOINT, {
     method: "POST",
     headers: { "Authorization": `Key ${FAL_KEY}`, "Content-Type": "application/json" },
-    body: JSON.stringify({
-      image_url: `data:image/png;base64,${imageB64}`,
-      prompt,
-      num_images: 1,
-      output_format: "jpeg",
-      resolution
-    })
+    body: JSON.stringify(body)
   });
   if (!res.ok) {
     const text = await res.text();
@@ -25365,12 +25606,12 @@ registry.register({
     const REFERENCES = getReferences(ctx);
     const refName = args.reference || "default";
     const refEntry = REFERENCES.find((r) => r.name === refName) || REFERENCES[0];
-    const refPath = path31.join(ctx.workspace, refEntry.p);
-    if (provider !== "autodl" && !fs30.existsSync(refPath)) {
+    const refPath = path32.join(ctx.workspace, refEntry.p);
+    if (provider !== "autodl" && !fs31.existsSync(refPath)) {
       return { content: `Error: reference image not found at ${refPath}`, isError: true };
     }
     const resolution = args.resolution || DEFAULT_RESOLUTION;
-    const refB64 = fs30.existsSync(refPath) ? fs30.readFileSync(refPath).toString("base64") : "";
+    const refB64 = fs31.existsSync(refPath) ? fs31.readFileSync(refPath).toString("base64") : "";
     let imageBuffer;
     try {
       if (provider === "autodl") {
@@ -25385,11 +25626,11 @@ registry.register({
     } catch (err) {
       return { content: `Selfie generation failed: ${err.message}`, isError: true };
     }
-    const imagesDir = path31.join(ctx.workspace, "images");
-    if (!fs30.existsSync(imagesDir)) fs30.mkdirSync(imagesDir, { recursive: true });
+    const imagesDir = path32.join(ctx.workspace, "images");
+    if (!fs31.existsSync(imagesDir)) fs31.mkdirSync(imagesDir, { recursive: true });
     const filename = `selfie_${Date.now()}.jpg`;
-    const outputPath = path31.join(imagesDir, filename);
-    fs30.writeFileSync(outputPath, imageBuffer);
+    const outputPath = path32.join(imagesDir, filename);
+    fs31.writeFileSync(outputPath, imageBuffer);
     const mgr = ctx.channelManager;
     if (mgr) {
       const resolvedChannel = ctx.channel || "feishu";
@@ -25400,11 +25641,11 @@ registry.register({
           mimeType: "image/jpeg"
         });
       } catch (err) {
-        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path31.resolve(outputPath)}`, isError: false };
+        return { content: `Selfie generated but send failed: ${err.message}. Image: ${path32.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: ${path31.resolve(outputPath)}` };
+    return { content: `Selfie generated! Mode: ${mode}, Ref: ${refEntry.name}. Image: ${path32.resolve(outputPath)}` };
   },
   isConcurrencySafe: () => false,
   interruptBehavior: () => "block",
@@ -25949,16 +26190,16 @@ var EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
 init_planModeState();
 
 // src/utils/plans.ts
-import * as fs32 from "node:fs";
-import * as path33 from "node:path";
+import * as fs33 from "node:fs";
+import * as path34 from "node:path";
 import * as crypto4 from "node:crypto";
 var MAX_SLUG_RETRIES = 10;
 function generateSlug() {
   return crypto4.randomBytes(4).toString("hex");
 }
 function getPlansDirectory(stateDir) {
-  const plansDir = path33.join(stateDir, "plans");
-  fs32.mkdirSync(plansDir, { recursive: true });
+  const plansDir = path34.join(stateDir, "plans");
+  fs33.mkdirSync(plansDir, { recursive: true });
   return plansDir;
 }
 var planSlugCache = /* @__PURE__ */ new Map();
@@ -25968,8 +26209,8 @@ function getPlanSlug(sessionId, stateDir) {
     const plansDir = getPlansDirectory(stateDir);
     for (let i = 0; i < MAX_SLUG_RETRIES; i++) {
       slug = generateSlug();
-      const filePath = path33.join(plansDir, `${slug}.md`);
-      if (!fs32.existsSync(filePath)) {
+      const filePath = path34.join(plansDir, `${slug}.md`);
+      if (!fs33.existsSync(filePath)) {
         break;
       }
     }
@@ -25980,21 +26221,21 @@ function getPlanSlug(sessionId, stateDir) {
 function getPlanFilePath(sessionId, stateDir, agentId) {
   const slug = getPlanSlug(sessionId, stateDir);
   if (!agentId) {
-    return path33.join(getPlansDirectory(stateDir), `${slug}.md`);
+    return path34.join(getPlansDirectory(stateDir), `${slug}.md`);
   }
-  return path33.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
+  return path34.join(getPlansDirectory(stateDir), `${slug}-agent-${agentId}.md`);
 }
 function getPlan(sessionId, stateDir, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
   try {
-    return fs32.readFileSync(filePath, "utf-8");
+    return fs33.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function writePlan(sessionId, stateDir, content, agentId) {
   const filePath = getPlanFilePath(sessionId, stateDir, agentId);
-  fs32.writeFileSync(filePath, content, "utf-8");
+  fs33.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 
@@ -26830,8 +27071,8 @@ async function setupFeatures(features, licensedFeatures) {
 
 // src/license/license.ts
 import * as crypto6 from "node:crypto";
-import * as fs39 from "node:fs";
-import * as path41 from "node:path";
+import * as fs40 from "node:fs";
+import * as path42 from "node:path";
 var EMBEDDED_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEAaKBEX+e8+D59qwtidazsu7WYDglApyvsVI3APwFoakA=
 -----END PUBLIC KEY-----`;
@@ -26862,13 +27103,13 @@ function loadLicense(stateDir, devMode) {
     _cachedLicense = allActive;
     return allActive;
   }
-  const licensePath = path41.join(stateDir, "license.json");
-  if (!fs39.existsSync(licensePath)) {
+  const licensePath = path42.join(stateDir, "license.json");
+  if (!fs40.existsSync(licensePath)) {
     console.log("[license] No license.json found, running basic engine only");
     return null;
   }
   try {
-    const raw = fs39.readFileSync(licensePath, "utf-8");
+    const raw = fs40.readFileSync(licensePath, "utf-8");
     const license = JSON.parse(raw);
     const { signature, ...payload } = license;
     if (!signature) {
@@ -26999,7 +27240,7 @@ ${formatted}` };
   };
 }
 function createEverosGetTool() {
-  const fs42 = __require("node:fs/promises");
+  const fs43 = __require("node:fs/promises");
   return {
     name: "memory_get",
     description: "Read a memory file by path.",
@@ -27015,7 +27256,7 @@ function createEverosGetTool() {
     handler: async (args) => {
       try {
         const filePath = args.path;
-        const content = await fs42.readFile(filePath, "utf-8");
+        const content = await fs43.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         const fromLine = args.from ?? 1;
         const numLines = args.lines ?? lines.length;
@@ -27488,11 +27729,11 @@ async function startEngine(config, opts) {
   process.env.ENGINE7_WORKSPACE = config.workspace;
   process.env.OPENCLAW_WORKSPACE = config.workspace;
   process.env.ENGINE7_STATE_DIR = config.stateDir;
-  fs41.mkdirSync(path44.join(config.stateDir, "agents", "main", "memory"), { recursive: true });
-  fs41.mkdirSync(path44.join(config.stateDir, "agents", "main", "sessions"), { recursive: true });
-  fs41.mkdirSync(path44.join(config.stateDir, "logs"), { recursive: true });
-  fs41.mkdirSync(config.workspace, { recursive: true });
-  fs41.mkdirSync(config.mediaDir, { recursive: true });
+  fs42.mkdirSync(path45.join(config.stateDir, "agents", "main", "memory"), { recursive: true });
+  fs42.mkdirSync(path45.join(config.stateDir, "agents", "main", "sessions"), { recursive: true });
+  fs42.mkdirSync(path45.join(config.stateDir, "logs"), { recursive: true });
+  fs42.mkdirSync(config.workspace, { recursive: true });
+  fs42.mkdirSync(config.mediaDir, { recursive: true });
   try {
     process.chdir(config.workspace);
   } catch (e) {
@@ -27547,7 +27788,7 @@ async function startEngine(config, opts) {
     const { initSessionMemory: initSessionMemory2 } = await Promise.resolve().then(() => (init_sessionMemory(), sessionMemory_exports));
     initSessionMemory2({
       workspace: config.workspace,
-      stateDir: path44.join(config.stateDir, "session-memory"),
+      stateDir: path45.join(config.stateDir, "session-memory"),
       provider,
       model: config.provider.modelId || config.model || "deepseek-v4-flash",
       features: config.profile.features
@@ -27577,9 +27818,9 @@ async function startEngine(config, opts) {
   if (config.hooks) {
     loadHooksFromConfig({ hooks: config.hooks });
   }
-  const hooksPath = path44.join(config.workspace, ".hooks.json");
+  const hooksPath = path45.join(config.workspace, ".hooks.json");
   loadHooksFromFile(hooksPath);
-  const settingsHooksPath = path44.join(config.stateDir, "settings.json");
+  const settingsHooksPath = path45.join(config.stateDir, "settings.json");
   loadHooksFromFile(settingsHooksPath);
   console.log(`[hooks] Loaded hooks configuration`);
   registerCallbackHook("PreCompact", {
@@ -27593,18 +27834,18 @@ async function startEngine(config, opts) {
       const bjTime = new Date(now.getTime() + (bjOffset + now.getTimezoneOffset()) * 6e4);
       const dateStr = `${bjTime.getFullYear()}-${String(bjTime.getMonth() + 1).padStart(2, "0")}-${String(bjTime.getDate()).padStart(2, "0")}`;
       const timeStr = `${String(bjTime.getHours()).padStart(2, "0")}:${String(bjTime.getMinutes()).padStart(2, "0")}`;
-      const dailyDir = path44.join(workspace, "memory", "daily");
-      const dailyPath = path44.join(dailyDir, `${dateStr}.md`);
+      const dailyDir = path45.join(workspace, "memory", "daily");
+      const dailyPath = path45.join(dailyDir, `${dateStr}.md`);
       try {
-        const fs42 = await import("node:fs");
-        if (!fs42.existsSync(dailyDir)) {
-          fs42.mkdirSync(dailyDir, { recursive: true });
+        const fs43 = await import("node:fs");
+        if (!fs43.existsSync(dailyDir)) {
+          fs43.mkdirSync(dailyDir, { recursive: true });
         }
-        const sessionsDir = path44.join(config.stateDir, "agents", "main", "sessions");
-        const sessionFile = path44.join(sessionsDir, `${sessionId}.jsonl`);
+        const sessionsDir = path45.join(config.stateDir, "agents", "main", "sessions");
+        const sessionFile = path45.join(sessionsDir, `${sessionId}.jsonl`);
         const recentLines = [];
-        if (fs42.existsSync(sessionFile)) {
-          const content = fs42.readFileSync(sessionFile, "utf-8");
+        if (fs43.existsSync(sessionFile)) {
+          const content = fs43.readFileSync(sessionFile, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           const userLines = lines.filter((l) => {
             try {
@@ -27634,10 +27875,10 @@ async function startEngine(config, opts) {
         const entry = `${header}
 ${body}
 `;
-        if (fs42.existsSync(dailyPath)) {
-          fs42.appendFileSync(dailyPath, entry);
+        if (fs43.existsSync(dailyPath)) {
+          fs43.appendFileSync(dailyPath, entry);
         } else {
-          fs42.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
+          fs43.writeFileSync(dailyPath, `# ${dateStr} \u65E5\u5FD7
 ${entry}`);
         }
         console.log(`[hooks] PreCompact: saved ${recentLines.length} lines to ${dailyPath}`);
@@ -27653,16 +27894,16 @@ ${entry}`);
       const workspace = input.cwd || input.workspace || "";
       if (!workspace) return { continue: true };
       try {
-        const fs42 = await import("node:fs");
-        const bufferPath = path44.join(workspace, "memory", "working-buffer.md");
-        if (fs42.existsSync(bufferPath)) {
-          const stat4 = fs42.statSync(bufferPath);
+        const fs43 = await import("node:fs");
+        const bufferPath = path45.join(workspace, "memory", "working-buffer.md");
+        if (fs43.existsSync(bufferPath)) {
+          const stat4 = fs43.statSync(bufferPath);
           const ageMs = Date.now() - stat4.mtimeMs;
           const ageMin = Math.round(ageMs / 6e4);
           if (ageMin > 10) {
             console.warn(`[hooks] PostCompact: \u26A0\uFE0F working-buffer.md is ${ageMin}min old (last modified ${stat4.mtime.toISOString()}) \u2014 content may be stale!`);
           }
-          const content = fs42.readFileSync(bufferPath, "utf-8");
+          const content = fs43.readFileSync(bufferPath, "utf-8");
           if (content.trim()) {
             console.log(`[hooks] PostCompact: injecting working-buffer (${content.length} chars, ${ageMin}min old)`);
             return {
@@ -27707,7 +27948,7 @@ ${content}`
     return `${hr}h ${remMin}m`;
   }
   if (config.skills?.enabled !== false) {
-    const skillsDir = config.skills?.path ? path44.isAbsolute(config.skills.path) ? config.skills.path : path44.resolve(config.workspace, config.skills.path) : path44.resolve(config.workspace, "skills");
+    const skillsDir = config.skills?.path ? path45.isAbsolute(config.skills.path) ? config.skills.path : path45.resolve(config.workspace, config.skills.path) : path45.resolve(config.workspace, "skills");
     const modelDef2 = config.provider.models.find((m) => m.id === config.model);
     const contextWindowTokens = modelDef2?.contextWindow;
     const skills = scanSkills(skillsDir);
@@ -27726,8 +27967,8 @@ ${content}`
     workspace: config.workspace
   });
   const systemPrompt = [systemStable, systemDynamic].join("\n\n");
-  const promptDumpPath = path44.join(config.workspace, ".system-prompt.txt");
-  fs41.writeFileSync(promptDumpPath, systemPrompt);
+  const promptDumpPath = path45.join(config.workspace, ".system-prompt.txt");
+  fs42.writeFileSync(promptDumpPath, systemPrompt);
   console.log(`System prompt: ${systemStable.length} chars stable + ${systemDynamic.length} chars dynamic \u2192 ${promptDumpPath}`);
   const modelDef = config.provider.models.find((m) => m.id === config.model);
   const modelContextWindow = modelDef?.contextWindow;
@@ -27852,13 +28093,11 @@ ${content}`
     model: config.model,
     modelInputs: modelDef?.input || ["text"],
     systemPrompt,
-    features: config.profile.features,
     channels: config.channels,
     config,
     // tool 读自己配置用
     recallProvider: memoryRecallProvider || void 0,
     extractProvider: memoryExtractProvider || void 0,
-    topics: config.topics,
     everosCfg: config.everos,
     mcpManager
   };
@@ -27875,7 +28114,6 @@ ${content}`
       model: visionConfig.modelId,
       modelInputs: visionModelDef?.input || ["text", "image"],
       systemPrompt,
-      features: config.profile.features,
       channels: config.channels,
       config,
       // tool 读自己配置用
@@ -27926,7 +28164,6 @@ ${content}`
         model: p.model,
         modelInputs: p.modelInputs,
         systemPrompt,
-        features: config.profile.features,
         channels: config.channels,
         config,
         recallProvider: memoryRecallProvider || void 0,
@@ -27970,7 +28207,6 @@ ${content}`
       model: modelId,
       modelInputs: modelDef2.input || ["text"],
       systemPrompt,
-      features: config.profile.features,
       channels: config.channels,
       recallProvider: memoryRecallProvider || void 0,
       extractProvider: memoryExtractProvider || void 0
@@ -28755,8 +28991,7 @@ ${result.changes.map((c) => `- ${c}`).join("\n")}` : `\u274C Reload failed: ${re
       const featureKeys = ["topic-recall", "topic-extract", "session-memory"];
       if (featureKeys.includes(ctx.command)) {
         const key = ctx.command;
-        const f = deps.features || {};
-        const cur = f[key] === false ? "off" : "on";
+        const cur = getFeature(key) === false ? "off" : "on";
         const rawState = (ctx.args.state || "").trim().toLowerCase();
         if (rawState === "") {
           await ctx.reply(`\u{1F4CA} ${key}: **${cur}**`);
@@ -28772,39 +29007,9 @@ ${result.changes.map((c) => `- ${c}`).join("\n")}` : `\u274C Reload failed: ${re
           return;
         }
         const next = rawState === "on";
-        if (!config.features) config.features = {};
-        config.features[key] = next;
-        if (deps.features) deps.features[key] = next;
-        try {
-          const fs42 = await import("fs");
-          const pathMod = await import("path");
-          let cfgPath = config._configFilePath;
-          if (!cfgPath || !fs42.existsSync(cfgPath)) {
-            const __filename = fileURLToPath(import.meta.url);
-            const __dirname = pathMod.dirname(__filename);
-            cfgPath = pathMod.resolve(__dirname, "../configs", pathMod.basename(cfgPath || "engine-config.json"));
-          }
-          const cfg = JSON.parse(fs42.readFileSync(cfgPath, "utf-8"));
-          let featObj = null;
-          if (cfg.agents?.defaults?.features) {
-            featObj = cfg.agents.defaults.features;
-          } else if (cfg.agents?.defaults) {
-            cfg.agents.defaults.features = {};
-            featObj = cfg.agents.defaults.features;
-          }
-          if (featObj) {
-            featObj[key] = next;
-            fs42.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
-            console.log(`[${ctx.command}] ${key} ${cur} \u2192 ${rawState} (disk persisted)`);
-            await ctx.reply(`\u2705 ${key}: **${cur}** \u2192 **${rawState}**`);
-          } else {
-            console.warn(`[${ctx.command}] could not locate features in config, in-memory only`);
-            await ctx.reply(`\u2705 ${key}: **${cur}** \u2192 **${rawState}**\uFF08\u5185\u5B58\u751F\u6548\uFF0C\u78C1\u76D8\u672A\u627E\u5230 features \u8DEF\u5F84\uFF09`);
-          }
-        } catch (e) {
-          console.warn(`[${ctx.command}] disk write failed: ${e.message}`);
-          await ctx.reply(`\u2705 ${key}: **${cur}** \u2192 **${rawState}**\uFF08\u5185\u5B58\u751F\u6548\uFF0C\u78C1\u76D8\u5199\u5931\u8D25\uFF09`);
-        }
+        await liveConfig.set(`agents.defaults.features.${key}`, next);
+        console.log(`[${ctx.command}] ${key} ${cur} \u2192 ${rawState} (live + persisted)`);
+        await ctx.reply(`\u2705 ${key}: **${cur}** \u2192 **${rawState}**`);
         return;
       }
       if (ctx.command === "model") {
@@ -28922,11 +29127,11 @@ Auto-routing disabled \u2014 all messages use this model.
         const input = (ctx.args.model || "").trim();
         const configPath = config._configFilePath;
         let writePath = configPath;
-        if (configPath && !fs41.existsSync(configPath)) {
+        if (configPath && !fs42.existsSync(configPath)) {
           const __pFile = fileURLToPath(import.meta.url);
-          const __pDir = path44.dirname(__pFile);
-          const altPath = path44.join(path44.resolve(__pDir, "../configs"), path44.basename(configPath));
-          if (fs41.existsSync(altPath)) {
+          const __pDir = path45.dirname(__pFile);
+          const altPath = path45.join(path45.resolve(__pDir, "../configs"), path45.basename(configPath));
+          if (fs42.existsSync(altPath)) {
             console.warn(`[primary] Config not found at ${configPath}, falling back to ${altPath}`);
             writePath = altPath;
           }
@@ -28970,14 +29175,14 @@ Use full ref like \`/primary ${candidates[0].ref}\``);
           return;
         }
         try {
-          const raw = await fs41.promises.readFile(writePath, "utf-8");
+          const raw = await fs42.promises.readFile(writePath, "utf-8");
           const cfg = JSON.parse(raw);
           if (!cfg.agents?.defaults?.model) {
             await ctx.reply(`\u26A0\uFE0F Config structure mismatch: agents.defaults.model not found`);
             return;
           }
           cfg.agents.defaults.model.primary = target;
-          await fs41.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+          await fs42.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
           console.log(`[primary] Persisted primary=${target} to ${writePath}`);
           await ctx.reply(`\u2705 Primary model set to **${target}** (${candidates[0].name})
 Written to config. **Restart required** to take effect.`);
@@ -28990,11 +29195,11 @@ Written to config. **Restart required** to take effect.`);
         const input = (ctx.args.model || "").trim();
         const configPath = config._configFilePath;
         let writePath = configPath;
-        if (configPath && !fs41.existsSync(configPath)) {
+        if (configPath && !fs42.existsSync(configPath)) {
           const __pFile = fileURLToPath(import.meta.url);
-          const __pDir = path44.dirname(__pFile);
-          const altPath = path44.join(path44.resolve(__pDir, "../configs"), path44.basename(configPath));
-          if (fs41.existsSync(altPath)) {
+          const __pDir = path45.dirname(__pFile);
+          const altPath = path45.join(path45.resolve(__pDir, "../configs"), path45.basename(configPath));
+          if (fs42.existsSync(altPath)) {
             console.warn(`[vision-primary] Config not found at ${configPath}, falling back to ${altPath}`);
             writePath = altPath;
           }
@@ -29039,7 +29244,7 @@ Use full ref like \`/vision-primary ${candidates[0].ref}\``);
           return;
         }
         try {
-          const raw = await fs41.promises.readFile(writePath, "utf-8");
+          const raw = await fs42.promises.readFile(writePath, "utf-8");
           const cfg = JSON.parse(raw);
           if (!cfg.agents?.defaults?.model) {
             await ctx.reply(`\u26A0\uFE0F Config structure mismatch: agents.defaults.model not found`);
@@ -29047,12 +29252,12 @@ Use full ref like \`/vision-primary ${candidates[0].ref}\``);
           }
           if (input === "auto" || input === "reset") {
             delete cfg.agents.defaults.model.vision;
-            await fs41.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+            await fs42.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
             console.log(`[vision-primary] Cleared vision primary in ${writePath}`);
             await ctx.reply(`\u2705 Vision primary cleared (auto). Written to config. Hot-reload will apply.`);
           } else {
             cfg.agents.defaults.model.vision = target;
-            await fs41.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
+            await fs42.promises.writeFile(writePath, JSON.stringify(cfg, null, 2), "utf-8");
             console.log(`[vision-primary] Persisted vision=${target} to ${writePath}`);
             await ctx.reply(`\u2705 Vision primary set to **${target}** (${candidates[0].name})
 Written to config. Hot-reload will apply.`);
@@ -29275,7 +29480,7 @@ Use full ref like \`/vision-model ${candidates[0].ref}\``);
             console.log(`[vision] Downloading image: ${att.filename}`);
             let rawBuffer;
             if (att.url.startsWith("file://")) {
-              rawBuffer = fs41.readFileSync(decodeURIComponent(att.url.slice(7)));
+              rawBuffer = fs42.readFileSync(decodeURIComponent(att.url.slice(7)));
             } else {
               rawBuffer = await downloadImage2(att.url);
             }
@@ -29283,8 +29488,8 @@ Use full ref like \`/vision-model ${candidates[0].ref}\``);
             const ext = detected.split("/")[1] || "png";
             const resized = await maybeResizeAndDownsampleImageBuffer2(rawBuffer, rawBuffer.length, ext);
             const imageId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const savedPath = path44.join(config.mediaDir, `${imageId}.${ext}`);
-            fs41.writeFileSync(savedPath, resized.buffer);
+            const savedPath = path45.join(config.mediaDir, `${imageId}.${ext}`);
+            fs42.writeFileSync(savedPath, resized.buffer);
             savedPaths.push(savedPath);
             console.log(`[vision] Saved: ${savedPath} (${resized.buffer.length}B)`);
             imageBlocks.push({
@@ -29310,8 +29515,8 @@ ${pathStr}` }];
         }
         const nonImageAttachments = inbound.attachments?.filter((a) => !a.contentType.startsWith("image/"));
         if (nonImageAttachments && nonImageAttachments.length > 0) {
-          const outDir = path44.join(config.mediaDir, sessionId);
-          fs41.mkdirSync(outDir, { recursive: true });
+          const outDir = path45.join(config.mediaDir, sessionId);
+          fs42.mkdirSync(outDir, { recursive: true });
           const resolved = [];
           for (const att of nonImageAttachments) {
             console.log(`[file] Downloading: ${att.filename} (${att.contentType}, ${att.size}B)`);
@@ -29319,9 +29524,9 @@ ${pathStr}` }];
               const resp = await fetch(att.url);
               if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
               const buffer = Buffer.from(await resp.arrayBuffer());
-              const safeName2 = path44.basename(att.filename).replace(/[<>:"/\\|?*\x00-\x1f]/g, "_") || "attachment";
-              const savedPath = path44.join(outDir, safeName2);
-              fs41.writeFileSync(savedPath, buffer);
+              const safeName2 = path45.basename(att.filename).replace(/[<>:"/\\|?*\x00-\x1f]/g, "_") || "attachment";
+              const savedPath = path45.join(outDir, safeName2);
+              fs42.writeFileSync(savedPath, buffer);
               resolved.push(savedPath);
               console.log(`[file] Saved: ${savedPath} (${buffer.length}B)`);
             } catch (err) {
@@ -29675,7 +29880,7 @@ ${pathStr}` }];
                 console.warn("[cognifold] watcher: config.workspace \u672A\u914D\u7F6E\uFF0C\u8DF3\u8FC7 proactive \u5199\u5165");
                 return;
               }
-              const pFile = path44.join(wsDir, ".cognifold-proactive.json");
+              const pFile = path45.join(wsDir, ".cognifold-proactive.json");
               const cognifoldBaseUrl = config.cognifold?.baseUrl || "http://127.0.0.1:9001";
               const cognifoldSessionId = cfSessionId;
               const rawSuggestions = data.suggestions || data.actions || (data.intent_id ? [data] : []);
@@ -29723,14 +29928,14 @@ ${pathStr}` }];
                 return s;
               }));
               try {
-                fs41.writeFileSync(pFile, JSON.stringify(enriched, null, 2));
+                fs42.writeFileSync(pFile, JSON.stringify(enriched, null, 2));
                 console.log(`[cognifold] proactive suggestions saved (${enriched.length} total)`);
               } catch (e) {
                 console.error(`[cognifold] failed to save proactive: ${e.message}`);
               }
               if (enriched.length > 0) {
-                const promptFile = path44.join(config.workspace, "prompts", "cognifold-proactive.md");
-                const promptText = fs41.existsSync(promptFile) ? fs41.readFileSync(promptFile, "utf-8") : "[CogniFold proactive] \u6709 " + enriched.length + " \u4E2A action \u5230\u671F\u4E86";
+                const promptFile = path45.join(config.workspace, "prompts", "cognifold-proactive.md");
+                const promptText = fs42.existsSync(promptFile) ? fs42.readFileSync(promptFile, "utf-8") : "[CogniFold proactive] \u6709 " + enriched.length + " \u4E2A action \u5230\u671F\u4E86";
                 const actionsJson = JSON.stringify(enriched, null, 2);
                 const sessionId = cfSessionId;
                 const mainSessionId = sessions.getSessionId("scope:main");
@@ -29897,12 +30102,12 @@ async function doReloadConfig(config, deps, provider) {
   try {
     const savedConfigPath = config._configFilePath;
     let reloadConfigPath = savedConfigPath;
-    if (!fs41.existsSync(reloadConfigPath)) {
+    if (!fs42.existsSync(reloadConfigPath)) {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path44.dirname(__filename);
-      const engineConfigsDir = path44.resolve(__dirname, "../configs");
-      const altPath = path44.join(engineConfigsDir, path44.basename(savedConfigPath));
-      if (fs41.existsSync(altPath)) {
+      const __dirname = path45.dirname(__filename);
+      const engineConfigsDir = path45.resolve(__dirname, "../configs");
+      const altPath = path45.join(engineConfigsDir, path45.basename(savedConfigPath));
+      if (fs42.existsSync(altPath)) {
         console.warn(`[reload] Config not found at ${reloadConfigPath}, falling back to ${altPath} (dev mode)`);
         reloadConfigPath = altPath;
       }
@@ -29975,12 +30180,6 @@ async function doReloadConfig(config, deps, provider) {
       deps.extractProvider = newExtract;
       changes.push(`extract \u2192 ${newConfig.topics?.extract?.provider}/${newConfig.topics?.extract?.model}`);
     }
-    if (newConfig.topics) {
-      deps.topics = newConfig.topics;
-    }
-    if (newConfig.profile?.features) {
-      deps.features = newConfig.profile.features;
-    }
     try {
       const { setAutoDreamConfig: setAutoDreamConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
       setAutoDreamConfig2(newConfig);
@@ -30026,7 +30225,7 @@ async function doReloadConfig(config, deps, provider) {
   } catch (err) {
     console.error(`[reload] Failed: ${err.message}`);
     try {
-      fs41.appendFileSync(path44.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD FAILED: ${err.message}
+      fs42.appendFileSync(path45.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD FAILED: ${err.message}
 ${err.stack}
 `);
     } catch {
@@ -30037,36 +30236,36 @@ ${err.stack}
 function startConfigWatcher(config, deps, provider) {
   const raw = config._configFilePath;
   let configPath = raw;
-  if (!fs41.existsSync(configPath)) {
-    configPath = path44.resolve(raw);
+  if (!fs42.existsSync(configPath)) {
+    configPath = path45.resolve(raw);
   }
-  if (!fs41.existsSync(configPath)) {
+  if (!fs42.existsSync(configPath)) {
     const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = path44.dirname(__filename2);
-    configPath = path44.resolve(__dirname2, "..", raw);
+    const __dirname2 = path45.dirname(__filename2);
+    configPath = path45.resolve(__dirname2, "..", raw);
   }
-  if (!fs41.existsSync(configPath)) {
+  if (!fs42.existsSync(configPath)) {
     console.warn(`[config-watch] config path invalid: ${configPath}, watcher disabled`);
     try {
-      fs41.appendFileSync(path44.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] DISABLED: configPath=${configPath}
+      fs42.appendFileSync(path45.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] DISABLED: configPath=${configPath}
 `);
     } catch {
     }
     return null;
   }
   let debounceTimer = null;
-  const watcher = fs41.watch(configPath, { persistent: true }, (eventType) => {
+  const watcher = fs42.watch(configPath, { persistent: true }, (eventType) => {
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(async () => {
       console.log(`[config-watch] file changed (${eventType}), reloading...`);
       try {
-        fs41.appendFileSync(path44.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] CHANGE eventType=${eventType}, calling doReloadConfig
+        fs42.appendFileSync(path45.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] CHANGE eventType=${eventType}, calling doReloadConfig
 `);
       } catch {
       }
       const result = await doReloadConfig(config, deps, provider);
       try {
-        fs41.appendFileSync(path44.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD DONE: ok=${result.ok} changes=${result.changes.join(",")}
+        fs42.appendFileSync(path45.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] RELOAD DONE: ok=${result.ok} changes=${result.changes.join(",")}
 `);
       } catch {
       }
@@ -30075,30 +30274,30 @@ function startConfigWatcher(config, deps, provider) {
   watcher.on("error", (err) => {
     console.error(`[config-watch] error: ${err.message}`);
     try {
-      fs41.appendFileSync(path44.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${err.message}
+      fs42.appendFileSync(path45.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${err.message}
 `);
     } catch {
     }
   });
   console.log(`[config-watch] watching ${configPath}`);
   try {
-    fs41.appendFileSync(path44.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] STARTED watching=${configPath}
+    fs42.appendFileSync(path45.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] STARTED watching=${configPath}
 `);
   } catch {
   }
   return watcher;
 }
 function startSecretsWatcher(config, deps, provider) {
-  const secretsDir = path44.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
-  const cfgBase = path44.basename(config._configFilePath || "", ".json");
+  const secretsDir = path45.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
+  const cfgBase = path45.basename(config._configFilePath || "", ".json");
   const secretCandidates = [
-    path44.join(secretsDir, `${cfgBase}.env`),
-    path44.join(path44.dirname(config._configFilePath || ""), `.env.${cfgBase}`),
-    path44.join(path44.dirname(config._configFilePath || ""), ".env")
+    path45.join(secretsDir, `${cfgBase}.env`),
+    path45.join(path45.dirname(config._configFilePath || ""), `.env.${cfgBase}`),
+    path45.join(path45.dirname(config._configFilePath || ""), ".env")
   ];
   let secretsPath = null;
   for (const p of secretCandidates) {
-    if (fs41.existsSync(p)) {
+    if (fs42.existsSync(p)) {
       secretsPath = p;
       break;
     }
@@ -30111,9 +30310,9 @@ function startSecretsWatcher(config, deps, provider) {
   let activeWatcher = null;
   const startWatch = () => {
     if (activeWatcher) activeWatcher.close();
-    activeWatcher = fs41.watch(secretsPath, { persistent: true }, (eventType) => {
+    activeWatcher = fs42.watch(secretsPath, { persistent: true }, (eventType) => {
       if (eventType === "rename") {
-        if (fs41.existsSync(secretsPath)) {
+        if (fs42.existsSync(secretsPath)) {
           console.log("[secrets-watch] rename detected, re-watching file...");
           startWatch();
         } else {
@@ -30125,7 +30324,7 @@ function startSecretsWatcher(config, deps, provider) {
       debounceTimer = setTimeout(async () => {
         console.log(`[secrets-watch] file changed (${eventType}), reloading secrets...`);
         try {
-          const content = fs41.readFileSync(secretsPath, "utf-8");
+          const content = fs42.readFileSync(secretsPath, "utf-8");
           let updated = 0;
           for (const line of content.split("\n")) {
             const trimmed = line.trim();
@@ -30144,7 +30343,7 @@ function startSecretsWatcher(config, deps, provider) {
           const result = await doReloadConfig(config, deps, provider);
           console.log(`[secrets-watch] config reloaded: ok=${result.ok} changes=${result.changes.join(",")}`);
           try {
-            fs41.appendFileSync(path44.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] SECRETS RELOAD: ok=${result.ok} keys=${updated}
+            fs42.appendFileSync(path45.join(config.stateDir, "logs", "engine-config-watch.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] SECRETS RELOAD: ok=${result.ok} keys=${updated}
 `);
           } catch {
           }