deepseeker-code 1.0.51 → 1.0.52

package/dist/cli.mjs

@@ -207,7 +207,7 @@ ${dim}  \u8FD0\u884C npm i -g deepseeker-code@latest \u66F4\u65B0${reset}
           return new Date(t).toLocaleDateString("zh-CN");
         },
         langCurrent: () => `\u5F53\u524D\u754C\u9762\u8BED\u8A00\uFF1A\u4E2D\u6587\uFF08/lang en \u5207\u6362\u82F1\u6587\uFF09`,
-        langSet: (l) => `\u754C\u9762\u8BED\u8A00\u5DF2\u5207\u6362\uFF1A${l === "zh" ? "\u4E2D\u6587" : "English"}`,
+        langSet: (l) => `\u754C\u9762\u8BED\u8A00\u5DF2\u5207\u6362\uFF1A${l === "zh" ? "\u4E2D\u6587" : "English"}\uFF08AI \u56DE\u590D\u8BED\u8A00\u9ED8\u8BA4\u8DDF\u968F\u6BCF\u8F6E\u63D0\u95EE\u81EA\u52A8\u5224\u65AD\uFF1B\u7EAF\u4EE3\u7801/\u65E0\u6587\u5B57\u8F6E\u6B21\u4EE5\u6B64\u8BED\u8A00\u4E3A\u51C6\uFF09`,
         langInvalid: (arg) => `\u65E0\u6548\u8BED\u8A00\uFF1A${arg}\uFF08\u53EF\u9009\uFF1Azh \u4E2D\u6587 / en English\uFF09`,
         outputStyleNone: () => `\u672A\u52A0\u8F7D\u4EFB\u4F55\u8F93\u51FA\u98CE\u683C\uFF08\u5728 ~/.deepseeker-code/output-styles/ \u653E <name>.md\uFF09\u3002`,
         outputStyleCurrent: (cur) => `\u5F53\u524D\u8F93\u51FA\u98CE\u683C\uFF1A${cur ?? "\u9ED8\u8BA4\uFF08\u4E2D\u6027\uFF09"}\u3002\u53EF\u7528\uFF1A`,
@@ -356,7 +356,7 @@ Usage: /model <model-id> to switch directly, or /switch for the picker`,
           return new Date(t).toLocaleDateString("en-US");
         },
         langCurrent: () => `Interface language: English (/lang zh for \u4E2D\u6587)`,
-        langSet: (l) => `Interface language: ${l === "zh" ? "\u4E2D\u6587" : "English"}`,
+        langSet: (l) => `Interface language: ${l === "zh" ? "\u4E2D\u6587" : "English"} (AI reply language follows each question's language automatically; this is the fallback for code-only / text-less turns)`,
         langInvalid: (arg) => `Invalid language: ${arg} (choose zh / en)`,
         outputStyleNone: () => `No output styles loaded (drop a <name>.md in ~/.deepseeker-code/output-styles/).`,
         outputStyleCurrent: (cur) => `Current output style: ${cur ?? "default (neutral)"}. Available:`,
@@ -618,7 +618,7 @@ var init_common = __esm({
       }
     };
     detectTextLocale = (text) => {
-      const stripped = (text || "").replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ").replace(/\s+/g, " ");
+      const stripped = (text || "").replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ").replace(/[A-Za-z]:[\\/][^\s"'`）)\]}，。；]*/g, " ").replace(/(?:^|[\s(（【"'])\/(?:home|Users|root|var|tmp|mnt|opt|data|app)[^\s"'`）)\]}，。；]*/g, " ").replace(/https?:\/\/[^\s"'`）)\]}，。；]*/g, " ").replace(/\s+/g, " ");
       const cjk = (stripped.match(/[㐀-䶿一-鿿]/g) || []).length;
       const latin = (stripped.match(/[A-Za-z]/g) || []).length;
       if (cjk === 0 && latin === 0) return null;
@@ -937,7 +937,7 @@ var init_stream = __esm({
 });
 
 // ../core/src/llm/providers/deepseek/index.ts
-var summarize, classifyRisk, isContextLengthError, isTransientError, buildAssistantMessage, deepseekProvider;
+var summarize, classifyRisk, isContextLengthError, isImageUnsupportedError, isTransientError, buildAssistantMessage, deepseekProvider;
 var init_deepseek = __esm({
   "../core/src/llm/providers/deepseek/index.ts"() {
     "use strict";
@@ -997,6 +997,15 @@ var init_deepseek = __esm({
       const msg = typeof e.message === "string" ? e.message : "";
       return code === "context_length_exceeded" || /context_length|context length|maximum context|input length|too long|exceed/i.test(msg);
     };
+    isImageUnsupportedError = (e) => {
+      if (!e || isContextLengthError(e)) return false;
+      const status = e.status ?? e.response?.status;
+      if (status !== 400 && status !== 422) return false;
+      const code = e.error?.code ?? e.code;
+      const msg = typeof e.message === "string" ? e.message : "";
+      const codeStr = typeof code === "string" ? code : "";
+      return /image|multimodal|vision|image_url/i.test(msg) || /image/i.test(codeStr);
+    };
     isTransientError = (e) => {
       if (!e) return false;
       const status = e.status ?? e.response?.status;
@@ -1019,7 +1028,8 @@ var init_deepseek = __esm({
       classifyRisk,
       buildAssistantMessage,
       isContextLengthError,
-      isTransientError
+      isTransientError,
+      isImageUnsupportedError
     };
   }
 });
@@ -1034,12 +1044,63 @@ var init_createModel = __esm({
   }
 });
 
+// ../core/src/llm/visionCapability.ts
+import path6 from "path";
+import fs4 from "fs/promises";
+var CAP_FILE, MAX_ENTRIES, mem, loadPromise, ensureVisionCacheLoaded, peekVisionCapability, writeChain, persistLatest, learnVisionCapability;
+var init_visionCapability = __esm({
+  "../core/src/llm/visionCapability.ts"() {
+    "use strict";
+    init_config();
+    init_common();
+    CAP_FILE = path6.join(appConfig.dataDir, "model-capabilities.json");
+    MAX_ENTRIES = 100;
+    mem = {};
+    loadPromise = (async () => {
+      const t = await readJSONFile(CAP_FILE);
+      if (t && typeof t === "object") mem = t;
+    })().catch(() => {
+    });
+    ensureVisionCacheLoaded = () => loadPromise;
+    peekVisionCapability = (modelId) => {
+      const e = mem[modelId?.trim()];
+      return e && typeof e.vision === "boolean" ? e.vision : void 0;
+    };
+    writeChain = Promise.resolve();
+    persistLatest = () => {
+      writeChain = writeChain.then(async () => {
+        try {
+          await fs4.mkdir(appConfig.dataDir, { recursive: true });
+          await atomicWriteJSON(CAP_FILE, mem);
+        } catch {
+        }
+      });
+      return writeChain;
+    };
+    learnVisionCapability = (modelId, vision) => {
+      const id = modelId?.trim();
+      if (!id) return;
+      mem[id] = { vision, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      while (Object.keys(mem).length > MAX_ENTRIES) {
+        let oldestKey = "";
+        for (const k of Object.keys(mem)) {
+          if (!oldestKey || (mem[k]?.checkedAt ?? "") < (mem[oldestKey]?.checkedAt ?? "")) oldestKey = k;
+        }
+        if (!oldestKey) break;
+        delete mem[oldestKey];
+      }
+      void persistLatest();
+    };
+  }
+});
+
 // ../core/src/session/contentParts.ts
-var MAX_IMAGE_BYTES, msgText, imageUrlsOf, hasImagePart, modelSupportsVision, isVisionEnabled, estimateImageTokens, toWireUserContent, toIngestContents, replaceImageParts, collapseToText, degradeImagesForAux;
+var MAX_IMAGE_BYTES, msgText, imageUrlsOf, hasImagePart, VISION_DEGRADE_NOTE, isVisionEnabled, estimateImageTokens, toWireUserContent, toIngestContents, replaceImageParts, collapseToText, degradeImagesForAux;
 var init_contentParts = __esm({
   "../core/src/session/contentParts.ts"() {
     "use strict";
     init_createModel();
+    init_visionCapability();
     MAX_IMAGE_BYTES = 8 * 1024 * 1024;
     msgText = (content) => {
       if (typeof content === "string") return content;
@@ -1053,13 +1114,13 @@ var init_contentParts = __esm({
       return content.filter((p) => p?.type === "image_url" && typeof p?.image_url?.url === "string").map((p) => p.image_url.url);
     };
     hasImagePart = (content) => imageUrlsOf(content).length > 0;
-    modelSupportsVision = (modelId) => /vision|vlm|(^|[-_.])vl([-_.0-9]|$)/i.test(modelId || "");
+    VISION_DEGRADE_NOTE = "[\u56FE\u7247\u672A\u9001\u8FBE\uFF1A\u5F53\u524D\u6A21\u578B\u4E0D\u652F\u6301\u56FE\u7247\u8F93\u5165\uFF0C\u7CFB\u7EDF\u5DF2\u81EA\u52A8\u6539\u7528\u6587\u672C\u65B9\u5F0F\uFF1B\u539F\u56FE\u4ECD\u5728\u4F1A\u8BDD\u5F52\u6863\u4E2D\uFF0C\u5982\u9700\u5206\u6790\u56FE\u7247\u5185\u5BB9\u53EF\u914D\u7F6E\u56FE\u50CF\u8BC6\u522B\u5DE5\u5177\u8BFB\u53D6\u5B58\u6863\u8DEF\u5F84\uFF0C\u6216\u7531\u7528\u6237\u91CD\u65B0\u63D0\u4F9B]";
     isVisionEnabled = (modelId) => {
       const v = process.env.DEEP_SEEK_VISION;
       if (v === "1" || v === "true") return true;
       if (v === "0" || v === "false") return false;
       const effective = typeof modelId === "string" && modelId.trim() ? modelId.trim() : MODEL_NAME;
-      return modelSupportsVision(effective);
+      return peekVisionCapability(effective) ?? true;
     };
     estimateImageTokens = () => {
       const n = Number(process.env.DEEP_SEEK_IMAGE_TOKENS);
@@ -1084,9 +1145,9 @@ var init_contentParts = __esm({
           skipped.push(`\u{1F5BC} \u56FE\u7247 ${name} \u5DF2\u5FFD\u7565\uFF1A\u8D85\u8FC7 ${Math.round(MAX_IMAGE_BYTES / 1024 / 1024)}MB \u4E0A\u9650`);
           continue;
         }
-        accepted.push({ name, url: `data:${a.mime};base64,${b64}` });
+        accepted.push({ name, url: `data:${a.mime};base64,${b64}`, path: a.path });
       }
-      const labels = accepted.map((p) => `\u{1F5BC} [\u56FE\u7247: ${p.name}]`);
+      const labels = accepted.map((p) => `\u{1F5BC} [\u56FE\u7247: ${p.name}${p.path ? ` | \u5B58\u6863: ${p.path}` : ""}]`);
       const footer = [...skipped, ...labels];
       const finalText = footer.length ? `${text}
 
@@ -1110,7 +1171,7 @@ ${paths.join("\n")}
       return {
         wire: `${text}
 
-\u{1F5BC} \u6536\u5230\u56FE\u7247\u9644\u4EF6\uFF08${names}\uFF09\uFF1A\u5F53\u524D\u6A21\u578B\u65E0\u89C6\u89C9\u80FD\u529B\uFF0C\u65E0\u6CD5\u76F4\u63A5\u67E5\u770B\u56FE\u7247\u5185\u5BB9\uFF08\u53EF\u5207\u6362 vision \u6A21\u578B\u6216\u8BBE DEEP_SEEK_VISION=1 \u5F3A\u5F00\uFF09\uFF1B${relay}`,
+\u{1F5BC} \u6536\u5230\u56FE\u7247\u9644\u4EF6\uFF08${names}\uFF09\uFF1A\u5F53\u524D\u6A21\u578B\u4E0D\u652F\u6301\u56FE\u7247\u8F93\u5165\uFF08\u89C6\u89C9\u80FD\u529B\u5DF2\u6309\u7AEF\u70B9\u5B9E\u6D4B\u81EA\u52A8\u5224\u5B9A\uFF1B\u53EF\u5207\u6362 vision \u6A21\u578B\u6216\u8BBE DEEP_SEEK_VISION=1 \u5F3A\u5F00\uFF09\uFF1B${relay}`,
         archive
       };
     };
@@ -1151,10 +1212,11 @@ var init_replay = __esm({
       let attemptCounts = [];
       const calls = [];
       const makeFaultError = (fault) => {
-        const msg = fault.message ?? (fault.type === "idle" ? "stream_idle_timeout" : fault.type === "context_length" ? "context_length_exceeded\uFF08\u56DE\u653E\u6CE8\u5165\uFF09" : fault.type === "transient" ? "HTTP 429 rate limit\uFF08\u56DE\u653E\u6CE8\u5165\uFF09" : "\u56DE\u653E\u81F4\u547D\u9519\u8BEF\uFF08fatal\uFF09");
+        const msg = fault.message ?? (fault.type === "idle" ? "stream_idle_timeout" : fault.type === "context_length" ? "context_length_exceeded\uFF08\u56DE\u653E\u6CE8\u5165\uFF09" : fault.type === "transient" ? "HTTP 429 rate limit\uFF08\u56DE\u653E\u6CE8\u5165\uFF09" : fault.type === "image_unsupported" ? "This model does not support image\uFF08\u56DE\u653E\u6CE8\u5165\uFF09" : "\u56DE\u653E\u81F4\u547D\u9519\u8BEF\uFF08fatal\uFF09");
         const e = new Error(msg);
         e.replayFault = fault.type;
         if (fault.type === "transient") e.status = 429;
+        if (fault.type === "image_unsupported") e.status = 400;
         return e;
       };
       const streamChat2 = async function* (messages, tools, opts) {
@@ -1210,9 +1272,10 @@ var init_replay = __esm({
           if (parts.toolCalls?.length) m.tool_calls = parts.toolCalls;
           return m;
         },
-        // 自识别回放注入的故障（streamInference 经 activeProvider 调用这两个分类器驱动重试通道）
+        // 自识别回放注入的故障（streamInference 经 activeProvider 调用这些分类器驱动重试通道）
         isContextLengthError: (e) => e?.replayFault === "context_length",
         isTransientError: (e) => e?.replayFault === "transient",
+        isImageUnsupportedError: (e) => e?.replayFault === "image_unsupported",
         get calls() {
           return calls;
         },
@@ -1371,8 +1434,8 @@ __export(store_exports, {
   updateCalibration: () => updateCalibration,
   writeStore: () => writeStore
 });
-import fs4 from "fs/promises";
-import path6 from "path";
+import fs5 from "fs/promises";
+import path7 from "path";
 async function getRollingState(sessionId) {
   const store = await readStore(sessionId);
   if (!store) {
@@ -1420,42 +1483,42 @@ var init_store = __esm({
     getSessionsDirPath = (mainSessionId) => {
       assertSafeSessionId(mainSessionId);
       const fileName = getFileName(mainSessionId);
-      return path6.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir, fileName);
+      return path7.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir, fileName);
     };
-    getWorkspaceSessionsDir = () => path6.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir);
+    getWorkspaceSessionsDir = () => path7.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir);
     getStatePath = (sessionId) => {
       assertSafeSessionId(sessionId);
-      return path6.join(getSessionsDirPath(sessionId), `${sessionId}.state.json`);
+      return path7.join(getSessionsDirPath(sessionId), `${sessionId}.state.json`);
     };
     getTranscriptPath = (sessionId) => {
       assertSafeSessionId(sessionId);
-      return path6.join(getSessionsDirPath(sessionId), `${sessionId}.jsonl`);
+      return path7.join(getSessionsDirPath(sessionId), `${sessionId}.jsonl`);
     };
     ensureSessionsDir = async (sessionId) => {
-      await fs4.mkdir(getSessionsDirPath(sessionId), { recursive: true });
+      await fs5.mkdir(getSessionsDirPath(sessionId), { recursive: true });
       await migrateLegacyFiles(sessionId).catch(() => {
       });
     };
     migrateLegacyFiles = async (sessionId) => {
       assertSafeSessionId(sessionId);
       const dir = getSessionsDirPath(sessionId);
-      const legacy = path6.join(dir, `${sessionId}.json`);
+      const legacy = path7.join(dir, `${sessionId}.json`);
       const transcriptPath = getTranscriptPath(sessionId);
       const statePath = getStatePath(sessionId);
       let legacyText;
       try {
-        legacyText = await fs4.readFile(legacy, "utf-8");
+        legacyText = await fs5.readFile(legacy, "utf-8");
       } catch {
         return;
       }
       try {
-        await fs4.access(transcriptPath);
+        await fs5.access(transcriptPath);
         return;
       } catch {
       }
       const raw = legacyText.trim();
       if (raw.length === 0) {
-        await fs4.rename(legacy, transcriptPath);
+        await fs5.rename(legacy, transcriptPath);
         return;
       }
       const lines = raw.split("\n");
@@ -1468,13 +1531,13 @@ var init_store = __esm({
         }
       });
       if (isJsonl) {
-        await fs4.rename(legacy, transcriptPath);
+        await fs5.rename(legacy, transcriptPath);
         return;
       }
       try {
         const v = JSON.parse(raw);
         if (typeof v === "object" && v !== null) {
-          await fs4.rename(legacy, statePath);
+          await fs5.rename(legacy, statePath);
           return;
         }
       } catch {
@@ -1485,8 +1548,8 @@ var init_store = __esm({
       await ensureSessionsDir(sessionId);
       const finalPath = getStatePath(sessionId);
       const tmpPath = `${finalPath}.${Date.now()}.tmp`;
-      await fs4.writeFile(tmpPath, JSON.stringify(store, null, 2), "utf-8");
-      await fs4.rename(tmpPath, finalPath);
+      await fs5.writeFile(tmpPath, JSON.stringify(store, null, 2), "utf-8");
+      await fs5.rename(tmpPath, finalPath);
     };
     storeLocks = /* @__PURE__ */ new Map();
     withStoreLock = (sessionId, fn) => {
@@ -1526,7 +1589,7 @@ var init_store = __esm({
       await ensureSessionsDir(sessionId);
       const p = getStatePath(sessionId);
       try {
-        const raw = (await fs4.readFile(p, "utf-8")).trim();
+        const raw = (await fs5.readFile(p, "utf-8")).trim();
         if (raw.length === 0) {
           return {};
         }
@@ -1555,7 +1618,7 @@ var init_store = __esm({
       const root = getWorkspaceSessionsDir();
       let entries;
       try {
-        entries = await fs4.readdir(root, { withFileTypes: true });
+        entries = await fs5.readdir(root, { withFileTypes: true });
       } catch {
         return [];
       }
@@ -1564,12 +1627,12 @@ var init_store = __esm({
         if (!entry.isDirectory()) continue;
         const sessionId = entry.name;
         if (!isSafeSessionId(sessionId)) continue;
-        const dirPath = path6.join(root, sessionId);
+        const dirPath = path7.join(root, sessionId);
         const state = await readJSONFile(getStatePath(sessionId));
         let messageCount = 0;
         let preview = "";
         try {
-          const raw = await fs4.readFile(getTranscriptPath(sessionId), "utf-8");
+          const raw = await fs5.readFile(getTranscriptPath(sessionId), "utf-8");
           for (const s of raw.split("\n")) {
             const line = s.trim();
             if (!line) continue;
@@ -1596,7 +1659,7 @@ var init_store = __esm({
         let updatedAt = state?.updatedAt;
         if (!updatedAt) {
           try {
-            updatedAt = (await fs4.stat(dirPath)).mtime.toISOString();
+            updatedAt = (await fs5.stat(dirPath)).mtime.toISOString();
           } catch {
           }
         }
@@ -1629,13 +1692,13 @@ var init_store = __esm({
     deleteSession = async (sessionId) => {
       assertSafeSessionId(sessionId);
       const dir = getSessionsDirPath(sessionId);
-      await fs4.rm(dir, { recursive: true, force: true });
+      await fs5.rm(dir, { recursive: true, force: true });
     };
   }
 });
 
 // ../core/src/session/transcript.ts
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 var isEventLine, readTranscriptLines, appendLineWithRetry, appendMessage, appendEvent;
 var init_transcript = __esm({
   "../core/src/session/transcript.ts"() {
@@ -1648,7 +1711,7 @@ var init_transcript = __esm({
       await ensureSessionsDir(sessionId);
       const p = getTranscriptPath(sessionId);
       try {
-        const text = await fs5.readFile(p, "utf-8");
+        const text = await fs6.readFile(p, "utf-8");
         const lines = [];
         for (const s of text.split("\n")) {
           const line = s.trim();
@@ -1670,15 +1733,15 @@ var init_transcript = __esm({
       for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
         let beforeSize = 0;
         try {
-          beforeSize = (await fs5.stat(p)).size;
+          beforeSize = (await fs6.stat(p)).size;
         } catch {
         }
         try {
-          await fs5.appendFile(p, payload, "utf-8");
+          await fs6.appendFile(p, payload, "utf-8");
           return;
         } catch (e) {
           try {
-            await fs5.truncate(p, beforeSize);
+            await fs6.truncate(p, beforeSize);
           } catch {
           }
           if (attempt === MAX_ATTEMPTS) throw e;
@@ -1741,7 +1804,7 @@ var init_types = __esm({
 
 // ../core/src/hooks/shellExecutor.ts
 import { spawn } from "child_process";
-import path7 from "path";
+import path8 from "path";
 var MAX_OUTPUT, DEFAULT_TIMEOUT_MS, HARD_TIMEOUT_CAP_MS, ENV_WHITELIST, truncate, MAX_STDIN_FIELD, capFieldStrings, extractFilePath, executeHookCommand;
 var init_shellExecutor = __esm({
   "../core/src/hooks/shellExecutor.ts"() {
@@ -1787,7 +1850,7 @@ var init_shellExecutor = __esm({
       if (typeof rel !== "string" || !rel.trim()) return void 0;
       const base = typeof p.cwd === "string" && p.cwd || process.env.WORKSPACE_ROOT || process.cwd();
       try {
-        return path7.resolve(base, rel);
+        return path8.resolve(base, rel);
       } catch {
         return void 0;
       }
@@ -2004,7 +2067,7 @@ var init_hooks = __esm({
 });
 
 // ../core/src/agent/truncate.ts
-import path8 from "path";
+import path9 from "path";
 function stripAnsi(text) {
   return text.replace(ANSI_ESCAPE, "");
 }
@@ -2043,10 +2106,10 @@ var init_truncate = __esm({
       if (!text) return text;
       const roots = /* @__PURE__ */ new Set();
       try {
-        roots.add(path8.resolve(appConfig.userWorkspaceDir));
+        roots.add(path9.resolve(appConfig.userWorkspaceDir));
         for (const r of getFileAccessRoots()) {
           try {
-            roots.add(path8.resolve(r));
+            roots.add(path9.resolve(r));
           } catch {
           }
         }
@@ -2414,8 +2477,8 @@ ${lines}
 });
 
 // ../core/src/tool/permissions.ts
-import fs6 from "fs/promises";
-import path9 from "path";
+import fs7 from "fs/promises";
+import path10 from "path";
 var PRIMARY_ARG, rules2, trustedProject, globCache, globToRegex, DANGER_COMMAND_TOOLS, compileRule, readPermissionConfig, toolNameMatches, ruleMatches, initPermissions, checkPermission, listPermissionRules, buildScopedAllowRule, resolveSettingsPath, addPermissionRule;
 var init_permissions = __esm({
   "../core/src/tool/permissions.ts"() {
@@ -2477,15 +2540,15 @@ var init_permissions = __esm({
     readPermissionConfig = async (includeProject) => {
       const merged = { allow: [], deny: [], ask: [] };
       const paths = [
-        path9.join(appConfig.dataDir, "settings.json"),
+        path10.join(appConfig.dataDir, "settings.json"),
         // 全局用户级
-        ...includeProject ? [path9.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
+        ...includeProject ? [path10.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
         // 项目级（叠加）；未信任时省略
       ];
       for (const configPath of paths) {
         let raw;
         try {
-          raw = await fs6.readFile(configPath, "utf-8");
+          raw = await fs7.readFile(configPath, "utf-8");
         } catch {
           continue;
         }
@@ -2570,7 +2633,7 @@ var init_permissions = __esm({
       }
       return `${toolName}(${val})`;
     };
-    resolveSettingsPath = (scope) => scope === "global" ? path9.join(appConfig.dataDir, "settings.json") : path9.join(process.cwd(), ".deepseeker-code", "settings.json");
+    resolveSettingsPath = (scope) => scope === "global" ? path10.join(appConfig.dataDir, "settings.json") : path10.join(process.cwd(), ".deepseeker-code", "settings.json");
     addPermissionRule = async (scope, kind, ruleStr) => {
       if (scope === "project" && !trustedProject) return false;
       const compiled = compileRule(ruleStr, `runtime:addPermissionRule(${scope})`, kind);
@@ -2582,7 +2645,7 @@ var init_permissions = __esm({
         const arr = Array.isArray(cfg.permissions[kind]) ? cfg.permissions[kind] : cfg.permissions[kind] = [];
         if (!arr.includes(ruleStr)) {
           arr.push(ruleStr);
-          await fs6.mkdir(path9.dirname(file), { recursive: true });
+          await fs7.mkdir(path10.dirname(file), { recursive: true });
           await atomicWriteJSON(file, cfg);
         }
         if (!rules2[kind].some((r) => r.raw === compiled.raw)) rules2[kind].push(compiled);
@@ -2620,9 +2683,9 @@ var init_sessionRegistry = __esm({
 });
 
 // ../core/src/tool/guard.ts
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import fsSync from "fs";
-import path10 from "path";
+import path11 from "path";
 import ignore from "ignore";
 import { AsyncLocalStorage } from "node:async_hooks";
 var WORKSPACE_ROOT, workspaceAls, getActiveWorkspaceRoot, runWithWorkspaceRoot, runWithSessionContext, BUILTIN_IGNORE_RULES, ignoreCache, ignoreBuilding, allowedRootsReal, getAllowedWorkspaceRoots, getContainingRoot, allowedBoundaryRoots, resolveSafePath, resolveReadablePath, assertWithinWorkspace, PROTECTED_WRITE_DIRS, COMMAND_ENV_DENYLIST, SENSITIVE_ENV_PATTERN, scrubCommandEnv, isProtectedWrite, scanIgnoreFilesRecursive, buildIgnoreEngine, getIgnoreForBase, initializeWorkspaceIgnore, checkIsPathIgnored, requestApproval;
@@ -2678,8 +2741,8 @@ var init_guard = __esm({
     getContainingRoot = (absPath) => {
       let best;
       for (const r of allowedBoundaryRoots()) {
-        const rel = path10.relative(r, absPath);
-        if (!rel.startsWith("..") && !path10.isAbsolute(rel)) {
+        const rel = path11.relative(r, absPath);
+        if (!rel.startsWith("..") && !path11.isAbsolute(rel)) {
           if (!best || r.length > best.length) best = r;
         }
       }
@@ -2696,16 +2759,16 @@ var init_guard = __esm({
     };
     resolveSafePath = (rel, base) => {
       const root = base ?? getActiveWorkspaceRoot();
-      const candidateAbsPath = path10.resolve(root, rel);
+      const candidateAbsPath = path11.resolve(root, rel);
       let truePhysicalPath = candidateAbsPath;
       try {
         if (fsSync.existsSync(candidateAbsPath)) {
           truePhysicalPath = fsSync.realpathSync(candidateAbsPath);
         } else {
-          const parentDir = path10.dirname(candidateAbsPath);
+          const parentDir = path11.dirname(candidateAbsPath);
           if (fsSync.existsSync(parentDir)) {
             const trueParentDir = fsSync.realpathSync(parentDir);
-            truePhysicalPath = path10.join(trueParentDir, path10.basename(candidateAbsPath));
+            truePhysicalPath = path11.join(trueParentDir, path11.basename(candidateAbsPath));
           }
         }
       } catch (e) {
@@ -2719,8 +2782,8 @@ var init_guard = __esm({
         }
       })() : allowedBoundaryRoots();
       const escaped = boundaryRoots.every((r) => {
-        const rel0 = path10.relative(r, truePhysicalPath);
-        return rel0.startsWith("..") || path10.isAbsolute(rel0);
+        const rel0 = path11.relative(r, truePhysicalPath);
+        return rel0.startsWith("..") || path11.isAbsolute(rel0);
       });
       if (escaped) {
         throw new Error(`\u{1F6D1} [SECURITY ALERT] \u68C0\u6D4B\u5230\u6076\u610F\u7684\u7269\u7406\u8DEF\u5F84\u8DE8\u754C\u9003\u9038\uFF01\u62D2\u7EDD\u8BBF\u95EE\uFF1A${rel}`);
@@ -2729,12 +2792,12 @@ var init_guard = __esm({
     };
     resolveReadablePath = (rel) => {
       const root = getActiveWorkspaceRoot();
-      const absPath = path10.resolve(root, rel);
+      const absPath = path11.resolve(root, rel);
       if (!fsSync.existsSync(absPath)) {
-        const rootName = path10.basename(root);
+        const rootName = path11.basename(root);
         const firstSeg = rel.split(/[\\/]/)[0];
         if (rootName && firstSeg === rootName) {
-          const alt = path10.resolve(root, rel.slice(firstSeg.length + 1));
+          const alt = path11.resolve(root, rel.slice(firstSeg.length + 1));
           if (fsSync.existsSync(alt)) return alt;
         }
       }
@@ -2747,9 +2810,9 @@ var init_guard = __esm({
         if (fsSync.existsSync(absPath)) {
           truePhysicalPath = fsSync.realpathSync(absPath);
         } else {
-          const parentDir = path10.dirname(absPath);
+          const parentDir = path11.dirname(absPath);
           if (fsSync.existsSync(parentDir)) {
-            truePhysicalPath = path10.join(fsSync.realpathSync(parentDir), path10.basename(absPath));
+            truePhysicalPath = path11.join(fsSync.realpathSync(parentDir), path11.basename(absPath));
           }
         }
       } catch (e) {
@@ -2763,8 +2826,8 @@ var init_guard = __esm({
         }
       })() : allowedBoundaryRoots();
       const escaped = boundaryRoots.every((r) => {
-        const rel0 = path10.relative(r, truePhysicalPath);
-        return rel0.startsWith("..") || path10.isAbsolute(rel0);
+        const rel0 = path11.relative(r, truePhysicalPath);
+        return rel0.startsWith("..") || path11.isAbsolute(rel0);
       });
       if (escaped) {
         throw new Error(`\u{1F6D1} [SECURITY ALERT] \u4E8C\u6B21\u56F4\u680F\u590D\u68C0\u53D1\u73B0\u8D8A\u754C\uFF08\u7591\u4F3C TOCTOU \u8F6F\u94FE\u63A5\u9003\u9038\uFF09\uFF1A${absPath}`);
@@ -2791,7 +2854,7 @@ var init_guard = __esm({
       if (!relOrAbs) return false;
       try {
         const base = cwd || process.env.WORKSPACE_ROOT || process.cwd();
-        const abs = path10.isAbsolute(relOrAbs) ? relOrAbs : path10.resolve(base, relOrAbs);
+        const abs = path11.isAbsolute(relOrAbs) ? relOrAbs : path11.resolve(base, relOrAbs);
         const lower = abs.replace(/\\/g, "/").toLowerCase();
         return PROTECTED_WRITE_DIRS.some((d) => {
           const seg = ("/" + d).toLowerCase();
@@ -2803,12 +2866,12 @@ var init_guard = __esm({
     };
     scanIgnoreFilesRecursive = async (dirPath, base, engine) => {
       try {
-        const entries = await fs7.readdir(dirPath, { withFileTypes: true });
+        const entries = await fs8.readdir(dirPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isFile() && (entry.name === ".gitignore" || entry.name === ".agentignore")) {
-            const fullPath = path10.join(dirPath, entry.name);
-            const content = await fs7.readFile(fullPath, "utf-8");
-            const relDir = path10.relative(base, dirPath).replace(/\\/g, "/");
+            const fullPath = path11.join(dirPath, entry.name);
+            const content = await fs8.readFile(fullPath, "utf-8");
+            const relDir = path11.relative(base, dirPath).replace(/\\/g, "/");
             const rules3 = content.split(/\r?\n/).map((line) => {
               const trimmed = line.trim();
               if (!trimmed || trimmed.startsWith("#")) return "";
@@ -2819,7 +2882,7 @@ var init_guard = __esm({
         }
         for (const entry of entries) {
           if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
-            await scanIgnoreFilesRecursive(path10.join(dirPath, entry.name), base, engine);
+            await scanIgnoreFilesRecursive(path11.join(dirPath, entry.name), base, engine);
           }
         }
       } catch {
@@ -2890,7 +2953,7 @@ var init_guard = __esm({
 // ../core/src/tool/registry/background.ts
 import { spawn as spawn2, execFileSync } from "child_process";
 import fsSync2 from "fs";
-import path11 from "path";
+import path12 from "path";
 function appendOutput(task, chunk) {
   task.outputBuffer += chunk;
   if (task.outputBuffer.length > MAX_BUFFER_CHARS) {
@@ -2915,7 +2978,7 @@ async function killTree(proc) {
   }
 }
 async function killBackgroundTasksUnder(dirPath) {
-  const norm = (p) => path11.resolve(p).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+  const norm = (p) => path12.resolve(p).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
   const target = norm(dirPath);
   let killed = 0;
   for (const task of registry.values()) {
@@ -2960,9 +3023,9 @@ var init_background = __esm({
       if (envShell && envShell.toLowerCase() !== "cmd") candidates.push(envShell);
       const gitExe = whereLines("git")[0];
       if (gitExe) {
-        const dir = path11.dirname(gitExe);
-        const root = path11.dirname(dir);
-        candidates.push(path11.join(root, "bin", "bash.exe"), path11.join(dir, "bash.exe"), path11.join(path11.dirname(root), "bin", "bash.exe"));
+        const dir = path12.dirname(gitExe);
+        const root = path12.dirname(dir);
+        candidates.push(path12.join(root, "bin", "bash.exe"), path12.join(dir, "bash.exe"), path12.join(path12.dirname(root), "bin", "bash.exe"));
       }
       const bashHits = whereLines("bash").filter((p) => !/\\System32\\/i.test(p)).sort((a, b) => Number(/\\Git\\/i.test(b)) - Number(/\\Git\\/i.test(a)));
       candidates.push(...bashHits);
@@ -3760,17 +3823,17 @@ ${capped || JSON.stringify(result)}`;
 });
 
 // ../core/src/tool/mcp/loader.ts
-import fs8 from "fs/promises";
-import path12 from "path";
+import fs9 from "fs/promises";
+import path13 from "path";
 import { homedir } from "os";
 function sanitize(s) {
   return s.replace(/[^a-zA-Z0-9_]/g, "_");
 }
 async function readMcpConfig() {
-  const configPath = process.env.MCP_CONFIG || path12.join(appConfig.dataDir, "mcp.json");
+  const configPath = process.env.MCP_CONFIG || path13.join(appConfig.dataDir, "mcp.json");
   let raw;
   try {
-    raw = await fs8.readFile(configPath, "utf-8");
+    raw = await fs9.readFile(configPath, "utf-8");
   } catch {
     return {};
   }
@@ -4418,7 +4481,7 @@ var init_toolFilter = __esm({
 });
 
 // ../core/src/common/registry.ts
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 var createRegistry, filterSources, scanSources;
 var init_registry2 = __esm({
   "../core/src/common/registry.ts"() {
@@ -4448,7 +4511,7 @@ var init_registry2 = __esm({
       for (const s of sources) {
         let entries;
         try {
-          entries = await fs9.readdir(s.dir, { withFileTypes: true });
+          entries = await fs10.readdir(s.dir, { withFileTypes: true });
         } catch {
           continue;
         }
@@ -4545,8 +4608,8 @@ ${AGENT_USAGE_HINT}`);
 });
 
 // ../core/src/projectGuide/loader.ts
-import fs10 from "fs/promises";
-import path13 from "path";
+import fs11 from "fs/promises";
+import path14 from "path";
 var CANDIDATES, MAX_GUIDE_BYTES, cached, initProjectGuide, getProjectGuide;
 var init_loader2 = __esm({
   "../core/src/projectGuide/loader.ts"() {
@@ -4563,7 +4626,7 @@ var init_loader2 = __esm({
       try {
         for (const name of CANDIDATES) {
           try {
-            const raw = await fs10.readFile(path13.join(WORKSPACE_ROOT, name), "utf-8");
+            const raw = await fs11.readFile(path14.join(WORKSPACE_ROOT, name), "utf-8");
             const body = raw.length > MAX_GUIDE_BYTES ? raw.slice(0, MAX_GUIDE_BYTES) + `
 
 \u2026[\u9879\u76EE\u6307\u5F15\u8D85 ${MAX_GUIDE_BYTES} \u5B57\u8282\u5DF2\u622A\u65AD\uFF0C\u5B8C\u6574\u5185\u5BB9\u53EF\u8C03\u7528 read_project_guide \u83B7\u53D6]` : raw;
@@ -4727,12 +4790,13 @@ var init_systemInjections = __esm({
         en: "Always produce ALL user-facing output in English: your replies, interim narration, todo item titles, the plan text you submit via exit_plan_mode, code comments, and commit messages. Keep code identifiers as-is; tool results and system instructions may arrive in Chinese \u2014 quote them verbatim where needed, but your own narration and explanations must stay in English."
       };
       const lastUserText = (() => {
+        const dropSyntheticLines = (t) => t.split("\n").filter((l) => !l.trimStart().startsWith("\u{1F5BC}")).join("\n").trim();
         for (let i = message.length - 1; i >= 0; i--) {
           const m = message[i];
           if (m?.role !== "user") continue;
           const c = m.content;
-          if (typeof c === "string") return c;
-          if (Array.isArray(c)) return c.filter((p) => typeof p?.text === "string").map((p) => p.text).join(" ");
+          if (typeof c === "string") return dropSyntheticLines(c);
+          if (Array.isArray(c)) return dropSyntheticLines(c.filter((p) => typeof p?.text === "string").map((p) => p.text).join(" "));
           return "";
         }
         return "";
@@ -4805,9 +4869,9 @@ var init_agent = __esm({
 });
 
 // ../core/src/tool/worktree/manager.ts
-import path14 from "path";
+import path15 from "path";
 import os4 from "os";
-import fs11 from "fs";
+import fs12 from "fs";
 var runMainGit, worktreeRootDir, worktreeDir, isNotARepoError, createWorktree, harvestDiff, runInWorktree, removeWorktree, sweepOrphanedWorktrees, disposeAllSessionWorktrees;
 var init_manager = __esm({
   "../core/src/tool/worktree/manager.ts"() {
@@ -4818,8 +4882,8 @@ var init_manager = __esm({
     init_background();
     init_sessionRegistry();
     runMainGit = (args, maxBuffer = 1024 * 1024 * 5) => execFileSmart("git", args, { cwd: WORKSPACE_ROOT, maxBuffer });
-    worktreeRootDir = () => path14.join(os4.tmpdir(), "deepseeker-code-worktrees", appConfig.userWorkspaceDir);
-    worktreeDir = (sessionId, stepId) => path14.join(worktreeRootDir(), sessionId, stepId);
+    worktreeRootDir = () => path15.join(os4.tmpdir(), "deepseeker-code-worktrees", appConfig.userWorkspaceDir);
+    worktreeDir = (sessionId, stepId) => path15.join(worktreeRootDir(), sessionId, stepId);
     isNotARepoError = (e) => {
       const text = `${e?.message || ""} ${e?.stderr || ""}`.toLowerCase();
       return text.includes("not a git repository");
@@ -4830,12 +4894,12 @@ var init_manager = __esm({
       const wtPath = worktreeDir(sessionId, stepId);
       const shortId = sessionId.replace(/[^A-Za-z0-9-]/g, "").slice(0, 8) || "x";
       const branch = `dsc-wt-${shortId}-${stepId}`;
-      await fs11.promises.mkdir(path14.dirname(wtPath), { recursive: true });
+      await fs12.promises.mkdir(path15.dirname(wtPath), { recursive: true });
       try {
         await runMainGit(["worktree", "add", "-b", branch, wtPath, "HEAD"]);
       } catch (e) {
         if (e?.code === "ENOENT" || /already exists|not a working tree/i.test(`${e?.stderr || ""} ${e?.message || ""}`)) {
-          await fs11.promises.rm(wtPath, { recursive: true, force: true }).catch(() => {
+          await fs12.promises.rm(wtPath, { recursive: true, force: true }).catch(() => {
           });
           await runMainGit(["worktree", "add", "-b", branch, wtPath, "HEAD"]);
         } else {
@@ -4883,7 +4947,7 @@ var init_manager = __esm({
       try {
         await runMainGit(["worktree", "remove", "--force", wt.path]);
       } catch (e) {
-        await fs11.promises.rm(wt.path, { recursive: true, force: true }).catch(() => {
+        await fs12.promises.rm(wt.path, { recursive: true, force: true }).catch(() => {
         });
       }
       try {
@@ -4900,30 +4964,30 @@ var init_manager = __esm({
       const root = worktreeRootDir();
       let entries;
       try {
-        entries = await fs11.promises.readdir(root);
+        entries = await fs12.promises.readdir(root);
       } catch {
         return;
       }
       let swept = 0;
       for (const sessionIdDir of entries) {
-        const sessionPath = path14.join(root, sessionIdDir);
+        const sessionPath = path15.join(root, sessionIdDir);
         let stepDirs;
         try {
-          stepDirs = await fs11.promises.readdir(sessionPath);
+          stepDirs = await fs12.promises.readdir(sessionPath);
         } catch {
           continue;
         }
         for (const stepDir of stepDirs) {
-          const wtPath = path14.join(sessionPath, stepDir);
+          const wtPath = path15.join(sessionPath, stepDir);
           try {
             await runMainGit(["worktree", "remove", "--force", wtPath]);
           } catch {
-            await fs11.promises.rm(wtPath, { recursive: true, force: true }).catch(() => {
+            await fs12.promises.rm(wtPath, { recursive: true, force: true }).catch(() => {
             });
           }
           swept++;
         }
-        await fs11.promises.rm(sessionPath, { recursive: true, force: true }).catch(() => {
+        await fs12.promises.rm(sessionPath, { recursive: true, force: true }).catch(() => {
         });
       }
       if (swept > 0) {
@@ -5191,7 +5255,7 @@ var init_workflow = __esm({
 
 // ../core/src/tool/tsHost.ts
 import fsSync3 from "fs";
-import path15 from "path";
+import path16 from "path";
 var _ts, _tsTried, getTs, buildDefaultOptions, findTsConfigBounded, resolveTsConfig, createProjectHost, lsCache, getLanguageService, realpathNative, posToLineCol, SUPPORTED_SOURCE_EXTS, checkSupportedSourceExt, lineColToPos;
 var init_tsHost = __esm({
   "../core/src/tool/tsHost.ts"() {
@@ -5224,16 +5288,16 @@ var init_tsHost = __esm({
       strict: false
     });
     findTsConfigBounded = (ts, absPath) => {
-      const root = path15.resolve(getContainingRoot(absPath));
-      let dir = path15.dirname(absPath);
+      const root = path16.resolve(getContainingRoot(absPath));
+      let dir = path16.dirname(absPath);
       while (true) {
-        const candidate = path15.join(dir, "tsconfig.json");
+        const candidate = path16.join(dir, "tsconfig.json");
         try {
           if (fsSync3.existsSync(candidate)) return candidate;
         } catch {
         }
-        if (path15.resolve(dir) === root) break;
-        const parent = path15.dirname(dir);
+        if (path16.resolve(dir) === root) break;
+        const parent = path16.dirname(dir);
         if (parent === dir) break;
         dir = parent;
       }
@@ -5244,7 +5308,7 @@ var init_tsHost = __esm({
       if (!tsConfigPath) {
         return { options: buildDefaultOptions(ts), fileNames: [], projectRoot: getContainingRoot(absPath) };
       }
-      const basePath = path15.dirname(tsConfigPath);
+      const basePath = path16.dirname(tsConfigPath);
       const raw = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
       if (raw.error) return { options: buildDefaultOptions(ts), fileNames: [], projectRoot: basePath };
       const parsed = ts.parseJsonConfigFileContent(raw.config, ts.sys, basePath);
@@ -5255,7 +5319,7 @@ var init_tsHost = __esm({
       const roots = /* @__PURE__ */ new Set();
       const caseSensitive = ts.sys.useCaseSensitiveFileNames;
       const canonical = (f) => caseSensitive ? f : f.toLowerCase();
-      const keyOf = (f) => canonical(path15.resolve(f)).replace(/\\/g, "/");
+      const keyOf = (f) => canonical(path16.resolve(f)).replace(/\\/g, "/");
       rootFileNames.forEach((f) => roots.add(keyOf(f)));
       const fresh = (fileName) => {
         const key = keyOf(fileName);
@@ -5340,7 +5404,7 @@ var init_tsHost = __esm({
     };
     SUPPORTED_SOURCE_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
     checkSupportedSourceExt = (displayPath) => {
-      const ext = path15.extname(displayPath).toLowerCase();
+      const ext = path16.extname(displayPath).toLowerCase();
       if (SUPPORTED_SOURCE_EXTS.has(ext)) return null;
       return `\u274C [\u6587\u4EF6\u7C7B\u578B\u4E0D\u652F\u6301]\uFF1A[${displayPath}] \u7684\u6269\u5C55\u540D ${ext || "(\u65E0)"} \u4E0D\u5728 TS \u5F15\u64CE\u652F\u6301\u8303\u56F4\uFF08\u4EC5 .ts/.tsx/.js/.jsx/.mjs/.cjs\uFF09\u3002\u8BF7\u6539\u7528 read_file/grep \u67E5\u770B\u5185\u5BB9\uFF1B\u7F16\u8BD1/\u7C7B\u578B\u7C7B\u9A8C\u8BC1\u7528 run_command \u8DD1\u5BF9\u5E94\u8BED\u8A00\u5DE5\u5177\u94FE\uFF08\u5982 mvn compile / tsc --noEmit\uFF09\u3002`;
     };
@@ -5349,8 +5413,8 @@ var init_tsHost = __esm({
 });
 
 // ../core/src/tool/registry/fs.ts
-import fs12 from "fs/promises";
-import path16 from "path";
+import fs13 from "fs/promises";
+import path17 from "path";
 import { createReadStream } from "fs";
 import * as readline from "readline";
 var isSensitiveReadTarget, stripReadFileLineNumbers, maskSecretsInContent, makeTmpPath, ATOMIC_TMP_RE, sweepStaleAtomicTmp, assertReadable, stripEdgeBlankLines, matchLineBlockWith, diagnoseOldStr, reindentToBase, alignIndentsByAnchor, applyOneEditToContent, fsTools;
@@ -5406,21 +5470,21 @@ var init_fs = __esm({
       const walk = async (dir) => {
         let entries;
         try {
-          entries = await fs12.readdir(dir, { withFileTypes: true });
+          entries = await fs13.readdir(dir, { withFileTypes: true });
         } catch {
           return;
         }
         for (const e of entries) {
-          const full = path16.join(dir, e.name);
+          const full = path17.join(dir, e.name);
           if (e.isDirectory()) {
             if (!skipDirs.has(e.name)) await walk(full);
             continue;
           }
           if (!e.isFile() || !ATOMIC_TMP_RE.test(e.name)) continue;
           try {
-            const st = await fs12.stat(full);
+            const st = await fs13.stat(full);
             if (st.mtimeMs > cutoff) continue;
-            await fs12.unlink(full);
+            await fs13.unlink(full);
             removed++;
           } catch {
           }
@@ -5682,11 +5746,11 @@ ${formattedCode}${hasMore ? `
               await initializeWorkspaceIgnore();
               const buildTreeText = async (currentPath, currentDepth, prefix = "") => {
                 if (currentDepth > maxDepth || hitScanLimit) return "";
-                const entries = await fs12.readdir(currentPath, { withFileTypes: true });
+                const entries = await fs13.readdir(currentPath, { withFileTypes: true });
                 const validEntries = entries.filter((entry) => {
                   if (entry.isSymbolicLink()) return false;
-                  const fullPath = path16.join(currentPath, entry.name);
-                  const relPath = path16.relative(getActiveWorkspaceRoot(), fullPath).replace(/\\/g, "/");
+                  const fullPath = path17.join(currentPath, entry.name);
+                  const relPath = path17.relative(getActiveWorkspaceRoot(), fullPath).replace(/\\/g, "/");
                   return !checkIsPathIgnored(entry.isDirectory() ? `${relPath}/` : relPath);
                 });
                 let output = "";
@@ -5705,7 +5769,7 @@ ${formattedCode}${hasMore ? `
 `;
                   if (entry.isDirectory()) {
                     const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
-                    const fullPath = path16.join(currentPath, entry.name);
+                    const fullPath = path17.join(currentPath, entry.name);
                     const subTree = await buildTreeText(fullPath, currentDepth + 1, nextPrefix);
                     output += subTree;
                   }
@@ -5769,7 +5833,7 @@ ${patches}`;
                 return `\u274C [\u53C2\u6570\u7F3A\u5931]\uFF1A\u8BF7\u4F20\u5165 edits \u6570\u7EC4\uFF08\u6BCF\u6761\u542B old_str/new_str\uFF09\u4E00\u6B21\u5B8C\u6210\u591A\u5904\u4FEE\u6539\uFF0C\u6216\u9876\u5C42 old_str + new_str \u4FEE\u6539\u5355\u5904\u3002old_str \u4E0D\u80FD\u4E3A\u7A7A\u3002`;
               }
               const absPath = resolveSafePath(args.path);
-              const rawContent = await fs12.readFile(absPath, "utf-8");
+              const rawContent = await fs13.readFile(absPath, "utf-8");
               const isCRLF = rawContent.includes("\r\n");
               let content = rawContent.replace(/\r\n/g, "\n");
               const summaries = [];
@@ -5782,7 +5846,7 @@ ${patches}`;
                 summaries.push(editList.length === 1 ? r.summary : `  ${i + 1}. ${r.summary}`);
               }
               assertWithinWorkspace(absPath);
-              await fs12.writeFile(absPath, isCRLF ? content.replace(/\n/g, "\r\n") : content, "utf-8");
+              await fs13.writeFile(absPath, isCRLF ? content.replace(/\n/g, "\r\n") : content, "utf-8");
               return editList.length === 1 ? `\u2705 [\u4EE3\u7801\u4FEE\u8865\u6210\u529F]\uFF1A\u6587\u4EF6 [${args.path}] ${summaries[0]}` : `\u2705 [\u4EE3\u7801\u4FEE\u8865\u6210\u529F]\uFF1A\u6587\u4EF6 [${args.path}] \u5DF2\u6309\u5E8F\u5B8C\u6210 ${editList.length} \u5904\u4FEE\u6539\uFF08\u5355\u6B21\u539F\u5B50\u5199\u5165\uFF09\uFF1A
 ${summaries.join("\n")}`;
             } catch (error) {
@@ -5812,24 +5876,24 @@ ${summaries.join("\n")}`;
             try {
               const absPath = resolveSafePath(args.path);
               try {
-                await fs12.access(absPath);
+                await fs13.access(absPath);
                 return `\u274C [\u521B\u5EFA\u5931\u8D25]\uFF1A\u6587\u4EF6 [${args.path}] \u5DF2\u5B58\u5728\u3002create_file \u4EC5\u7528\u4E8E\u65B0\u5EFA\u6587\u4EF6\uFF1B\u5982\u9700\u4FEE\u6539\u8BF7\u7528 edit_file\uFF0C\u5982\u9700\u8986\u76D6\u8BF7\u7528 write_file\u3002`;
               } catch (e) {
                 if (e?.code !== "ENOENT") throw e;
               }
               const content = args.content ?? "";
               assertWithinWorkspace(absPath);
-              await fs12.mkdir(path16.dirname(absPath), { recursive: true });
+              await fs13.mkdir(path17.dirname(absPath), { recursive: true });
               tmpPath = makeTmpPath(absPath);
-              await fs12.writeFile(tmpPath, content, "utf-8");
-              await fs12.rename(tmpPath, absPath);
+              await fs13.writeFile(tmpPath, content, "utf-8");
+              await fs13.rename(tmpPath, absPath);
               return `\u2705 [\u521B\u5EFA\u6210\u529F]\uFF1A\u65B0\u6587\u4EF6 [${args.path}] \u5DF2\u521B\u5EFA\uFF0C\u5199\u5165 ${content.length} \u5B57\u7B26\u3002`;
             } catch (error) {
               return `\u64CD\u4F5C\u5931\u8D25: ${error.message}`;
             } finally {
               if (tmpPath) {
                 try {
-                  await fs12.unlink(tmpPath);
+                  await fs13.unlink(tmpPath);
                 } catch {
                 }
               }
@@ -5858,7 +5922,7 @@ ${summaries.join("\n")}`;
             }
             let rel = "";
             try {
-              rel = path16.relative(getActiveWorkspaceRoot(), resolveSafePath(cleanPath));
+              rel = path17.relative(getActiveWorkspaceRoot(), resolveSafePath(cleanPath));
             } catch {
             }
             if (rel === "" || rel === "src") {
@@ -5866,7 +5930,7 @@ ${summaries.join("\n")}`;
             }
             let label = "\u6587\u4EF6\u6216\u76EE\u5F55";
             try {
-              const stat = await fs12.stat(resolveSafePath(cleanPath));
+              const stat = await fs13.stat(resolveSafePath(cleanPath));
               label = stat.isDirectory() ? "\u4E00\u6574\u4E2A\u6587\u4EF6\u5939\u76EE\u5F55" : "\u7EAF\u7269\u7406\u6587\u4EF6";
             } catch {
             }
@@ -5879,22 +5943,22 @@ ${summaries.join("\n")}`;
                 return `\u274C [\u5B89\u5168\u7194\u65AD]\uFF1A\u7981\u6B62\u901A\u8FC7\u672C\u5DE5\u5177\u76F4\u63A5\u6467\u6BC1\u9879\u76EE\u6839\u76EE\u5F55\u6216\u4F20\u5165\u7A7A\u8DEF\u5F84\uFF01`;
               }
               const absPath = resolveSafePath(cleanPath);
-              const rel = path16.relative(getActiveWorkspaceRoot(), absPath);
-              if (!rel || rel === "" || rel === "src" || rel.startsWith("..") || path16.isAbsolute(rel)) {
+              const rel = path17.relative(getActiveWorkspaceRoot(), absPath);
+              if (!rel || rel === "" || rel === "src" || rel.startsWith("..") || path17.isAbsolute(rel)) {
                 return `\u274C [\u5B89\u5168\u7194\u65AD]\uFF1A\u62D2\u7EDD\u9500\u6BC1\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 / src \u6E90\u7801\u6839 / \u8D8A\u754C\u8DEF\u5F84 [${cleanPath}]\uFF01`;
               }
               let stat;
               try {
-                stat = await fs12.stat(absPath);
+                stat = await fs13.stat(absPath);
               } catch {
                 return `\u274C [\u9500\u6BC1\u5931\u8D25]\uFF1A\u5728\u5DE5\u4F5C\u533A\u5185\u672A\u627E\u5230\u6307\u5B9A\u7684\u8DEF\u5F84 [${cleanPath}]\u3002`;
               }
               const isDirectory = stat.isDirectory();
               assertWithinWorkspace(absPath);
               if (isDirectory) {
-                await fs12.rm(absPath, { recursive: true, force: true });
+                await fs13.rm(absPath, { recursive: true, force: true });
               } else {
-                await fs12.unlink(absPath);
+                await fs13.unlink(absPath);
               }
               const targetTypeLabel = isDirectory ? "\u4E00\u6574\u4E2A\u6587\u4EF6\u5939\u76EE\u5F55" : "\u7EAF\u7269\u7406\u6587\u4EF6";
               return `\u2705 [\u8DEF\u5F84\u9500\u6BC1\u6210\u529F]\uFF1A\u5DF2\u6210\u529F\u6C38\u4E45\u9500\u6BC1${targetTypeLabel} [${cleanPath}]\u3002`;
@@ -5925,15 +5989,15 @@ ${summaries.join("\n")}`;
             try {
               const absPath = resolveSafePath(args.path);
               assertWithinWorkspace(absPath);
-              await fs12.mkdir(path16.dirname(absPath), { recursive: true });
+              await fs13.mkdir(path17.dirname(absPath), { recursive: true });
               tmpPath = makeTmpPath(absPath);
-              await fs12.writeFile(tmpPath, args.content, "utf-8");
-              await fs12.rename(tmpPath, absPath);
+              await fs13.writeFile(tmpPath, args.content, "utf-8");
+              await fs13.rename(tmpPath, absPath);
               return `\u2705 [\u6587\u4EF6\u5199\u5165\u6210\u529F]\uFF1A\u5DF2\u5168\u91CF\u5199\u5165 [${args.path}]\uFF08${args.content.length} \u5B57\u7B26\uFF09\u3002`;
             } catch (error) {
               if (tmpPath) {
                 try {
-                  await fs12.unlink(tmpPath);
+                  await fs13.unlink(tmpPath);
                 } catch {
                 }
               }
@@ -5964,11 +6028,11 @@ ${summaries.join("\n")}`;
               if (readBlock) return readBlock;
               const extBlock = checkSupportedSourceExt(args.path);
               if (extBlock) return extBlock;
-              const statForSize = await fs12.stat(absPath);
+              const statForSize = await fs13.stat(absPath);
               if (statForSize.size > 1024 * 1024) {
                 return `\u26A0\uFE0F [\u6587\u4EF6\u8FC7\u5927]\uFF1A[${args.path}] \u7EA6 ${Math.round(statForSize.size / 1024)}KB\uFF0C\u8D85\u8FC7\u7B26\u53F7\u5927\u7EB2\u5206\u6790\u7684 1MB \u4E0A\u9650\uFF08\u9632\u5168\u91CF readFile + AST \u9A7B\u7559\u5403\u5185\u5B58\uFF09\u3002\u8BF7\u6539\u7528 read_file \u5206\u7247\u67E5\u770B\uFF0C\u6216\u7F29\u5C0F\u76EE\u6807\u6587\u4EF6\u3002`;
               }
-              const fileContent = await fs12.readFile(absPath, "utf-8");
+              const fileContent = await fs13.readFile(absPath, "utf-8");
               const TS = await getTs();
               if (!TS) {
                 return `\u26A0\uFE0F [\u7B26\u53F7\u5927\u7EB2\u4E0D\u53EF\u7528]\uFF1Atypescript \u6A21\u5757\u672A\u5B89\u88C5\uFF08CLI \u53D1\u5E03\u7248\u672A\u5185\u8054\uFF09\u3002\u8BF7\u6539\u7528 read_file \u67E5\u770B\u6587\u4EF6\u5185\u5BB9\u3002`;
@@ -6050,19 +6114,19 @@ ${summaries.join("\n")}`;
               const srcAbs = resolveSafePath(args.source);
               const dstAbs = resolveSafePath(args.destination);
               try {
-                await fs12.access(srcAbs);
+                await fs13.access(srcAbs);
               } catch {
                 return `\u274C [\u79FB\u52A8\u5931\u8D25]\uFF1A\u6E90\u8DEF\u5F84 [${args.source}] \u4E0D\u5B58\u5728\u3002`;
               }
               try {
-                await fs12.access(dstAbs);
+                await fs13.access(dstAbs);
                 return `\u274C [\u79FB\u52A8\u5931\u8D25]\uFF1A\u76EE\u6807 [${args.destination}] \u5DF2\u5B58\u5728\u3002\u5982\u9700\u8986\u76D6\u8BF7\u5148 delete_path \u518D move_file\u3002`;
               } catch {
               }
               assertWithinWorkspace(srcAbs);
               assertWithinWorkspace(dstAbs);
-              await fs12.mkdir(path16.dirname(dstAbs), { recursive: true });
-              await fs12.rename(srcAbs, dstAbs);
+              await fs13.mkdir(path17.dirname(dstAbs), { recursive: true });
+              await fs13.rename(srcAbs, dstAbs);
               return `\u2705 [\u79FB\u52A8\u6210\u529F]\uFF1A[${args.source}] \u2192 [${args.destination}]\u3002`;
             } catch (error) {
               return `\u64CD\u4F5C\u5931\u8D25: ${error.message}`;
@@ -6076,8 +6140,8 @@ ${summaries.join("\n")}`;
 
 // ../core/src/tool/registry/search.ts
 import { rgPath } from "vscode-ripgrep";
-import path17 from "path";
-import fs13 from "fs/promises";
+import path18 from "path";
+import fs14 from "fs/promises";
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -6119,10 +6183,10 @@ var init_search = __esm({
               const resolveSearchRoot = () => {
                 if (!args.path) return ctx?.cwd ?? getActiveWorkspaceRoot();
                 const p = args.path.trim();
-                const looksLikeBareName = !path17.isAbsolute(p) && !p.includes("/") && !p.includes("\\");
+                const looksLikeBareName = !path18.isAbsolute(p) && !p.includes("/") && !p.includes("\\");
                 if (looksLikeBareName) {
                   const hit = getAllowedWorkspaceRoots().find((r) => {
-                    const bn = path17.basename(r);
+                    const bn = path18.basename(r);
                     return bn === p || bn.toLowerCase() === p.toLowerCase();
                   });
                   if (hit) return hit;
@@ -6211,7 +6275,7 @@ var init_search = __esm({
             const GUIDE_CANDIDATES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"];
             for (const name of GUIDE_CANDIDATES) {
               try {
-                const content = await fs13.readFile(path17.join(getActiveWorkspaceRoot(), name), "utf-8");
+                const content = await fs14.readFile(path18.join(getActiveWorkspaceRoot(), name), "utf-8");
                 return `[Project Guide via ${name}]
 
 ${content}`;
@@ -6498,8 +6562,8 @@ ${AUTO_BG_NOTICE}
 });
 
 // ../core/src/tool/registry/glob.ts
-import fs14 from "fs/promises";
-import path18 from "path";
+import fs15 from "fs/promises";
+import path19 from "path";
 var findMatchingBrace, splitTopLevel, globToRegex2, globTools;
 var init_glob = __esm({
   "../core/src/tool/registry/glob.ts"() {
@@ -6603,18 +6667,18 @@ var init_glob = __esm({
               const MAX_SCAN_LIMIT = 1e4;
               const scan = async (dir) => {
                 if (scannedCount > MAX_SCAN_LIMIT) return;
-                const entries = await fs14.readdir(dir, { withFileTypes: true });
+                const entries = await fs15.readdir(dir, { withFileTypes: true });
                 const validEntries = entries.filter((e) => {
-                  const full = path18.join(dir, e.name);
-                  const rel = path18.relative(activeRoot, full).replace(/\\/g, "/");
+                  const full = path19.join(dir, e.name);
+                  const rel = path19.relative(activeRoot, full).replace(/\\/g, "/");
                   return !checkIsPathIgnored(e.isDirectory() ? `${rel}/` : rel);
                 });
                 for (const e of validEntries) {
                   scannedCount++;
                   if (scannedCount > MAX_SCAN_LIMIT) break;
                   if (e.isSymbolicLink()) continue;
-                  const full = path18.join(dir, e.name);
-                  const rel = path18.relative(activeRoot, full).replace(/\\/g, "/");
+                  const full = path19.join(dir, e.name);
+                  const rel = path19.relative(activeRoot, full).replace(/\\/g, "/");
                   if (e.isDirectory()) {
                     if (cleanPattern.endsWith("/") && re.test(`${rel}/`)) {
                       hits.push(`${rel}/`);
@@ -6830,8 +6894,8 @@ ${summary}`;
 });
 
 // ../core/src/tool/registry/inspect_dependencies.ts
-import * as fs15 from "fs/promises";
-import * as path19 from "path";
+import * as fs16 from "fs/promises";
+import * as path20 from "path";
 var dependencyTools;
 var init_inspect_dependencies = __esm({
   "../core/src/tool/registry/inspect_dependencies.ts"() {
@@ -6852,8 +6916,8 @@ var init_inspect_dependencies = __esm({
           isSync: true,
           async execute() {
             try {
-              const pjsPath = path19.join(getActiveWorkspaceRoot(), "package.json");
-              const raw = await fs15.readFile(pjsPath, "utf-8");
+              const pjsPath = path20.join(getActiveWorkspaceRoot(), "package.json");
+              const raw = await fs16.readFile(pjsPath, "utf-8");
               const pjs = JSON.parse(raw);
               const result = {
                 dependencies: pjs.dependencies || {},
@@ -7495,8 +7559,8 @@ var init_http = __esm({
 });
 
 // ../core/src/tool/registry/typescript.ts
-import fs16 from "fs/promises";
-import path20 from "path";
+import fs17 from "fs/promises";
+import path21 from "path";
 var MAX_FILE_BYTES, toDisplayPath, isLibFile, precheck, MAX_DIAG_ENTRIES, MAX_DIAG_FILES, MAX_REF_ENTRIES, REF_SNIPPET_MAX, diagnoseOneFile, typescriptTools;
 var init_typescript = __esm({
   "../core/src/tool/registry/typescript.ts"() {
@@ -7507,8 +7571,8 @@ var init_typescript = __esm({
     init_fs();
     MAX_FILE_BYTES = 1024 * 1024;
     toDisplayPath = (wsRoot, abs) => {
-      const rel = path20.relative(wsRoot, abs);
-      if (rel && !rel.startsWith("..") && !path20.isAbsolute(rel)) return rel.replace(/\\/g, "/");
+      const rel = path21.relative(wsRoot, abs);
+      if (rel && !rel.startsWith("..") && !path21.isAbsolute(rel)) return rel.replace(/\\/g, "/");
       return abs.replace(/\\/g, "/").split("/").slice(-3).join("/");
     };
     isLibFile = (abs) => /(?:^|\/)node_modules\//.test(abs.replace(/\\/g, "/")) || /\.d\.ts$/i.test(abs);
@@ -7517,7 +7581,7 @@ var init_typescript = __esm({
       if (readBlock) return readBlock;
       const extBlock = checkSupportedSourceExt(displayPath);
       if (extBlock) return extBlock;
-      const stat = await fs16.stat(absPath);
+      const stat = await fs17.stat(absPath);
       if (stat.size > MAX_FILE_BYTES) {
         return `\u26A0\uFE0F [\u6587\u4EF6\u8FC7\u5927]\uFF1A[${displayPath}] \u7EA6 ${Math.round(stat.size / 1024)}KB\uFF0C\u8D85\u8FC7 ${MAX_FILE_BYTES / 1024}KB \u4E0A\u9650\uFF08\u9632\u5168\u91CF type-check \u5403\u5185\u5B58\uFF09\u3002`;
       }
@@ -7733,7 +7797,7 @@ ${out.join("\n")}`;
                 let lines = lineTextCache.get(abs);
                 if (!lines) {
                   try {
-                    lines = (await fs16.readFile(abs, "utf-8")).split(/\r?\n/);
+                    lines = (await fs17.readFile(abs, "utf-8")).split(/\r?\n/);
                   } catch {
                     lines = [];
                   }
@@ -7862,8 +7926,8 @@ var init_todo = __esm({
 });
 
 // ../core/src/observability/traceCalculate.ts
-import fs17 from "fs/promises";
-import path21 from "path";
+import fs18 from "fs/promises";
+import path22 from "path";
 var getDirBytes, getTodayDateString;
 var init_traceCalculate = __esm({
   "../core/src/observability/traceCalculate.ts"() {
@@ -7875,17 +7939,17 @@ var init_traceCalculate = __esm({
         const cur = stack.pop();
         let entries;
         try {
-          entries = await fs17.readdir(cur, { withFileTypes: true });
+          entries = await fs18.readdir(cur, { withFileTypes: true });
         } catch {
           continue;
         }
         for (const e of entries) {
-          const p = path21.join(cur, e.name);
+          const p = path22.join(cur, e.name);
           if (e.isDirectory()) {
             stack.push(p);
           } else {
             try {
-              total += (await fs17.stat(p)).size;
+              total += (await fs18.stat(p)).size;
             } catch {
             }
           }
@@ -7904,8 +7968,8 @@ var init_traceCalculate = __esm({
 });
 
 // ../core/src/tool/undo/store.ts
-import path22 from "path";
-import fs18 from "fs/promises";
+import path23 from "path";
+import fs19 from "fs/promises";
 var getUndoRootPath, getUndoClockPath, getUndoDirPath, getUndoBackupRoot, ensureUndoDir, getUndoIndexPath;
 var init_store2 = __esm({
   "../core/src/tool/undo/store.ts"() {
@@ -7913,33 +7977,33 @@ var init_store2 = __esm({
     init_config();
     init_common();
     init_traceCalculate();
-    getUndoRootPath = () => path22.join(appConfig.dataDir, "undo");
-    getUndoClockPath = () => path22.join(getUndoRootPath(), "undo-cleanup-clock.json");
+    getUndoRootPath = () => path23.join(appConfig.dataDir, "undo");
+    getUndoClockPath = () => path23.join(getUndoRootPath(), "undo-cleanup-clock.json");
     getUndoDirPath = (mainSessionId) => {
       const rootId = getFileName(mainSessionId);
       assertSafeSessionId(rootId, "undoSessionId");
-      return path22.join(getUndoRootPath(), appConfig.userWorkspaceDir, rootId);
+      return path23.join(getUndoRootPath(), appConfig.userWorkspaceDir, rootId);
     };
-    getUndoBackupRoot = (mainSessionId) => path22.join(getUndoDirPath(mainSessionId), "backups");
+    getUndoBackupRoot = (mainSessionId) => path23.join(getUndoDirPath(mainSessionId), "backups");
     ensureUndoDir = async (mainSessionId) => {
-      await fs18.mkdir(getUndoDirPath(mainSessionId), { recursive: true, mode: 448 });
+      await fs19.mkdir(getUndoDirPath(mainSessionId), { recursive: true, mode: 448 });
     };
     getUndoIndexPath = async (mainSessionId) => {
       const rootId = getFileName(mainSessionId);
       assertSafeSessionId(rootId, "undoSessionId");
       const dir = getUndoDirPath(mainSessionId);
-      await fs18.mkdir(dir, { recursive: true, mode: 448 });
-      const files = await fs18.readdir(dir);
+      await fs19.mkdir(dir, { recursive: true, mode: 448 });
+      const files = await fs19.readdir(dir);
       const existedFile = files.find((f) => f.endsWith(`__${rootId}.jsonl`));
       const fileName = existedFile ?? `undo-${getTodayDateString()}__${rootId}.jsonl`;
-      return path22.join(dir, fileName);
+      return path23.join(dir, fileName);
     };
   }
 });
 
 // ../core/src/tool/undo/index.ts
-import fs19 from "fs/promises";
-import path23 from "path";
+import fs20 from "fs/promises";
+import path24 from "path";
 var undoLocks, withUndoLock, appendUndoRecord, readUndoIndex, markRestored;
 var init_undo = __esm({
   "../core/src/tool/undo/index.ts"() {
@@ -7969,7 +8033,7 @@ var init_undo = __esm({
         };
         const p = await getUndoIndexPath(sessionId);
         const line = JSON.stringify(enriched) + "\n";
-        await fs19.appendFile(p, line, { encoding: "utf-8", mode: 384 });
+        await fs20.appendFile(p, line, { encoding: "utf-8", mode: 384 });
       });
     };
     readUndoIndex = async (sessionId) => {
@@ -7981,7 +8045,7 @@ var init_undo = __esm({
       }
       let files;
       try {
-        files = await fs19.readdir(dir);
+        files = await fs20.readdir(dir);
       } catch {
         return [];
       }
@@ -7989,7 +8053,7 @@ var init_undo = __esm({
       for (const f of files) {
         if (!f.startsWith("undo-") || !f.endsWith(".jsonl")) continue;
         try {
-          const raw = await fs19.readFile(path23.join(dir, f), "utf-8");
+          const raw = await fs20.readFile(path24.join(dir, f), "utf-8");
           for (const line of raw.split("\n")) {
             const trimmed = line.trim();
             if (!trimmed) continue;
@@ -8014,16 +8078,16 @@ var init_undo = __esm({
         }
         let files;
         try {
-          files = await fs19.readdir(dir);
+          files = await fs20.readdir(dir);
         } catch {
           return;
         }
         for (const f of files) {
           if (!f.startsWith("undo-") || !f.endsWith(".jsonl")) continue;
-          const fp = path23.join(dir, f);
+          const fp = path24.join(dir, f);
           let raw;
           try {
-            raw = await fs19.readFile(fp, "utf-8");
+            raw = await fs20.readFile(fp, "utf-8");
           } catch {
             continue;
           }
@@ -8047,8 +8111,8 @@ var init_undo = __esm({
           if (changed) {
             const content = lines.join("\n").replace(/\n*$/, "\n");
             const tmp = fp + ".tmp";
-            await fs19.writeFile(tmp, content, { encoding: "utf-8", mode: 384 });
-            await fs19.rename(tmp, fp);
+            await fs20.writeFile(tmp, content, { encoding: "utf-8", mode: 384 });
+            await fs20.rename(tmp, fp);
           }
         }
       });
@@ -8057,8 +8121,8 @@ var init_undo = __esm({
 });
 
 // ../core/src/tool/undo/cleanup.ts
-import fs20 from "fs/promises";
-import path24 from "path";
+import fs21 from "fs/promises";
+import path25 from "path";
 async function maybeCleanupAfterUndoAppend(_sessionId) {
   if (cleanupInProgress) return;
   cleanupInProgress = true;
@@ -8084,8 +8148,8 @@ async function maybeCleanupAfterUndoAppend(_sessionId) {
     lastSizeCleanupAt = now;
     diskLastCleanupAt = now;
     const clockPath = getUndoClockPath();
-    await fs20.mkdir(path24.dirname(clockPath), { recursive: true });
-    await fs20.writeFile(clockPath, JSON.stringify({ lastCleanupAt: now, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+    await fs21.mkdir(path25.dirname(clockPath), { recursive: true });
+    await fs21.writeFile(clockPath, JSON.stringify({ lastCleanupAt: now, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
     if (deleted > 0) console.log(`\u2728 [Undo\u8FD0\u7EF4] \u5171\u9500\u6BC1 ${deleted} \u4E2A undo \u8D44\u4EA7\uFF08\u7D22\u5F15 + \u5B64\u513F\u5185\u5BB9\uFF09\uFF0C\u78C1\u76D8\u6C34\u4F4D\u56DE\u843D\u3002`);
   } catch (e) {
     console.warn("\u26A0\uFE0F [Undo\u8FD0\u7EF4] \u81EA\u52A8\u6E05\u7406\u5F02\u5E38\uFF0C\u5DF2\u8DF3\u8FC7:", e?.message ?? e);
@@ -8102,23 +8166,23 @@ async function cleanupOldUndoFiles() {
   const now = Date.now();
   let relativePaths;
   try {
-    relativePaths = await fs20.readdir(dir, { recursive: true });
+    relativePaths = await fs21.readdir(dir, { recursive: true });
   } catch {
     return 0;
   }
   const re = /^undo-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   let deleted = 0;
   for (const rp of relativePaths) {
-    const fileName = path24.basename(rp);
+    const fileName = path25.basename(rp);
     const m = fileName.match(re);
     if (!m) continue;
     const fileBornDay = /* @__PURE__ */ new Date(`${m[1]}T00:00:00`);
     if (fileBornDay >= cutoff) continue;
-    const fullPath = path24.join(dir, rp);
+    const fullPath = path25.join(dir, rp);
     try {
-      const st = await fs20.stat(fullPath);
+      const st = await fs21.stat(fullPath);
       if (now - st.mtimeMs < ACTIVE_GRACE_MS) continue;
-      await fs20.unlink(fullPath);
+      await fs21.unlink(fullPath);
       deleted += 1;
     } catch {
     }
@@ -8129,17 +8193,17 @@ async function evictOldestForSize(targetBytes) {
   const dir = getUndoRootPath();
   let relativePaths;
   try {
-    relativePaths = await fs20.readdir(dir, { recursive: true });
+    relativePaths = await fs21.readdir(dir, { recursive: true });
   } catch {
     return 0;
   }
   const re = /^undo-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   const candidates = [];
   for (const rp of relativePaths) {
-    if (!re.test(path24.basename(rp))) continue;
+    if (!re.test(path25.basename(rp))) continue;
     try {
-      const st = await fs20.stat(path24.join(dir, rp));
-      candidates.push({ mtime: st.mtimeMs, fullPath: path24.join(dir, rp), size: st.size });
+      const st = await fs21.stat(path25.join(dir, rp));
+      candidates.push({ mtime: st.mtimeMs, fullPath: path25.join(dir, rp), size: st.size });
     } catch {
     }
   }
@@ -8149,7 +8213,7 @@ async function evictOldestForSize(targetBytes) {
   for (const c of candidates) {
     if (totalBytes <= targetBytes) break;
     try {
-      await fs20.unlink(c.fullPath);
+      await fs21.unlink(c.fullPath);
       totalBytes -= c.size;
       deleted += 1;
     } catch {
@@ -8163,38 +8227,38 @@ async function gcOrphanBackups() {
   let deleted = 0;
   let workspaces;
   try {
-    workspaces = await fs20.readdir(root);
+    workspaces = await fs21.readdir(root);
   } catch {
     return 0;
   }
   for (const ws of workspaces) {
-    const wsDir = path24.join(root, ws);
+    const wsDir = path25.join(root, ws);
     let stWs;
     try {
-      stWs = await fs20.stat(wsDir);
+      stWs = await fs21.stat(wsDir);
     } catch {
       continue;
     }
     if (!stWs.isDirectory()) continue;
     let sessions2;
     try {
-      sessions2 = await fs20.readdir(wsDir);
+      sessions2 = await fs21.readdir(wsDir);
     } catch {
       continue;
     }
     for (const sess of sessions2) {
-      const sessDir = path24.join(wsDir, sess);
+      const sessDir = path25.join(wsDir, sess);
       const liveIds = /* @__PURE__ */ new Set();
       let files;
       try {
-        files = await fs20.readdir(sessDir);
+        files = await fs21.readdir(sessDir);
       } catch {
         continue;
       }
       for (const f of files) {
         if (!f.startsWith("undo-") || !f.endsWith(".jsonl")) continue;
         try {
-          const raw = await fs20.readFile(path24.join(sessDir, f), "utf-8");
+          const raw = await fs21.readFile(path25.join(sessDir, f), "utf-8");
           for (const line of raw.split("\n")) {
             const t = line.trim();
             if (!t) continue;
@@ -8207,17 +8271,17 @@ async function gcOrphanBackups() {
         } catch {
         }
       }
-      const backupsDir = path24.join(sessDir, "backups");
+      const backupsDir = path25.join(sessDir, "backups");
       let undoDirs;
       try {
-        undoDirs = await fs20.readdir(backupsDir);
+        undoDirs = await fs21.readdir(backupsDir);
       } catch {
         continue;
       }
       for (const ud of undoDirs) {
         if (liveIds.has(ud)) continue;
         try {
-          await fs20.rm(path24.join(backupsDir, ud), { recursive: true, force: true });
+          await fs21.rm(path25.join(backupsDir, ud), { recursive: true, force: true });
           deleted += 1;
         } catch {
         }
@@ -8245,7 +8309,7 @@ var init_cleanup = __esm({
       if (clockLoaded) return;
       clockLoaded = true;
       try {
-        const rawClock = await fs20.readFile(getUndoClockPath(), "utf-8");
+        const rawClock = await fs21.readFile(getUndoClockPath(), "utf-8");
         diskLastCleanupAt = JSON.parse(rawClock).lastCleanupAt || 0;
       } catch {
         diskLastCleanupAt = 0;
@@ -8255,17 +8319,17 @@ var init_cleanup = __esm({
       let total = 0;
       let entries;
       try {
-        entries = await fs20.readdir(dir, { withFileTypes: true });
+        entries = await fs21.readdir(dir, { withFileTypes: true });
       } catch {
         return 0;
       }
       for (const e of entries) {
-        const full = path24.join(dir, e.name);
+        const full = path25.join(dir, e.name);
         if (e.isDirectory()) {
           total += await getDirBytesRecursive(full);
         } else if (e.isFile()) {
           try {
-            total += (await fs20.stat(full)).size;
+            total += (await fs21.stat(full)).size;
           } catch {
           }
         }
@@ -8276,8 +8340,8 @@ var init_cleanup = __esm({
 });
 
 // ../core/src/tool/undo/backup.ts
-import fs21 from "fs/promises";
-import path25 from "path";
+import fs22 from "fs/promises";
+import path26 from "path";
 import crypto from "crypto";
 async function beforeMutationBackup(toolName, args, toolCallId, sessionId) {
   if (appConfig.undoEnabled === false) return null;
@@ -8292,7 +8356,7 @@ async function beforeMutationBackup(toolName, args, toolCallId, sessionId) {
   }
   await ensureUndoDir(sessionId);
   const undoId = createUUID();
-  const undoDir = path25.join(getUndoBackupRoot(sessionId), undoId);
+  const undoDir = path26.join(getUndoBackupRoot(sessionId), undoId);
   const now = /* @__PURE__ */ new Date();
   const common = {
     undoId,
@@ -8327,7 +8391,7 @@ async function backupFileOverwrite(common, undoDir, args) {
   const absPath = resolveSafePath(common.relativePath);
   let exists = true;
   try {
-    await fs21.access(absPath);
+    await fs22.access(absPath);
   } catch {
     exists = false;
   }
@@ -8335,15 +8399,15 @@ async function backupFileOverwrite(common, undoDir, args) {
     return { ...common, backupKind: "creation_marker", backupPath: "", fileSizeBefore: 0 };
   }
   assertWithinWorkspace(absPath);
-  const fileStat = await fs21.stat(absPath);
+  const fileStat = await fs22.stat(absPath);
   const maxPerOp = appConfig.undoMaxBytesPerOp ?? 100 * 1024 * 1024;
   if (fileStat.size > maxPerOp) {
     throw new Error(`\u6587\u4EF6 [${common.relativePath}] \u4F53\u79EF\u7EA6 ${fileStat.size} \u5B57\u8282\u8D85\u8FC7\u5355\u6B21\u5907\u4EFD\u4E0A\u9650 ${maxPerOp}\uFF0C\u5199\u5165\u5DF2\u963B\u65AD\uFF08\u9632\u5185\u5B58\u62D6\u57AE\uFF1B\u53EF\u8C03 undoMaxBytesPerOp\uFF09`);
   }
-  const content = await fs21.readFile(absPath);
-  await fs21.mkdir(undoDir, { recursive: true, mode: 448 });
-  const contentPath = path25.join(undoDir, "content");
-  await fs21.writeFile(contentPath, content, { mode: 384 });
+  const content = await fs22.readFile(absPath);
+  await fs22.mkdir(undoDir, { recursive: true, mode: 448 });
+  const contentPath = path26.join(undoDir, "content");
+  await fs22.writeFile(contentPath, content, { mode: 384 });
   return {
     ...common,
     backupKind: "file_content",
@@ -8362,9 +8426,9 @@ async function backupFileCreate(common) {
 }
 async function backupDelete(common, undoDir, relativePath) {
   const absPath = resolveSafePath(relativePath);
-  const st = await fs21.stat(absPath);
+  const st = await fs22.stat(absPath);
   assertWithinWorkspace(absPath);
-  await fs21.mkdir(undoDir, { recursive: true, mode: 448 });
+  await fs22.mkdir(undoDir, { recursive: true, mode: 448 });
   if (st.isDirectory()) {
     const treeBytes = await getDirTreeBytes(absPath);
     const maxPerOp2 = appConfig.undoMaxBytesPerOp ?? 100 * 1024 * 1024;
@@ -8379,15 +8443,15 @@ async function backupDelete(common, undoDir, relativePath) {
         throw new Error(`\u76EE\u5F55 [${relativePath}] \u5185\u542B\u654F\u611F\u6587\u4EF6 ${sensitiveInTree.length} \u4E2A\uFF08\u5982 ${sensitiveInTree[0]}\uFF09\uFF0C\u6309\u7B56\u7565(undoBackupSensitive=deny)\u62D2\u7EDD\u5907\u4EFD\uFF0C\u5199\u5165\u5DF2\u963B\u65AD`);
       }
     }
-    const treeDest = path25.join(undoDir, "tree");
+    const treeDest = path26.join(undoDir, "tree");
     const sensitiveSet = new Set(sensitiveInTree);
-    await fs21.cp(absPath, treeDest, {
+    await fs22.cp(absPath, treeDest, {
       recursive: true,
       force: true,
       preserveTimestamps: true,
       filter: (src) => {
         if (src === absPath) return true;
-        const relWithin = path25.relative(absPath, src).replace(/\\/g, "/");
+        const relWithin = path26.relative(absPath, src).replace(/\\/g, "/");
         return !sensitiveSet.has(relWithin);
       }
     });
@@ -8403,9 +8467,9 @@ async function backupDelete(common, undoDir, relativePath) {
   if (st.size > maxPerOp) {
     throw new Error(`\u6587\u4EF6 [${relativePath}] \u4F53\u79EF\u7EA6 ${st.size} \u5B57\u8282\u8D85\u8FC7\u5355\u6B21\u5907\u4EFD\u4E0A\u9650 ${maxPerOp}\uFF0C\u5199\u5165\u5DF2\u963B\u65AD\uFF08\u9632\u5185\u5B58\u62D6\u57AE\uFF1B\u53EF\u8C03 undoMaxBytesPerOp\uFF09`);
   }
-  const content = await fs21.readFile(absPath);
-  const contentPath = path25.join(undoDir, "content");
-  await fs21.writeFile(contentPath, content, { mode: 384 });
+  const content = await fs22.readFile(absPath);
+  const contentPath = path26.join(undoDir, "content");
+  await fs22.writeFile(contentPath, content, { mode: 384 });
   return {
     ...common,
     backupKind: "file_content",
@@ -8450,21 +8514,21 @@ var init_backup = __esm({
       const walk = async (d) => {
         let entries;
         try {
-          entries = await fs21.readdir(d, { withFileTypes: true });
+          entries = await fs22.readdir(d, { withFileTypes: true });
         } catch {
           return;
         }
         entries.sort((a, b) => a.name.localeCompare(b.name));
         for (const e of entries) {
-          const full = path25.join(d, e.name);
-          const rel = path25.relative(dir, full).replace(/\\/g, "/");
+          const full = path26.join(d, e.name);
+          const rel = path26.relative(dir, full).replace(/\\/g, "/");
           if (e.isDirectory()) {
             h.update(`D ${rel}
 `);
             await walk(full);
           } else if (e.isFile()) {
             try {
-              h.update(`F ${rel} ${sha1Buf(await fs21.readFile(full))}
+              h.update(`F ${rel} ${sha1Buf(await fs22.readFile(full))}
 `);
             } catch {
             }
@@ -8478,16 +8542,16 @@ var init_backup = __esm({
       let total = 0;
       let entries;
       try {
-        entries = await fs21.readdir(dir, { withFileTypes: true });
+        entries = await fs22.readdir(dir, { withFileTypes: true });
       } catch {
         return 0;
       }
       for (const e of entries) {
-        const full = path25.join(dir, e.name);
+        const full = path26.join(dir, e.name);
         if (e.isDirectory()) total += await getDirTreeBytes(full);
         else if (e.isFile()) {
           try {
-            total += (await fs21.stat(full)).size;
+            total += (await fs22.stat(full)).size;
           } catch {
           }
         }
@@ -8499,16 +8563,16 @@ var init_backup = __esm({
       const walk = async (d) => {
         let entries;
         try {
-          entries = await fs21.readdir(d, { withFileTypes: true });
+          entries = await fs22.readdir(d, { withFileTypes: true });
         } catch {
           return;
         }
         for (const e of entries) {
-          const full = path25.join(d, e.name);
+          const full = path26.join(d, e.name);
           if (e.isDirectory()) {
             await walk(full);
           } else if (e.isFile()) {
-            const relWithin = path25.relative(dir, full).replace(/\\/g, "/");
+            const relWithin = path26.relative(dir, full).replace(/\\/g, "/");
             if (isSensitivePath(`${wsRelDir}/${relWithin}`)) found.push(relWithin);
           }
         }
@@ -8520,15 +8584,15 @@ var init_backup = __esm({
 });
 
 // ../core/src/tool/undo/restore.ts
-import fs22 from "fs/promises";
-import path26 from "path";
+import fs23 from "fs/promises";
+import path27 from "path";
 import crypto2 from "crypto";
 async function doRestore(target, sessionId) {
   if (target.backupKind === "directory_tree") {
     const abs = resolveSafePath(target.relativePath);
     let exists = false;
     try {
-      await fs22.access(abs);
+      await fs23.access(abs);
       exists = true;
     } catch {
     }
@@ -8566,7 +8630,7 @@ async function ensureReverseBackup(target, sessionId) {
   }
   let exists = true;
   try {
-    await fs22.access(absPath);
+    await fs23.access(absPath);
   } catch {
     exists = false;
   }
@@ -8579,17 +8643,17 @@ async function ensureReverseBackup(target, sessionId) {
     }
   }
   const reverseId = createUUID();
-  const reverseDir = path26.join(getUndoBackupRoot(sessionId), reverseId);
-  await fs22.mkdir(reverseDir, { recursive: true, mode: 448 });
+  const reverseDir = path27.join(getUndoBackupRoot(sessionId), reverseId);
+  await fs23.mkdir(reverseDir, { recursive: true, mode: 448 });
   assertWithinWorkspace(absPath);
-  const st = await fs22.stat(absPath);
+  const st = await fs23.stat(absPath);
   if (st.isDirectory()) {
-    const dest2 = path26.join(reverseDir, "tree");
-    await fs22.cp(absPath, dest2, { recursive: true, force: true, preserveTimestamps: true });
+    const dest2 = path27.join(reverseDir, "tree");
+    await fs23.cp(absPath, dest2, { recursive: true, force: true, preserveTimestamps: true });
     return { reverseId, backupKind: "directory_tree", backupPath: dest2 };
   }
-  const dest = path26.join(reverseDir, "content");
-  await fs22.writeFile(dest, await fs22.readFile(absPath));
+  const dest = path27.join(reverseDir, "content");
+  await fs23.writeFile(dest, await fs23.readFile(absPath));
   return { reverseId, backupKind: "file_content", backupPath: dest };
 }
 async function dispatchRestore(r) {
@@ -8597,20 +8661,20 @@ async function dispatchRestore(r) {
   assertWithinWorkspace(absPath);
   switch (r.backupKind) {
     case "creation_marker": {
-      await fs22.rm(absPath, { force: true });
+      await fs23.rm(absPath, { force: true });
       return `\u5DF2\u5220\u9664\u65B0\u5EFA\u6587\u4EF6 [${r.relativePath}]`;
     }
     case "file_content": {
-      await fs22.mkdir(path26.dirname(absPath), { recursive: true });
-      const backupAbs = path26.join(getUndoBackupRoot(r.sessionId), r.undoId, "content");
-      const content = await fs22.readFile(backupAbs);
-      await fs22.writeFile(absPath, content);
+      await fs23.mkdir(path27.dirname(absPath), { recursive: true });
+      const backupAbs = path27.join(getUndoBackupRoot(r.sessionId), r.undoId, "content");
+      const content = await fs23.readFile(backupAbs);
+      await fs23.writeFile(absPath, content);
       return `\u5DF2\u6062\u590D [${r.relativePath}] \u81F3\u5907\u4EFD\u524D\u5185\u5BB9\uFF08${r.fileSizeBefore ?? content.byteLength} \u5B57\u8282\uFF09`;
     }
     case "directory_tree": {
-      await fs22.mkdir(path26.dirname(absPath), { recursive: true });
-      const src = path26.join(getUndoBackupRoot(r.sessionId), r.undoId, "tree");
-      await fs22.cp(src, absPath, { recursive: true, force: true, preserveTimestamps: true });
+      await fs23.mkdir(path27.dirname(absPath), { recursive: true });
+      const src = path27.join(getUndoBackupRoot(r.sessionId), r.undoId, "tree");
+      await fs23.cp(src, absPath, { recursive: true, force: true, preserveTimestamps: true });
       return `\u5DF2\u6062\u590D\u76EE\u5F55\u6811 [${r.relativePath}]\uFF08\u7EA6 ${r.fileSizeBefore ?? 0} \u5B57\u8282\uFF09`;
     }
   }
@@ -8643,7 +8707,7 @@ var init_restore = __esm({
     init_common();
     init_traceCalculate();
     sha1File = async (absPath) => {
-      const buf = await fs22.readFile(absPath);
+      const buf = await fs23.readFile(absPath);
       return crypto2.createHash("sha1").update(buf).digest("hex");
     };
     listUndoable = async (sessionId) => {
@@ -8917,7 +8981,7 @@ ${diff.slice(0, 1500)}` : "";
 });
 
 // ../core/src/tool/registry/notebook.ts
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 var toArraySource, encodeSource, makeCell, applyNotebookEdit, notebookTools;
 var init_notebook = __esm({
   "../core/src/tool/registry/notebook.ts"() {
@@ -9018,7 +9082,7 @@ ${String(args.new_source).slice(0, 500)}` : ""}`,
             }
             let raw;
             try {
-              raw = await fs23.readFile(absPath, "utf-8");
+              raw = await fs24.readFile(absPath, "utf-8");
             } catch (e) {
               return `\u274C [notebook_edit] \u8BFB\u53D6\u5931\u8D25\uFF1A${e?.message ?? e}`;
             }
@@ -9048,10 +9112,10 @@ ${String(args.new_source).slice(0, 500)}` : ""}`,
             }
             const tmpPath = makeTmpPath(absPath);
             try {
-              await fs23.writeFile(tmpPath, JSON.stringify(nb, null, 2), "utf-8");
-              await fs23.rename(tmpPath, absPath);
+              await fs24.writeFile(tmpPath, JSON.stringify(nb, null, 2), "utf-8");
+              await fs24.rename(tmpPath, absPath);
             } catch (e) {
-              await fs23.unlink(tmpPath).catch(() => {
+              await fs24.unlink(tmpPath).catch(() => {
               });
               return `\u274C [notebook_edit] \u5199\u5165\u5931\u8D25\uFF1A${e?.message ?? e}`;
             }
@@ -9091,8 +9155,8 @@ var init_frontmatter = __esm({
 });
 
 // ../core/src/memory/loader.ts
-import fs24 from "fs/promises";
-import path27 from "path";
+import fs25 from "fs/promises";
+import path28 from "path";
 var GLOBAL_MEMORY_DIR, SOURCES, VALID_TYPES, parseMemoryAt, loadMemories, initMemories;
 var init_loader3 = __esm({
   "../core/src/memory/loader.ts"() {
@@ -9101,16 +9165,16 @@ var init_loader3 = __esm({
     init_frontmatter();
     init_registry6();
     init_registry2();
-    GLOBAL_MEMORY_DIR = path27.join(appConfig.dataDir, "memory");
+    GLOBAL_MEMORY_DIR = path28.join(appConfig.dataDir, "memory");
     SOURCES = [
       { dir: GLOBAL_MEMORY_DIR, source: "global" },
-      { dir: path27.join(process.cwd(), ".deepseeker-code", "memory"), source: "project" }
+      { dir: path28.join(process.cwd(), ".deepseeker-code", "memory"), source: "project" }
     ];
     VALID_TYPES = ["user", "feedback", "project", "reference"];
     parseMemoryAt = async (file, _dir, source) => {
       let raw;
       try {
-        raw = await fs24.readFile(file, "utf-8");
+        raw = await fs25.readFile(file, "utf-8");
       } catch {
         return null;
       }
@@ -9144,7 +9208,7 @@ var init_loader3 = __esm({
       clearMemories();
       const picked = await scanSources(
         filterSources(SOURCES, includeProject),
-        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path27.join(dir, e.name) : void 0,
+        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path28.join(dir, e.name) : void 0,
         parseMemoryAt
       );
       for (const { item } of picked) registerMemory(item);
@@ -9162,8 +9226,8 @@ var init_loader3 = __esm({
 });
 
 // ../core/src/tool/registry/memory.ts
-import fs25 from "fs/promises";
-import path28 from "path";
+import fs26 from "fs/promises";
+import path29 from "path";
 var MAX_BODY_BYTES, NAME_RE, VALID_TYPES2, memoryFilePath, sanitizeLine, buildMemoryMd, writeAndRegister, memoryTools;
 var init_memory = __esm({
   "../core/src/tool/registry/memory.ts"() {
@@ -9175,7 +9239,7 @@ var init_memory = __esm({
     MAX_BODY_BYTES = 64 * 1024;
     NAME_RE = /^[a-z0-9-]+$/;
     VALID_TYPES2 = ["user", "feedback", "project", "reference"];
-    memoryFilePath = (name, project) => project ? path28.join(process.cwd(), ".deepseeker-code", "memory", `${name}.md`) : path28.join(GLOBAL_MEMORY_DIR, `${name}.md`);
+    memoryFilePath = (name, project) => project ? path29.join(process.cwd(), ".deepseeker-code", "memory", `${name}.md`) : path29.join(GLOBAL_MEMORY_DIR, `${name}.md`);
     sanitizeLine = (s) => String(s ?? "").replace(/[\r\n]+/g, " ").trim();
     buildMemoryMd = (name, description, type, body) => `---
 name: ${name}
@@ -9187,10 +9251,10 @@ ${body.trim()}
 `;
     writeAndRegister = async (name, description, type, body, project) => {
       const file = memoryFilePath(name, project);
-      await fs25.mkdir(path28.dirname(file), { recursive: true });
+      await fs26.mkdir(path29.dirname(file), { recursive: true });
       const tmp = makeTmpPath(file);
-      await fs25.writeFile(tmp, buildMemoryMd(name, description, type, body), "utf-8");
-      await fs25.rename(tmp, file);
+      await fs26.writeFile(tmp, buildMemoryMd(name, description, type, body), "utf-8");
+      await fs26.rename(tmp, file);
       registerMemory({ name, description, type, body: body.trim(), source: project ? "project" : "global", file });
       return file;
     };
@@ -9306,7 +9370,7 @@ ${lines.join("\n")}`;
             const m = getMemory(name);
             if (!m) return `\u274C \u672A\u627E\u5230\u8BB0\u5FC6\uFF1A${name}\uFF08\u53EF\u80FD\u5DF2\u88AB\u5220\u9664\uFF09\u3002`;
             try {
-              await fs25.unlink(m.file);
+              await fs26.unlink(m.file);
             } catch {
             }
             unregisterMemory(name);
@@ -9319,8 +9383,8 @@ ${lines.join("\n")}`;
 });
 
 // ../core/src/tool/registry/recall.ts
-import fs26 from "fs/promises";
-import path29 from "path";
+import fs27 from "fs/promises";
+import path30 from "path";
 var escapeRegExp2, lineText, primaryPathArg, annotateStaleness, snippetAround, recallTools;
 var init_recall = __esm({
   "../core/src/tool/registry/recall.ts"() {
@@ -9351,9 +9415,9 @@ var init_recall = __esm({
     annotateStaleness = async (args, observedAt) => {
       const p = primaryPathArg(args);
       if (!p) return "\u5FEB\u7167\uFF08\u65E0\u8DEF\u5F84\u5B9E\u4F53\uFF0C\u672A\u7ECF\u91CD\u9A8C\u2014\u2014\u636E\u4EE5\u884C\u52A8\u524D\u8BF7\u91CD\u8DD1\u9A8C\u8BC1\uFF09";
-      const abs = path29.isAbsolute(p) ? p : path29.resolve(getActiveWorkspaceRoot(), p);
+      const abs = path30.isAbsolute(p) ? p : path30.resolve(getActiveWorkspaceRoot(), p);
       try {
-        const st = await fs26.stat(abs);
+        const st = await fs27.stat(abs);
         if (observedAt && st.mtime.toISOString() > observedAt) {
           return `\u26A0\uFE0F \u89C2\u5BDF\u540E\u8BE5\u6587\u4EF6\u5DF2\u88AB\u4FEE\u6539\uFF08${p}\uFF09\u2014\u2014\u5FC5\u987B\u91CD\u65B0 read_file \u540E\u624D\u80FD\u636E\u4EE5\u4FEE\u6539`;
         }
@@ -9398,10 +9462,10 @@ var init_recall = __esm({
               if (args.with_full) {
                 const safeId = String(args.with_full).replace(/[^A-Za-z0-9_-]/g, "");
                 if (!safeId) return "\u274C [recall] with_full \u542B\u975E\u6CD5\u5B57\u7B26\u3002";
-                const sidecar = path29.join(getSessionsDirPath(ctx.sessionId), "tool-outputs", `${safeId}.txt`);
+                const sidecar = path30.join(getSessionsDirPath(ctx.sessionId), "tool-outputs", `${safeId}.txt`);
                 let full = "";
                 try {
-                  full = await fs26.readFile(sidecar, "utf-8");
+                  full = await fs27.readFile(sidecar, "utf-8");
                 } catch {
                   return `\u274C [recall] \u672A\u627E\u5230\u8BE5 id \u7684\u5B58\u6863\u539F\u6587\uFF08\u53EF\u80FD\u672A\u66FE\u89E6\u53D1\u622A\u65AD\u5B58\u6863\u3001\u6216\u4F1A\u8BDD\u5DF2\u6E05\u7406\uFF09\uFF1A${args.with_full}`;
                 }
@@ -9610,7 +9674,7 @@ var init_spreadsheet = __esm({
 });
 
 // ../core/src/tool/registry/document.ts
-import fs27 from "fs/promises";
+import fs28 from "fs/promises";
 var getMammoth, getUnpdf, documentTools;
 var init_document = __esm({
   "../core/src/tool/registry/document.ts"() {
@@ -9700,7 +9764,7 @@ var init_document = __esm({
               }
               const start = args.start_char ? Math.max(0, Math.floor(args.start_char)) : 0;
               const maxChars = Math.min(args.max_chars ? Math.max(1, Math.floor(args.max_chars)) : 3e4, 5e4);
-              const buf = await fs27.readFile(absPath);
+              const buf = await fs28.readFile(absPath);
               const unpdf = await getUnpdf();
               const pdf = await unpdf.getDocumentProxy(new Uint8Array(buf));
               const { text, totalPages } = await unpdf.extractText(pdf, { mergePages: true });
@@ -9906,7 +9970,7 @@ var init_backgroundTool = __esm({
 });
 
 // ../core/src/tool/autoPermission.ts
-import path30 from "path";
+import path31 from "path";
 var AUTO_SCOPE, AUTO_DEFAULT_EXTRA, AUTO_AGGRESSIVE_EXTRA, isMcpTool, BUILTIN_AUTO_DENY, matchBuiltinDeny, COMMAND_DENY, matchCommandDeny, hasShellMetachars, READONLY_HEADS, PKG_MGR, SCRIPT_RUNNER_HEADS, SCRIPT_RUNNER_READONLY, isScriptRunnerCommand, hasWriteModifier, SENSITIVE_FILE_ARG_RE, hasSensitiveFileArg, isReadOnlyCommand, isWithinWorkspace, runAutoCheck;
 var init_autoPermission = __esm({
   "../core/src/tool/autoPermission.ts"() {
@@ -10054,9 +10118,9 @@ var init_autoPermission = __esm({
     isWithinWorkspace = (p, cwd) => {
       if (!p || !cwd) return false;
       try {
-        const abs = path30.isAbsolute(p) ? p : path30.resolve(cwd, p);
-        const rel = path30.relative(cwd, abs);
-        return rel === "" || !rel.startsWith("..") && !path30.isAbsolute(rel);
+        const abs = path31.isAbsolute(p) ? p : path31.resolve(cwd, p);
+        const rel = path31.relative(cwd, abs);
+        return rel === "" || !rel.startsWith("..") && !path31.isAbsolute(rel);
       } catch {
         return false;
       }
@@ -10084,8 +10148,8 @@ var init_autoPermission = __esm({
 });
 
 // ../core/src/agent/toolExecution.ts
-import fs28 from "fs/promises";
-import path31 from "path";
+import fs29 from "fs/promises";
+import path32 from "path";
 var applyPrivacyMasking, processToolCall;
 var init_toolExecution = __esm({
   "../core/src/agent/toolExecution.ts"() {
@@ -10225,7 +10289,7 @@ var init_toolExecution = __esm({
         const argCwd = typeof calledArgs?.cwd === "string" ? calledArgs.cwd.trim() : "";
         const samePath = (a, b) => {
           try {
-            const ra = path31.resolve(a), rb = path31.resolve(b);
+            const ra = path32.resolve(a), rb = path32.resolve(b);
             return process.platform === "win32" ? ra.toLowerCase() === rb.toLowerCase() : ra === rb;
           } catch {
             return false;
@@ -10340,10 +10404,10 @@ ${result}`;
       const truncBudget = matchedTool?.function?.maxOutputCharacters ?? appConfig.MAX_TOOL_RESULT_CHARS;
       if (result.length > truncBudget) {
         try {
-          const sidecarDir = path31.join(getSessionsDirPath(sessionId), "tool-outputs");
-          await fs28.mkdir(sidecarDir, { recursive: true });
+          const sidecarDir = path32.join(getSessionsDirPath(sessionId), "tool-outputs");
+          await fs29.mkdir(sidecarDir, { recursive: true });
           const safeId = String(toolCall.id).replace(/[^A-Za-z0-9_-]/g, "");
-          await fs28.writeFile(path31.join(sidecarDir, `${safeId}.txt`), result, "utf-8");
+          await fs29.writeFile(path32.join(sidecarDir, `${safeId}.txt`), result, "utf-8");
           sidecarNote = `\u5B8C\u6574\u539F\u6587\u5DF2\u5B58\u6863\uFF0Crecall \u5DE5\u5177\u4F20 with_full="${toolCall.id}" \u53EF\u53D6\u56DE`;
         } catch (e) {
           console.warn(`\u26A0\uFE0F [sidecar] \u5DE5\u5177\u539F\u6587\u5B58\u6863\u5931\u8D25\uFF08\u5DF2\u964D\u7EA7\u4E3A\u666E\u901A\u622A\u65AD\u63D0\u793A\uFF09:`, e instanceof Error ? e.message : e);
@@ -10494,6 +10558,8 @@ var init_streamInference = __esm({
     init_transcript();
     init_contextCore();
     init_contentParts();
+    init_visionCapability();
+    init_createModel();
     sha1short = (s) => createHash2("sha1").update(s).digest("hex").slice(0, 10);
     RETRY_BACKOFF_CAP_MS = 3e4;
     extractRetryAfterMs = (e) => {
@@ -10567,6 +10633,7 @@ var init_streamInference = __esm({
         const MAX_API_RETRIES = 3;
         let apiRetries = 0;
         let compactedThisRound = false;
+        let visionDegradedThisRound = false;
         for (let streamAttempt = 0; ; streamAttempt++) {
           try {
             for await (const chunk of activeProvider.streamChat(inferenceMessages, cleanedToolSchemas, { signal, model, thinkingLevel })) {
@@ -10667,6 +10734,26 @@ var init_streamInference = __esm({
               lastUsage = void 0;
               continue;
             }
+            if (activeProvider.isImageUnsupportedError(streamErr) && noOutputYet && !visionDegradedThisRound) {
+              const effModel = typeof model === "string" && model.trim() ? model.trim() : MODEL_NAME;
+              learnVisionCapability(effModel, false);
+              for (let i = 0; i < message.length; i++) message[i] = collapseToText(message[i], VISION_DEGRADE_NOTE);
+              inferenceMessages = withNudgeTail(message, nudgeMsg);
+              visionDegradedThisRound = true;
+              events({
+                sessionId,
+                eventType: "llm.visionDowngraded",
+                metadata: { depth, decisionSource: llmDecisionSource, ok: true, round, model: effModel },
+                payload: { output: streamErr instanceof Error ? streamErr.message : String(streamErr) }
+              });
+              yield { type: "vision.downgraded", model: effModel };
+              console.warn(`\u26A0\uFE0F \u6A21\u578B ${effModel} \u4E0D\u652F\u6301\u56FE\u7247\u8F93\u5165\uFF08API ${streamErr?.status ?? "?"}\uFF09\uFF0C\u5DF2\u81EA\u52A8\u964D\u7EA7\u4E3A\u6587\u672C\u5360\u4F4D\u5E76\u91CD\u8BD5\uFF08\u80FD\u529B\u5DF2\u8BB0\u4F4F\uFF0C\u540E\u7EED\u6D88\u606F\u76F4\u63A5\u6309\u6587\u672C\u53D1\u9001\uFF09`);
+              contentBuf = "";
+              reasoningBuf = "";
+              toolCallsBuf.clear();
+              lastUsage = void 0;
+              continue;
+            }
             throw streamErr;
           }
         }
@@ -11242,7 +11329,7 @@ var init_recovery = __esm({
 });
 
 // ../core/src/session/content.ts
-var decayOldToolResults, NO_VISION_IMAGE_NOTE, enforceVisionGate, buildContextMessages;
+var decayOldToolResults, enforceVisionGate, buildContextMessages;
 var init_content = __esm({
   "../core/src/session/content.ts"() {
     "use strict";
@@ -11251,6 +11338,7 @@ var init_content = __esm({
     init_transcript();
     init_store();
     init_config();
+    init_visionCapability();
     init_recovery();
     decayOldToolResults = (msgs) => {
       const units = groupUnits(msgs);
@@ -11281,9 +11369,9 @@ var init_content = __esm({
         return replaceImageParts(mm, "[\u5386\u53F2\u56FE\u7247\u5DF2\u6298\u53E0\uFF1A\u539F\u56FE\u4ECD\u5728\u4F1A\u8BDD\u5F52\u6863\u4E2D\uFF0C\u5982\u9700\u518D\u6B21\u67E5\u770B\u8BF7\u91CD\u65B0\u63D0\u4F9B\u8BE5\u56FE\u7247]");
       });
     };
-    NO_VISION_IMAGE_NOTE = "[\u56FE\u7247\u672A\u9001\u8FBE\uFF1A\u5F53\u524D\u6A21\u578B\u65E0\u89C6\u89C9\u80FD\u529B\uFF0C\u770B\u4E0D\u5230\u8BE5\u56FE\uFF1B\u539F\u56FE\u4FDD\u7559\u5728\u4F1A\u8BDD\u5F52\u6863\u4E2D\uFF0C\u5982\u9700\u5206\u6790\u8BF7\u8BA9\u7528\u6237\u91CD\u65B0\u63D0\u4F9B\u6216\u5207\u6362 vision \u6A21\u578B]";
-    enforceVisionGate = (msgs, modelId) => isVisionEnabled(modelId) ? msgs : msgs.map((m) => collapseToText(m, NO_VISION_IMAGE_NOTE));
+    enforceVisionGate = (msgs, modelId) => isVisionEnabled(modelId) ? msgs : msgs.map((m) => collapseToText(m, VISION_DEGRADE_NOTE));
     buildContextMessages = async (sessionId, currentUserMsg, systemPrompt, modelId) => {
+      await ensureVisionCacheLoaded();
       const lines = await readTranscriptLines(sessionId);
       const store = await getRollingState(sessionId);
       const eventAware = appConfig.transcriptEvents || lines.some(isEventLine);
@@ -11313,7 +11401,7 @@ var init_content = __esm({
 });
 
 // ../core/src/session/lineage.ts
-import fs29 from "node:fs";
+import fs30 from "node:fs";
 var parentOfSubsession, stringAncestorsOf, readForkedFromSync, lineageClosureOf, ownerCanApprove;
 var init_lineage = __esm({
   "../core/src/session/lineage.ts"() {
@@ -11336,7 +11424,7 @@ var init_lineage = __esm({
     };
     readForkedFromSync = (sessionId) => {
       try {
-        const raw = fs29.readFileSync(getStatePath(sessionId), "utf-8");
+        const raw = fs30.readFileSync(getStatePath(sessionId), "utf-8");
         const v = JSON.parse(raw)?.forkedFrom;
         return typeof v === "string" && v.length > 0 ? v : void 0;
       } catch {
@@ -11533,8 +11621,8 @@ var init_subagent = __esm({
 });
 
 // ../core/src/hooks/loader.ts
-import fs30 from "fs/promises";
-import path32 from "path";
+import fs31 from "fs/promises";
+import path33 from "path";
 var readHooksConfig, appendValidated, validateRule, parseStdoutDecision, parseAgentDecision, compileRule2, loadHooks, initHooks;
 var init_loader4 = __esm({
   "../core/src/hooks/loader.ts"() {
@@ -11549,15 +11637,15 @@ var init_loader4 = __esm({
     readHooksConfig = async (includeProject) => {
       const merged = {};
       const paths = [
-        path32.join(appConfig.dataDir, "settings.json"),
+        path33.join(appConfig.dataDir, "settings.json"),
         // 全局用户级
-        ...includeProject ? [path32.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
+        ...includeProject ? [path33.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
         // 项目级（叠加）；未信任时省略
       ];
       for (const configPath of paths) {
         let raw;
         try {
-          raw = await fs30.readFile(configPath, "utf-8");
+          raw = await fs31.readFile(configPath, "utf-8");
         } catch {
           continue;
         }
@@ -11888,8 +11976,8 @@ ${m.context}`;
 });
 
 // ../core/src/skills/loader.ts
-import fs31 from "fs/promises";
-import path33 from "path";
+import fs32 from "fs/promises";
+import path34 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var BUILTIN_DIR, SOURCES2, MAX_SKILL_BODY_BYTES, splitList, parseSkillAt, loadSkills, initSkills;
 var init_loader5 = __esm({
@@ -11900,18 +11988,18 @@ var init_loader5 = __esm({
     init_registry3();
     init_skill();
     init_registry2();
-    BUILTIN_DIR = path33.join(path33.dirname(fileURLToPath2(import.meta.url)), "builtin");
+    BUILTIN_DIR = path34.join(path34.dirname(fileURLToPath2(import.meta.url)), "builtin");
     SOURCES2 = [
       { dir: BUILTIN_DIR, source: "builtin" },
-      { dir: path33.join(appConfig.dataDir, "skills"), source: "global" },
-      { dir: path33.join(process.cwd(), ".deepseeker-code", "skills"), source: "project" }
+      { dir: path34.join(appConfig.dataDir, "skills"), source: "global" },
+      { dir: path34.join(process.cwd(), ".deepseeker-code", "skills"), source: "project" }
     ];
     MAX_SKILL_BODY_BYTES = 64 * 1024;
     splitList = (raw) => (raw ?? "").split(",").map((s) => s.trim()).filter(Boolean);
     parseSkillAt = async (skillFile, dir, source) => {
       let raw;
       try {
-        raw = await fs31.readFile(skillFile, "utf-8");
+        raw = await fs32.readFile(skillFile, "utf-8");
       } catch {
         return null;
       }
@@ -11950,7 +12038,7 @@ var init_loader5 = __esm({
     loadSkills = async (includeProject) => {
       const picked = await scanSources(
         filterSources(SOURCES2, includeProject),
-        (e, dir) => e.isDirectory() ? path33.join(dir, e.name, "SKILL.md") : void 0,
+        (e, dir) => e.isDirectory() ? path34.join(dir, e.name, "SKILL.md") : void 0,
         parseSkillAt
       );
       for (const { item } of picked) registerSkill(item);
@@ -11981,8 +12069,8 @@ var init_loader5 = __esm({
 });
 
 // ../core/src/agents/loader.ts
-import fs32 from "fs/promises";
-import path34 from "path";
+import fs33 from "fs/promises";
+import path35 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var BUILTIN_DIR2, SOURCES3, parseAgentAt, initAgents;
 var init_loader6 = __esm({
@@ -11992,16 +12080,16 @@ var init_loader6 = __esm({
     init_frontmatter();
     init_registry4();
     init_registry2();
-    BUILTIN_DIR2 = path34.join(path34.dirname(fileURLToPath3(import.meta.url)), "builtin");
+    BUILTIN_DIR2 = path35.join(path35.dirname(fileURLToPath3(import.meta.url)), "builtin");
     SOURCES3 = [
       { dir: BUILTIN_DIR2, source: "builtin" },
-      { dir: path34.join(appConfig.dataDir, "agents"), source: "global" },
-      { dir: path34.join(process.cwd(), ".deepseeker-code", "agents"), source: "project" }
+      { dir: path35.join(appConfig.dataDir, "agents"), source: "global" },
+      { dir: path35.join(process.cwd(), ".deepseeker-code", "agents"), source: "project" }
     ];
     parseAgentAt = async (file, dir, source) => {
       let raw;
       try {
-        raw = await fs32.readFile(file, "utf-8");
+        raw = await fs33.readFile(file, "utf-8");
       } catch {
         return null;
       }
@@ -12036,7 +12124,7 @@ var init_loader6 = __esm({
         const known = new Set(into.map((t) => t.function.name));
         const picked = await scanSources(
           filterSources(SOURCES3, includeProject),
-          (e, dir) => e.isFile() && e.name.endsWith(".agent.md") ? path34.join(dir, e.name) : void 0,
+          (e, dir) => e.isFile() && e.name.endsWith(".agent.md") ? path35.join(dir, e.name) : void 0,
           parseAgentAt
         );
         for (const { item: m, file, source } of picked) {
@@ -12073,8 +12161,8 @@ var init_registry7 = __esm({
 });
 
 // ../core/src/commands/loader.ts
-import fs33 from "fs/promises";
-import path35 from "path";
+import fs34 from "fs/promises";
+import path36 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var BUILTIN_DIR3, SOURCES4, MAX_COMMAND_BODY_BYTES, parseCommandAt, loadCommands, initCommands;
 var init_loader7 = __esm({
@@ -12084,17 +12172,17 @@ var init_loader7 = __esm({
     init_frontmatter();
     init_registry7();
     init_registry2();
-    BUILTIN_DIR3 = path35.join(path35.dirname(fileURLToPath4(import.meta.url)), "builtin");
+    BUILTIN_DIR3 = path36.join(path36.dirname(fileURLToPath4(import.meta.url)), "builtin");
     SOURCES4 = [
       { dir: BUILTIN_DIR3, source: "builtin" },
-      { dir: path35.join(appConfig.dataDir, "commands"), source: "global" },
-      { dir: path35.join(process.cwd(), ".deepseeker-code", "commands"), source: "project" }
+      { dir: path36.join(appConfig.dataDir, "commands"), source: "global" },
+      { dir: path36.join(process.cwd(), ".deepseeker-code", "commands"), source: "project" }
     ];
     MAX_COMMAND_BODY_BYTES = 64 * 1024;
     parseCommandAt = async (file, _dir, source) => {
       let raw;
       try {
-        raw = await fs33.readFile(file, "utf-8");
+        raw = await fs34.readFile(file, "utf-8");
       } catch {
         return null;
       }
@@ -12105,7 +12193,7 @@ var init_loader7 = __esm({
       }
       const name = parsed.frontmatter.name;
       const description = parsed.frontmatter.description;
-      const fallbackName = path35.basename(file, ".md");
+      const fallbackName = path36.basename(file, ".md");
       const finalName = name || fallbackName;
       if (!description) {
         console.warn(`\u26A0\uFE0F [commands] \u7F3A\u5C11 description\uFF08${file}\uFF09\uFF0C\u5DF2\u8DF3\u8FC7`);
@@ -12131,7 +12219,7 @@ var init_loader7 = __esm({
     loadCommands = async (includeProject) => {
       const picked = await scanSources(
         filterSources(SOURCES4, includeProject),
-        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path35.join(dir, e.name) : void 0,
+        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path36.join(dir, e.name) : void 0,
         parseCommandAt
       );
       for (const { item } of picked) registerCommand(item);
@@ -12149,8 +12237,8 @@ var init_loader7 = __esm({
 });
 
 // ../core/src/outputStyles/loader.ts
-import fs34 from "fs/promises";
-import path36 from "path";
+import fs35 from "fs/promises";
+import path37 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var BUILTIN_DIR4, MAX_STYLE_BODY_BYTES, SOURCES5, parseStyleAt, loadOutputStyles, initOutputStyles;
 var init_loader8 = __esm({
@@ -12160,17 +12248,17 @@ var init_loader8 = __esm({
     init_frontmatter();
     init_registry5();
     init_registry2();
-    BUILTIN_DIR4 = path36.join(path36.dirname(fileURLToPath5(import.meta.url)), "builtin");
+    BUILTIN_DIR4 = path37.join(path37.dirname(fileURLToPath5(import.meta.url)), "builtin");
     MAX_STYLE_BODY_BYTES = 64 * 1024;
     SOURCES5 = [
       { dir: BUILTIN_DIR4, source: "builtin" },
-      { dir: path36.join(appConfig.dataDir, "output-styles"), source: "global" },
-      { dir: path36.join(process.cwd(), ".deepseeker-code", "output-styles"), source: "project" }
+      { dir: path37.join(appConfig.dataDir, "output-styles"), source: "global" },
+      { dir: path37.join(process.cwd(), ".deepseeker-code", "output-styles"), source: "project" }
     ];
     parseStyleAt = async (file, _dir, source) => {
       let raw;
       try {
-        raw = await fs34.readFile(file, "utf-8");
+        raw = await fs35.readFile(file, "utf-8");
       } catch {
         return null;
       }
@@ -12202,7 +12290,7 @@ var init_loader8 = __esm({
     loadOutputStyles = async (includeProject) => {
       const picked = await scanSources(
         filterSources(SOURCES5, includeProject),
-        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path36.join(dir, e.name) : void 0,
+        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path37.join(dir, e.name) : void 0,
         parseStyleAt
       );
       for (const { item } of picked) registerOutputStyle(item);
@@ -12283,8 +12371,8 @@ var init_bootstrap = __esm({
 });
 
 // ../core/src/statusLine/config.ts
-import fs35 from "fs/promises";
-import path37 from "path";
+import fs36 from "fs/promises";
+import path38 from "path";
 var parseBlock, readStatusLineConfig;
 var init_config2 = __esm({
   "../core/src/statusLine/config.ts"() {
@@ -12300,16 +12388,16 @@ var init_config2 = __esm({
     };
     readStatusLineConfig = async (includeProject) => {
       const paths = [
-        path37.join(appConfig.dataDir, "settings.json"),
+        path38.join(appConfig.dataDir, "settings.json"),
         // 全局用户级
-        ...includeProject ? [path37.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
+        ...includeProject ? [path38.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
         // 项目级（覆盖）；未信任时省略
       ];
       let result = null;
       for (const configPath of paths) {
         let raw;
         try {
-          raw = await fs35.readFile(configPath, "utf-8");
+          raw = await fs36.readFile(configPath, "utf-8");
         } catch {
           continue;
         }
@@ -12329,8 +12417,8 @@ var init_config2 = __esm({
 
 // ../core/src/statusLine/runner.ts
 import { spawn as spawn5 } from "child_process";
-import fs36 from "fs";
-import path38 from "path";
+import fs37 from "fs";
+import path39 from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var STATUSLINE_TIMEOUT_MS, cachedVersion, runStatusLine;
 var init_runner = __esm({
@@ -12339,16 +12427,16 @@ var init_runner = __esm({
     init_guard();
     STATUSLINE_TIMEOUT_MS = 3e3;
     try {
-      const here = path38.dirname(fileURLToPath6(import.meta.url));
+      const here = path39.dirname(fileURLToPath6(import.meta.url));
       const candidates = [
-        path38.join(here, "../../../package.json"),
+        path39.join(here, "../../../package.json"),
         // src/core/package.json
-        path38.join(here, "../../../../package.json")
+        path39.join(here, "../../../../package.json")
         // 仓库根 package.json
       ];
       for (const p of candidates) {
         try {
-          const pkg = JSON.parse(fs36.readFileSync(p, "utf-8"));
+          const pkg = JSON.parse(fs37.readFileSync(p, "utf-8"));
           if (typeof pkg.version === "string" && pkg.version) {
             cachedVersion = pkg.version;
             break;
@@ -12399,8 +12487,8 @@ var init_runner = __esm({
 });
 
 // ../core/src/observability/store.ts
-import path39 from "path";
-import fs37 from "fs/promises";
+import path40 from "path";
+import fs38 from "fs/promises";
 var getTraceDirPath, getTracePath, tracePathCache, ensuredTraceDirs, ensureTraceDir, getGlobalClockPath, getTraceStorePath;
 var init_store3 = __esm({
   "../core/src/observability/store.ts"() {
@@ -12410,21 +12498,21 @@ var init_store3 = __esm({
     init_common();
     getTraceDirPath = (mainTraceId) => {
       assertSafeSessionId(mainTraceId, "traceId");
-      return path39.join(appConfig.dataDir, "trace", appConfig.userWorkspaceDir, getFileName(mainTraceId));
+      return path40.join(appConfig.dataDir, "trace", appConfig.userWorkspaceDir, getFileName(mainTraceId));
     };
     getTracePath = () => {
-      return path39.join(appConfig.dataDir, "trace");
+      return path40.join(appConfig.dataDir, "trace");
     };
     tracePathCache = /* @__PURE__ */ new Map();
     ensuredTraceDirs = /* @__PURE__ */ new Set();
     ensureTraceDir = async (mainTraceId) => {
       const dir = getTraceDirPath(mainTraceId);
       if (ensuredTraceDirs.has(dir)) return;
-      await fs37.mkdir(dir, { recursive: true });
+      await fs38.mkdir(dir, { recursive: true });
       ensuredTraceDirs.add(dir);
     };
     getGlobalClockPath = () => {
-      return path39.join(getTracePath(), "trace-cleanup-clock.json");
+      return path40.join(getTracePath(), "trace-cleanup-clock.json");
     };
     getTraceStorePath = async (mainTraceId) => {
       assertSafeSessionId(mainTraceId, "traceId");
@@ -12433,7 +12521,7 @@ var init_store3 = __esm({
       if (cached2) return cached2;
       await ensureTraceDir(rootId);
       const dir = getTraceDirPath(rootId);
-      const files = await fs37.readdir(dir);
+      const files = await fs38.readdir(dir);
       const existedFile = files.find((f) => f.endsWith(`__${rootId}.jsonl`));
       let fileName = "";
       if (existedFile) {
@@ -12442,7 +12530,7 @@ var init_store3 = __esm({
         const todayStr = getTodayDateString();
         fileName = `trace-${todayStr}__${rootId}.jsonl`;
       }
-      const resolved = path39.join(dir, fileName);
+      const resolved = path40.join(dir, fileName);
       tracePathCache.set(rootId, resolved);
       return resolved;
     };
@@ -12450,8 +12538,8 @@ var init_store3 = __esm({
 });
 
 // ../core/src/observability/trace.ts
-import fs38 from "fs/promises";
-import path40 from "path";
+import fs39 from "fs/promises";
+import path41 from "path";
 async function emitTrace(base) {
   const event = {
     sessionId: base.sessionId,
@@ -12473,7 +12561,7 @@ async function emitTrace(base) {
 async function appendTraceEvent(event) {
   const p = await getTraceStorePath(event.sessionId);
   const line = JSON.stringify(event) + "\n";
-  await fs38.appendFile(p, line, "utf-8");
+  await fs39.appendFile(p, line, "utf-8");
   if (workspaceTraceBytes < 0) {
     workspaceTraceBytes = await getDirBytes(getTracePath());
   }
@@ -12505,8 +12593,8 @@ async function maybeCleanupAfterAppend(sessionId) {
     lastSizeCleanupAt2 = now;
     diskLastCleanupAt2 = now;
     const clockPath = getGlobalClockPath();
-    await fs38.mkdir(path40.dirname(clockPath), { recursive: true });
-    await fs38.writeFile(clockPath, JSON.stringify({ lastCleanupAt: now, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+    await fs39.mkdir(path41.dirname(clockPath), { recursive: true });
+    await fs39.writeFile(clockPath, JSON.stringify({ lastCleanupAt: now, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
     if (deletedCount > 0) {
       console.log(`\u2728 [Trace\u8FD0\u7EF4] \u5171\u9500\u6BC1 ${deletedCount} \u4E2A\u4F1A\u8BDD\u65E5\u5FD7\uFF08\u8F6F\u89C4\u5219\u8FC7\u671F\u6E05\u7406 + \u5BB9\u91CF\u786C\u9A71\u9010\uFF09\uFF0C\u78C1\u76D8\u6C34\u4F4D\u56DE\u843D\u3002`);
     }
@@ -12526,22 +12614,22 @@ async function cleanupOldTraceFiles() {
   let deleted = 0;
   let relativePaths;
   try {
-    relativePaths = await fs38.readdir(dir, { recursive: true });
+    relativePaths = await fs39.readdir(dir, { recursive: true });
   } catch {
     return 0;
   }
   const re = /^trace-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   for (const relativePath of relativePaths) {
-    const fileName = path40.basename(relativePath);
+    const fileName = path41.basename(relativePath);
     const m = fileName.match(re);
     if (!m) continue;
     const fileBornDay = /* @__PURE__ */ new Date(`${m[1]}T00:00:00`);
     if (fileBornDay >= cutoff) continue;
-    const fullPath = path40.join(dir, relativePath);
+    const fullPath = path41.join(dir, relativePath);
     try {
-      const st = await fs38.stat(fullPath);
+      const st = await fs39.stat(fullPath);
       if (now - st.mtimeMs < ACTIVE_GRACE_MS2) continue;
-      await fs38.unlink(fullPath);
+      await fs39.unlink(fullPath);
       deleted += 1;
     } catch {
     }
@@ -12552,18 +12640,18 @@ async function evictOldestForSize2(targetBytes) {
   const dir = getTracePath();
   let relativePaths;
   try {
-    relativePaths = await fs38.readdir(dir, { recursive: true });
+    relativePaths = await fs39.readdir(dir, { recursive: true });
   } catch {
     return 0;
   }
   const re = /^trace-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   const candidates = [];
   for (const relativePath of relativePaths) {
-    const fileName = path40.basename(relativePath);
+    const fileName = path41.basename(relativePath);
     if (!re.test(fileName)) continue;
     try {
-      const st = await fs38.stat(path40.join(dir, relativePath));
-      candidates.push({ mtime: st.mtimeMs, fullPath: path40.join(dir, relativePath), size: st.size });
+      const st = await fs39.stat(path41.join(dir, relativePath));
+      candidates.push({ mtime: st.mtimeMs, fullPath: path41.join(dir, relativePath), size: st.size });
     } catch {
     }
   }
@@ -12573,7 +12661,7 @@ async function evictOldestForSize2(targetBytes) {
   for (const c of candidates) {
     if (totalBytes <= targetBytes) break;
     try {
-      await fs38.unlink(c.fullPath);
+      await fs39.unlink(c.fullPath);
       totalBytes -= c.size;
       deleted += 1;
     } catch {
@@ -12605,7 +12693,7 @@ var init_trace = __esm({
       if (clockLoaded2) return;
       clockLoaded2 = true;
       try {
-        const rawClock = await fs38.readFile(getGlobalClockPath(), "utf-8");
+        const rawClock = await fs39.readFile(getGlobalClockPath(), "utf-8");
         diskLastCleanupAt2 = JSON.parse(rawClock).lastCleanupAt || 0;
       } catch {
         diskLastCleanupAt2 = 0;
@@ -12752,8 +12840,8 @@ ${PLAN_MODE_AUTO_ENTER_HINT}
 });
 
 // ../core/src/serve/chatProcessing.ts
-import path41 from "path";
-import fs39 from "fs";
+import path42 from "path";
+import fs40 from "fs";
 var handleUnifiedChat;
 var init_chatProcessing = __esm({
   "../core/src/serve/chatProcessing.ts"() {
@@ -12766,6 +12854,7 @@ var init_chatProcessing = __esm({
     init_transcript();
     init_content();
     init_contentParts();
+    init_visionCapability();
     init_trace();
     init_webHost();
     init_registry();
@@ -12808,17 +12897,17 @@ ${inject}`;
       if (roots.length > 1) {
         let activeReal = getActiveWorkspaceRoot();
         try {
-          activeReal = fs39.realpathSync(activeReal);
+          activeReal = fs40.realpathSync(activeReal);
         } catch {
         }
-        const lines = roots.map((r) => `- ${path41.basename(r) || r}: ${r}${r === activeReal ? "\uFF08\u9ED8\u8BA4\u6839\uFF1A\u76F8\u5BF9\u8DEF\u5F84/\u547D\u4EE4\u57FA\u51C6\uFF09" : "\uFF08\u53EF\u76F4\u63A5\u8BFB\u5199\uFF09"}`);
+        const lines = roots.map((r) => `- ${path42.basename(r) || r}: ${r}${r === activeReal ? "\uFF08\u9ED8\u8BA4\u6839\uFF1A\u76F8\u5BF9\u8DEF\u5F84/\u547D\u4EE4\u57FA\u51C6\uFF09" : "\uFF08\u53EF\u76F4\u63A5\u8BFB\u5199\uFF09"}`);
         sysPrompt = sysPrompt + `
 
 \u3010\u5DE5\u4F5C\u533A\uFF08\u591A\u9879\u76EE\uFF09\u3011
 \u65E0\u9700\u5207\u6362\u9879\u76EE\uFF0C\u4EE5\u4E0B\u6240\u6709\u6839\u90FD\u53EF\u76F4\u63A5\u7528\u7EDD\u5BF9\u8DEF\u5F84\u8BBF\u95EE\uFF1B\u8DE8\u9879\u76EE\u7528\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u9ED8\u8BA4\u6839\u7684 ../<\u5144\u5F1F\u76EE\u5F55>:
 ${lines.join("\n")}
-\u2605 \u8DEF\u5F84\u951A\u5B9A\u94C1\u5F8B\uFF1A\u5DE5\u5177\u7F3A\u7701\u53EA\u4F5C\u7528\u4E8E\u9ED8\u8BA4\u6839\uFF08${path41.basename(activeReal) || activeReal} = IDE \u5934\u90E8\u6240\u793A\u6839\uFF09\u3002\u5F53\u7528\u6237\u5728\u5BF9\u8BDD\u4E2D\u6307\u660E\u4E86\u67D0\u4E2A\u9879\u76EE\uFF08\u5982\u300C\u5728 A \u9879\u76EE\u300D\u300C\u6539\u524D\u7AEF\u7684 xxx\u300D\u300C\u641C\u540E\u7AEF\u300D\uFF09\uFF0C\u8BE5\u8F6E\u6240\u6709\u5E26 path \u53C2\u6570\u7684\u5DE5\u5177\u8C03\u7528\uFF08read_file / edit_file / search_grep / glob / list_dir / read_xlsx / read_docx \u7B49\uFF09\u5FC5\u987B\u628A\u5BF9\u5E94\u9879\u76EE\u6839\u4F5C\u4E3A path \u4F20\u5165\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u3001../<\u5144\u5F1F\u76EE\u5F55>\u3001\u6216\u9879\u76EE\u76EE\u5F55\u540D\uFF09\uFF0C\u5426\u5219\u53EA\u4F1A\u8BFB\u5199/\u641C\u7D22\u9ED8\u8BA4\u6839\uFF0C\u4E0E\u7528\u6237\u610F\u56FE\u4E0D\u7B26\u3002
-\u6CE8\u610F\uFF1A\u9879\u76EE\u7EA7\u914D\u7F6E\uFF08.deepseeker-code/\uFF09\u4EC5\u5728\u9ED8\u8BA4\u6839 ${path41.basename(activeReal) || activeReal} \u751F\u6548\u3002`;
+\u2605 \u8DEF\u5F84\u951A\u5B9A\u94C1\u5F8B\uFF1A\u5DE5\u5177\u7F3A\u7701\u53EA\u4F5C\u7528\u4E8E\u9ED8\u8BA4\u6839\uFF08${path42.basename(activeReal) || activeReal} = IDE \u5934\u90E8\u6240\u793A\u6839\uFF09\u3002\u5F53\u7528\u6237\u5728\u5BF9\u8BDD\u4E2D\u6307\u660E\u4E86\u67D0\u4E2A\u9879\u76EE\uFF08\u5982\u300C\u5728 A \u9879\u76EE\u300D\u300C\u6539\u524D\u7AEF\u7684 xxx\u300D\u300C\u641C\u540E\u7AEF\u300D\uFF09\uFF0C\u8BE5\u8F6E\u6240\u6709\u5E26 path \u53C2\u6570\u7684\u5DE5\u5177\u8C03\u7528\uFF08read_file / edit_file / search_grep / glob / list_dir / read_xlsx / read_docx \u7B49\uFF09\u5FC5\u987B\u628A\u5BF9\u5E94\u9879\u76EE\u6839\u4F5C\u4E3A path \u4F20\u5165\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u3001../<\u5144\u5F1F\u76EE\u5F55>\u3001\u6216\u9879\u76EE\u76EE\u5F55\u540D\uFF09\uFF0C\u5426\u5219\u53EA\u4F1A\u8BFB\u5199/\u641C\u7D22\u9ED8\u8BA4\u6839\uFF0C\u4E0E\u7528\u6237\u610F\u56FE\u4E0D\u7B26\u3002
+\u6CE8\u610F\uFF1A\u9879\u76EE\u7EA7\u914D\u7F6E\uFF08.deepseeker-code/\uFF09\u4EC5\u5728\u9ED8\u8BA4\u6839 ${path42.basename(activeReal) || activeReal} \u751F\u6548\u3002`;
       }
       const osName = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
       const now = /* @__PURE__ */ new Date();
@@ -12835,6 +12924,7 @@ ${lines.join("\n")}
 \u3010\u73AF\u5883\u3011
 ${envLines.join("\n")}`;
       let replyText = "";
+      await ensureVisionCacheLoaded();
       const { wire: userContent, archive: archiveContent } = toIngestContents(inbound.content, inbound.attachments, opts?.model);
       try {
         const fullMessages = await buildContextMessages(
@@ -12922,7 +13012,7 @@ ${envLines.join("\n")}`;
 });
 
 // ../core/src/session/fork.ts
-import fs40 from "fs/promises";
+import fs41 from "fs/promises";
 var listForkAnchors, derivePrefix, forkSession;
 var init_fork = __esm({
   "../core/src/session/fork.ts"() {
@@ -12995,7 +13085,7 @@ var init_fork = __esm({
       const prefix = derivePrefix(lines, upToLineId);
       const newId = createUUID();
       await ensureSessionsDir(newId);
-      const rawText = await fs40.readFile(getTranscriptPath(sourceId), "utf-8");
+      const rawText = await fs41.readFile(getTranscriptPath(sourceId), "utf-8");
       const kept = [];
       let good = 0;
       for (const s of rawText.split("\n")) {
@@ -13011,7 +13101,7 @@ var init_fork = __esm({
       }
       let payload = kept.join("\n");
       if (payload.length > 0 && !payload.endsWith("\n")) payload += "\n";
-      await fs40.writeFile(getTranscriptPath(newId), payload, "utf-8");
+      await fs41.writeFile(getTranscriptPath(newId), payload, "utf-8");
       const srcState = await readStore(sourceId);
       const srcRolling = await getRollingState(sourceId);
       const legacy = !lines.some(isEventLine);
@@ -13553,6 +13643,9 @@ var init_useChatState = __esm({
             }
             break;
           }
+          case "vision.downgraded":
+            pushInfo(`\u{1F5BC} \u6A21\u578B ${String(obj.model ?? "")} \u4E0D\u652F\u6301\u56FE\u7247\uFF0C\u5DF2\u81EA\u52A8\u964D\u7EA7\u4E3A\u6587\u672C\u5904\u7406\uFF08\u5DF2\u8BB0\u4F4F\uFF0C\u540E\u7EED\u6D88\u606F\u76F4\u63A5\u6309\u6587\u672C\u53D1\u9001\uFF09`);
+            break;
           default:
             break;
         }
@@ -14941,7 +15034,7 @@ var init_TopPanel = __esm({
 });
 
 // ../core/src/observability/inspect.ts
-import fs41 from "fs";
+import fs42 from "fs";
 var CWD, fmt, readTrace, inspectUsage, inspectContext, inspectPermissions, inspectMcp, inspectHooks, inspectDebug;
 var init_inspect = __esm({
   "../core/src/observability/inspect.ts"() {
@@ -14959,7 +15052,7 @@ var init_inspect = __esm({
       if (!sessionId) return [];
       try {
         const p = await getTraceStorePath(sessionId);
-        const text = await fs41.promises.readFile(p, "utf8");
+        const text = await fs42.promises.readFile(p, "utf8");
         const out = [];
         for (const line of text.split("\n")) {
           if (!line.trim()) continue;
@@ -15770,7 +15863,7 @@ init_updateCheck();
 init_trust();
 import { render } from "ink";
 import os5 from "os";
-import path42 from "path";
+import path43 from "path";
 import { emitKeypressEvents } from "node:readline";
 import { jsx as jsx19 } from "react/jsx-runtime";
 var parseArgs = (argv) => {
@@ -15903,7 +15996,7 @@ var main = async () => {
   process.stdout.write("\x1B[2J\x1B[3J\x1B[1;1H");
   const cwdIsHome = () => {
     try {
-      return path42.resolve(cwd).toLowerCase() === path42.resolve(os5.homedir()).toLowerCase();
+      return path43.resolve(cwd).toLowerCase() === path43.resolve(os5.homedir()).toLowerCase();
     } catch {
       return false;
     }