deepseeker-code 1.0.4 → 1.0.42

package/dist/cli.mjs

@@ -9,12 +9,88 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/updateCheck.ts
+var updateCheck_exports = {};
+__export(updateCheck_exports, {
+  getCachedLatestIfNewer: () => getCachedLatestIfNewer,
+  readLocalVersion: () => readLocalVersion,
+  refreshUpdateCache: () => refreshUpdateCache
+});
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "node:fs";
+import path2 from "node:path";
+import os2 from "os";
+import { fileURLToPath } from "node:url";
+var PKG_NAME, REGISTRY, CACHE_TTL_MS, FETCH_TIMEOUT_MS, cacheFile, readLocalVersion, parseSemver, compareVersion, readCache, writeCache, getCachedLatestIfNewer, refreshUpdateCache;
+var init_updateCheck = __esm({
+  "src/updateCheck.ts"() {
+    "use strict";
+    PKG_NAME = "deepseeker-code";
+    REGISTRY = "https://registry.npmjs.org";
+    CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+    FETCH_TIMEOUT_MS = 3e3;
+    cacheFile = () => path2.join(os2.homedir(), ".deepseeker-code", "update-check.json");
+    readLocalVersion = () => {
+      try {
+        const here = path2.dirname(fileURLToPath(import.meta.url));
+        return JSON.parse(readFileSync2(path2.join(here, "..", "package.json"), "utf8")).version ?? "0.0.0";
+      } catch {
+        return "0.0.0";
+      }
+    };
+    parseSemver = (v) => {
+      const m = String(v ?? "").match(/^(\d+)\.(\d+)\.(\d+)/);
+      return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : [0, 0, 0];
+    };
+    compareVersion = (a, b) => {
+      const [a1, a2, a3] = parseSemver(a);
+      const [b1, b2, b3] = parseSemver(b);
+      return a1 - b1 || a2 - b2 || a3 - b3;
+    };
+    readCache = () => {
+      try {
+        const obj = JSON.parse(readFileSync2(cacheFile(), "utf8"));
+        return typeof obj.latestVersion === "string" && typeof obj.lastCheck === "number" ? obj : null;
+      } catch {
+        return null;
+      }
+    };
+    writeCache = (latestVersion) => {
+      try {
+        mkdirSync(path2.dirname(cacheFile()), { recursive: true });
+        writeFileSync(cacheFile(), JSON.stringify({ lastCheck: Date.now(), latestVersion }), "utf8");
+      } catch {
+      }
+    };
+    getCachedLatestIfNewer = (currentVersion) => {
+      const cache = readCache();
+      if (!cache) return null;
+      return compareVersion(cache.latestVersion, currentVersion) > 0 ? cache.latestVersion : null;
+    };
+    refreshUpdateCache = () => {
+      const cache = readCache();
+      if (cache && Date.now() - cache.lastCheck < CACHE_TTL_MS) return;
+      void (async () => {
+        try {
+          const res = await fetch(`${REGISTRY}/${PKG_NAME}/latest`, {
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+          });
+          if (!res.ok) return;
+          const info = await res.json();
+          if (info.version) writeCache(info.version);
+        } catch {
+        }
+      })();
+    };
+  }
+});
+
 // src/strings.ts
 var VERSION, STRINGS, locale, getLocale, setLocale, S, LOCAL_COMMAND_NAMES;
 var init_strings = __esm({
   "src/strings.ts"() {
     "use strict";
-    VERSION = "v1.0.0";
+    init_updateCheck();
+    VERSION = `v${readLocalVersion()}`;
     STRINGS = {
       zh: {
         brand: "DeepSeeker-Code",
@@ -34,17 +110,19 @@ var init_strings = __esm({
         toolRunning: (name) => `\u23FA ${name} \u8FD0\u884C\u4E2D\u2026`,
         toolDone: (name, ok) => `\u23FA ${name} \xB7 ${ok ? "\u6210\u529F" : "\u5931\u8D25"}`,
         toolDenied: (name) => `\u{1F6AB} ${name} \u5DF2\u88AB\u62D2\u7EDD`,
-        planTitle: "\u2705 \u5B9E\u73B0\u65B9\u6848\uFF08\u8BA1\u5212\u6A21\u5F0F\uFF09",
-        planPrompt: "\u2191\u2193 \u9009\u62E9 \xB7 Enter \u786E\u8BA4\uFF08\u4FEE\u6539\u9879\u8FDB\u5165\u7F16\u8F91\uFF0CEnter \u63D0\u4EA4 / Esc \u53D6\u6D88\uFF09\u3002",
-        planAcceptAuto: "\u63A5\u53D7\u5E76\u81EA\u52A8\u6267\u884C\uFF08\u5B9E\u73B0\u9636\u6BB5\u514D\u5BA1\u6279\uFF09",
-        planAcceptManual: "\u63A5\u53D7\u5E76\u624B\u52A8\u6267\u884C\uFF08\u9010\u6B65\u5BA1\u6279\u6BCF\u4E2A\u5DE5\u5177\uFF09",
-        planEdit: "\u4FEE\u6539\u65B9\u6848",
-        planReject: "\u62D2\u7EDD\uFF0C\u56DE\u5230\u8F93\u5165\u6846",
+        planTitle: "\u51C6\u5907\u5F00\u59CB\u7F16\u7801\uFF1F",
+        planPrompt: "\u2191\u2193 \u9009\u62E9 \xB7 Enter \u786E\u8BA4\uFF08\u7F16\u8F91\u9879\u8FDB\u5165\u7F16\u8F91\u5668\uFF0CEnter \u63D0\u4EA4 / Esc \u53D6\u6D88\uFF09\u3002",
+        planAcceptAuto: "\u662F\uFF0C\u5E76\u81EA\u52A8\u63A5\u53D7\u7F16\u8F91\uFF08\u5B9E\u73B0\u9636\u6BB5\u514D\u5BA1\u6279\uFF09",
+        planAcceptManual: "\u662F\uFF0C\u5E76\u624B\u52A8\u5BA1\u6279\u7F16\u8F91\uFF08\u9010\u6B65\u5BA1\u6279\u6BCF\u4E2A\u5DE5\u5177\uFF09",
+        planEdit: "\u7F16\u8F91\u65B9\u6848",
+        planReject: "\u5426\uFF0C\u7EE7\u7EED\u89C4\u5212",
         planEditTitle: "\u270F\uFE0F \u7F16\u8F91\u65B9\u6848",
         planEditHint: "Enter \u6309\u6B64\u65B9\u6848\u6267\u884C \xB7 Esc \u53D6\u6D88\u56DE\u5230\u9009\u9879",
-        planRejected: "\u270B \u5DF2\u62D2\u7EDD\u65B9\u6848\uFF0C\u672C\u8F6E\u672A\u6267\u884C\u3002",
+        planKeepPlanning: "\u270B \u5DF2\u7559\u5728\u8BA1\u5212\u6A21\u5F0F\uFF1A\u7EE7\u7EED\u8F93\u5165\u8865\u5145\u8981\u6C42\uFF0C\u6A21\u578B\u5C06\u4FEE\u8BA2\u65B9\u6848\u540E\u518D\u6B21\u63D0\u4EA4\uFF08/plan \u53EF\u9000\u51FA\uFF09\u3002",
         planEditEmpty: "\u65B9\u6848\u4E0D\u80FD\u4E3A\u7A7A",
         planAutoExecute: "\u26A1 \u5DF2\u8FDB\u5165\u81EA\u52A8\u6267\u884C\uFF1A\u5B9E\u73B0\u9636\u6BB5\u5DE5\u5177\u5C06\u514D\u5BA1\u6279\u76F4\u63A5\u8FD0\u884C\u3002",
+        inputBadgePlan: "plan mode on\uFF08\u53EA\u8BFB\u8C03\u7814 \u2192 \u65B9\u6848\u5BA1\u6279 \u2192 \u5B9E\u73B0\uFF09",
+        inputBadgeAuto: "auto-accept edits on",
         approvalTitle: "\u{1F510} \u64CD\u4F5C\u5BA1\u6279",
         approvalPrompt: "\u2191\u2193 \u9009\u62E9\u540E Enter\uFF08Esc \u62D2\u7EDD\uFF09\uFF1A\u5141\u8BB8\u672C\u6B21 / \u603B\u662F\u5141\u8BB8\uFF08\u5199\u6301\u4E45\u89C4\u5219\uFF09/ \u62D2\u7EDD\u3002",
         approvalAllow: "\u5141\u8BB8\u672C\u6B21",
@@ -172,17 +250,19 @@ DeepSeeker-Code \u5C06\u5728\u6B64\u76EE\u5F55\u8BFB\u53D6\u3001\u7F16\u8F91\u54
         toolRunning: (name) => `\u23FA ${name} running\u2026`,
         toolDone: (name, ok) => `\u23FA ${name} \xB7 ${ok ? "ok" : "failed"}`,
         toolDenied: (name) => `\u{1F6AB} ${name} denied`,
-        planTitle: "\u2705 Implementation plan (plan mode)",
+        planTitle: "Ready to code?",
         planPrompt: "\u2191\u2193 then Enter (edit opens the editor: Enter to save / Esc to cancel).",
-        planAcceptAuto: "Accept & auto-run (skip impl approvals)",
-        planAcceptManual: "Accept & step-by-step (approve each tool)",
+        planAcceptAuto: "Yes, and auto-accept edits (skip impl approvals)",
+        planAcceptManual: "Yes, and manually approve edits (step-by-step)",
         planEdit: "Edit plan",
-        planReject: "Reject, back to prompt",
+        planReject: "No, keep planning",
         planEditTitle: "\u270F\uFE0F Edit plan",
         planEditHint: "Enter to implement with this plan \xB7 Esc back to options",
-        planRejected: "\u270B Plan rejected, nothing executed this turn.",
+        planKeepPlanning: "\u270B Staying in plan mode: add feedback and the plan will be revised and resubmitted (/plan to exit).",
         planEditEmpty: "Plan cannot be empty",
         planAutoExecute: "\u26A1 Auto-run: implementation tools will execute without approval.",
+        inputBadgePlan: "plan mode on (read-only research \u2192 approve \u2192 implement)",
+        inputBadgeAuto: "auto-accept edits on",
         approvalTitle: "\u{1F510} Action approval",
         approvalPrompt: "\u2191\u2193 then Enter (Esc to deny): allow once / always allow (persist rule) / deny.",
         approvalAllow: "Allow once",
@@ -313,15 +393,15 @@ __export(config_exports, {
   appConfig: () => appConfig,
   configSources: () => configSources
 });
-import path2 from "path";
-import os2 from "os";
-import { readFileSync as readFileSync2 } from "fs";
+import path3 from "path";
+import os3 from "os";
+import { readFileSync as readFileSync3 } from "fs";
 import { createHash } from "crypto";
 var _DataDir, appConfig, ENV_SOURCES, configSources, ENGINE_OVERRIDE_VALIDATORS, ENGINE_OVERRIDE_KEYS, applyEngineOverrides;
 var init_config = __esm({
   "../core/src/config/index.ts"() {
     "use strict";
-    _DataDir = process.env.DEEPSEEKER_CODE_DATA_DIR ? path2.resolve(process.env.DEEPSEEKER_CODE_DATA_DIR) : path2.join(os2.homedir(), ".deepseeker-code");
+    _DataDir = process.env.DEEPSEEKER_CODE_DATA_DIR ? path3.resolve(process.env.DEEPSEEKER_CODE_DATA_DIR) : path3.join(os3.homedir(), ".deepseeker-code");
     appConfig = {
       dataDir: _DataDir,
       maxReasoningRounds: 3,
@@ -348,8 +428,8 @@ var init_config = __esm({
         if (/^[a-z]:/i.test(cwd)) {
           cwd = cwd.charAt(0).toUpperCase() + cwd.slice(1);
         }
-        const currentFolder = path2.basename(cwd);
-        const parentFolder = path2.basename(path2.dirname(cwd));
+        const currentFolder = path3.basename(cwd);
+        const parentFolder = path3.basename(path3.dirname(cwd));
         const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 8);
         return `${parentFolder}-${currentFolder}-${hash}`;
       })(),
@@ -447,15 +527,15 @@ var init_config = __esm({
     ENGINE_OVERRIDE_KEYS = Object.keys(ENGINE_OVERRIDE_VALIDATORS);
     applyEngineOverrides = (cfg) => {
       const paths = [
-        { scope: "settings.global", configPath: path2.join(cfg.dataDir, "settings.json") },
+        { scope: "settings.global", configPath: path3.join(cfg.dataDir, "settings.json") },
         // 全局用户级
-        { scope: "settings.project", configPath: path2.join(process.cwd(), ".deepseeker-code", "settings.json") }
+        { scope: "settings.project", configPath: path3.join(process.cwd(), ".deepseeker-code", "settings.json") }
         // 项目级（覆盖全局）
       ];
       for (const { scope, configPath } of paths) {
         let raw;
         try {
-          raw = readFileSync2(configPath, "utf-8");
+          raw = readFileSync3(configPath, "utf-8");
         } catch {
           continue;
         }
@@ -592,7 +672,7 @@ ${body}`) return;
 });
 
 // src/prefs.ts
-import path3 from "path";
+import path4 from "path";
 import fs2 from "fs/promises";
 var PREFS_FILE, readPrefs, readLocale, writePrefs, writeLocale;
 var init_prefs = __esm({
@@ -600,7 +680,7 @@ var init_prefs = __esm({
     "use strict";
     init_config();
     init_common();
-    PREFS_FILE = path3.join(appConfig.dataDir, "prefs.json");
+    PREFS_FILE = path4.join(appConfig.dataDir, "prefs.json");
     readPrefs = async () => {
       const p = await readJSONFile(PREFS_FILE);
       return p && typeof p === "object" ? p : {};
@@ -621,7 +701,7 @@ var init_prefs = __esm({
 });
 
 // ../core/src/trust/index.ts
-import path4 from "path";
+import path5 from "path";
 import fs3 from "fs/promises";
 var TRUSTED_FILE, normalizeDir, readTrustedDirs, isTrustedDir, trustDir, untrustDir;
 var init_trust = __esm({
@@ -629,9 +709,9 @@ var init_trust = __esm({
     "use strict";
     init_config();
     init_common();
-    TRUSTED_FILE = path4.join(appConfig.dataDir, "trusted_dirs.json");
+    TRUSTED_FILE = path5.join(appConfig.dataDir, "trusted_dirs.json");
     normalizeDir = (dir) => {
-      let d = path4.resolve(dir).replace(/\\/g, "/");
+      let d = path5.resolve(dir).replace(/\\/g, "/");
       if (/^[a-z]:/i.test(d)) d = d.charAt(0).toUpperCase() + d.slice(1);
       return d;
     };
@@ -974,7 +1054,7 @@ var init_replay = __esm({
 });
 
 // ../core/src/llm/model.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 var resolveInitialProvider, activeProvider, chatWithModelWithSummary, classifyToolRisk;
 var init_model = __esm({
   "../core/src/llm/model.ts"() {
@@ -989,7 +1069,7 @@ var init_model = __esm({
       }
       let raw;
       try {
-        raw = JSON.parse(readFileSync3(scriptPath, "utf-8"));
+        raw = JSON.parse(readFileSync4(scriptPath, "utf-8"));
       } catch (e) {
         throw new Error(`\u56DE\u653E\u5267\u672C\u52A0\u8F7D\u5931\u8D25\uFF08${scriptPath}\uFF09: ${e?.message ?? e}`);
       }
@@ -1109,7 +1189,7 @@ __export(store_exports, {
   writeStore: () => writeStore
 });
 import fs4 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 async function getRollingState(sessionId) {
   const store = await readStore(sessionId);
   if (!store) {
@@ -1156,16 +1236,16 @@ var init_store = __esm({
     getSessionsDirPath = (mainSessionId) => {
       assertSafeSessionId(mainSessionId);
       const fileName = getFileName(mainSessionId);
-      return path5.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir, fileName);
+      return path6.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir, fileName);
     };
-    getWorkspaceSessionsDir = () => path5.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir);
+    getWorkspaceSessionsDir = () => path6.join(appConfig.dataDir, "sessions", appConfig.userWorkspaceDir);
     getStatePath = (sessionId) => {
       assertSafeSessionId(sessionId);
-      return path5.join(getSessionsDirPath(sessionId), `${sessionId}.state.json`);
+      return path6.join(getSessionsDirPath(sessionId), `${sessionId}.state.json`);
     };
     getTranscriptPath = (sessionId) => {
       assertSafeSessionId(sessionId);
-      return path5.join(getSessionsDirPath(sessionId), `${sessionId}.jsonl`);
+      return path6.join(getSessionsDirPath(sessionId), `${sessionId}.jsonl`);
     };
     ensureSessionsDir = async (sessionId) => {
       await fs4.mkdir(getSessionsDirPath(sessionId), { recursive: true });
@@ -1175,7 +1255,7 @@ var init_store = __esm({
     migrateLegacyFiles = async (sessionId) => {
       assertSafeSessionId(sessionId);
       const dir = getSessionsDirPath(sessionId);
-      const legacy = path5.join(dir, `${sessionId}.json`);
+      const legacy = path6.join(dir, `${sessionId}.json`);
       const transcriptPath = getTranscriptPath(sessionId);
       const statePath = getStatePath(sessionId);
       let legacyText;
@@ -1300,7 +1380,7 @@ var init_store = __esm({
         if (!entry.isDirectory()) continue;
         const sessionId = entry.name;
         if (!isSafeSessionId(sessionId)) continue;
-        const dirPath = path5.join(root, sessionId);
+        const dirPath = path6.join(root, sessionId);
         const state = await readJSONFile(getStatePath(sessionId));
         let messageCount = 0;
         let preview = "";
@@ -1477,7 +1557,7 @@ var init_types = __esm({
 
 // ../core/src/hooks/shellExecutor.ts
 import { spawn } from "child_process";
-import path6 from "path";
+import path7 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"() {
@@ -1523,7 +1603,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 path6.resolve(base, rel);
+        return path7.resolve(base, rel);
       } catch {
         return void 0;
       }
@@ -1728,7 +1808,7 @@ var init_hooks = __esm({
 });
 
 // ../core/src/agent/truncate.ts
-import path7 from "path";
+import path8 from "path";
 function stripAnsi(text) {
   return text.replace(ANSI_ESCAPE, "");
 }
@@ -1767,10 +1847,10 @@ var init_truncate = __esm({
       if (!text) return text;
       const roots = /* @__PURE__ */ new Set();
       try {
-        roots.add(path7.resolve(appConfig.userWorkspaceDir));
+        roots.add(path8.resolve(appConfig.userWorkspaceDir));
         for (const r of getFileAccessRoots()) {
           try {
-            roots.add(path7.resolve(r));
+            roots.add(path8.resolve(r));
           } catch {
           }
         }
@@ -2037,7 +2117,7 @@ ${line}` : line;
 
 // ../core/src/tool/permissions.ts
 import fs6 from "fs/promises";
-import path8 from "path";
+import path9 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"() {
@@ -2099,9 +2179,9 @@ var init_permissions = __esm({
     readPermissionConfig = async (includeProject) => {
       const merged = { allow: [], deny: [], ask: [] };
       const paths = [
-        path8.join(appConfig.dataDir, "settings.json"),
+        path9.join(appConfig.dataDir, "settings.json"),
         // 全局用户级
-        ...includeProject ? [path8.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
+        ...includeProject ? [path9.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
         // 项目级（叠加）；未信任时省略
       ];
       for (const configPath of paths) {
@@ -2192,7 +2272,7 @@ var init_permissions = __esm({
       }
       return `${toolName}(${val})`;
     };
-    resolveSettingsPath = (scope) => scope === "global" ? path8.join(appConfig.dataDir, "settings.json") : path8.join(process.cwd(), ".deepseeker-code", "settings.json");
+    resolveSettingsPath = (scope) => scope === "global" ? path9.join(appConfig.dataDir, "settings.json") : path9.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);
@@ -2204,7 +2284,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(path8.dirname(file), { recursive: true });
+          await fs6.mkdir(path9.dirname(file), { recursive: true });
           await atomicWriteJSON(file, cfg);
         }
         if (!rules2[kind].some((r) => r.raw === compiled.raw)) rules2[kind].push(compiled);
@@ -2244,7 +2324,7 @@ var init_sessionRegistry = __esm({
 // ../core/src/tool/guard.ts
 import fs7 from "fs/promises";
 import fsSync from "fs";
-import path9 from "path";
+import path10 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;
@@ -2300,8 +2380,8 @@ var init_guard = __esm({
     getContainingRoot = (absPath) => {
       let best;
       for (const r of allowedBoundaryRoots()) {
-        const rel = path9.relative(r, absPath);
-        if (!rel.startsWith("..") && !path9.isAbsolute(rel)) {
+        const rel = path10.relative(r, absPath);
+        if (!rel.startsWith("..") && !path10.isAbsolute(rel)) {
           if (!best || r.length > best.length) best = r;
         }
       }
@@ -2318,16 +2398,16 @@ var init_guard = __esm({
     };
     resolveSafePath = (rel, base) => {
       const root = base ?? getActiveWorkspaceRoot();
-      const candidateAbsPath = path9.resolve(root, rel);
+      const candidateAbsPath = path10.resolve(root, rel);
       let truePhysicalPath = candidateAbsPath;
       try {
         if (fsSync.existsSync(candidateAbsPath)) {
           truePhysicalPath = fsSync.realpathSync(candidateAbsPath);
         } else {
-          const parentDir = path9.dirname(candidateAbsPath);
+          const parentDir = path10.dirname(candidateAbsPath);
           if (fsSync.existsSync(parentDir)) {
             const trueParentDir = fsSync.realpathSync(parentDir);
-            truePhysicalPath = path9.join(trueParentDir, path9.basename(candidateAbsPath));
+            truePhysicalPath = path10.join(trueParentDir, path10.basename(candidateAbsPath));
           }
         }
       } catch (e) {
@@ -2341,8 +2421,8 @@ var init_guard = __esm({
         }
       })() : allowedBoundaryRoots();
       const escaped = boundaryRoots.every((r) => {
-        const rel0 = path9.relative(r, truePhysicalPath);
-        return rel0.startsWith("..") || path9.isAbsolute(rel0);
+        const rel0 = path10.relative(r, truePhysicalPath);
+        return rel0.startsWith("..") || path10.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}`);
@@ -2351,12 +2431,12 @@ var init_guard = __esm({
     };
     resolveReadablePath = (rel) => {
       const root = getActiveWorkspaceRoot();
-      const absPath = path9.resolve(root, rel);
+      const absPath = path10.resolve(root, rel);
       if (!fsSync.existsSync(absPath)) {
-        const rootName = path9.basename(root);
+        const rootName = path10.basename(root);
         const firstSeg = rel.split(/[\\/]/)[0];
         if (rootName && firstSeg === rootName) {
-          const alt = path9.resolve(root, rel.slice(firstSeg.length + 1));
+          const alt = path10.resolve(root, rel.slice(firstSeg.length + 1));
           if (fsSync.existsSync(alt)) return alt;
         }
       }
@@ -2369,9 +2449,9 @@ var init_guard = __esm({
         if (fsSync.existsSync(absPath)) {
           truePhysicalPath = fsSync.realpathSync(absPath);
         } else {
-          const parentDir = path9.dirname(absPath);
+          const parentDir = path10.dirname(absPath);
           if (fsSync.existsSync(parentDir)) {
-            truePhysicalPath = path9.join(fsSync.realpathSync(parentDir), path9.basename(absPath));
+            truePhysicalPath = path10.join(fsSync.realpathSync(parentDir), path10.basename(absPath));
           }
         }
       } catch (e) {
@@ -2385,8 +2465,8 @@ var init_guard = __esm({
         }
       })() : allowedBoundaryRoots();
       const escaped = boundaryRoots.every((r) => {
-        const rel0 = path9.relative(r, truePhysicalPath);
-        return rel0.startsWith("..") || path9.isAbsolute(rel0);
+        const rel0 = path10.relative(r, truePhysicalPath);
+        return rel0.startsWith("..") || path10.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}`);
@@ -2397,9 +2477,14 @@ var init_guard = __esm({
     SENSITIVE_ENV_PATTERN = /(KEY|TOKEN|SECRET|PASSWORD|PASSPHRASE|CREDENTIAL|PRIVATE|AUTH)/i;
     scrubCommandEnv = (env = process.env) => {
       const next = {};
+      const GIT_CONFIG_MEMBER = /^GIT_CONFIG_(KEY|VALUE)_\d+$/;
+      const gitConfigFamilyHit = Object.keys(env).some(
+        (k) => GIT_CONFIG_MEMBER.test(k) && (COMMAND_ENV_DENYLIST.includes(k) || SENSITIVE_ENV_PATTERN.test(k))
+      );
       for (const [k, v] of Object.entries(env)) {
         if (COMMAND_ENV_DENYLIST.includes(k)) continue;
         if (SENSITIVE_ENV_PATTERN.test(k)) continue;
+        if (gitConfigFamilyHit && (k === "GIT_CONFIG_COUNT" || GIT_CONFIG_MEMBER.test(k))) continue;
         next[k] = v;
       }
       return next;
@@ -2408,7 +2493,7 @@ var init_guard = __esm({
       if (!relOrAbs) return false;
       try {
         const base = cwd || process.env.WORKSPACE_ROOT || process.cwd();
-        const abs = path9.isAbsolute(relOrAbs) ? relOrAbs : path9.resolve(base, relOrAbs);
+        const abs = path10.isAbsolute(relOrAbs) ? relOrAbs : path10.resolve(base, relOrAbs);
         const lower = abs.replace(/\\/g, "/").toLowerCase();
         return PROTECTED_WRITE_DIRS.some((d) => {
           const seg = ("/" + d).toLowerCase();
@@ -2423,9 +2508,9 @@ var init_guard = __esm({
         const entries = await fs7.readdir(dirPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isFile() && (entry.name === ".gitignore" || entry.name === ".agentignore")) {
-            const fullPath = path9.join(dirPath, entry.name);
+            const fullPath = path10.join(dirPath, entry.name);
             const content = await fs7.readFile(fullPath, "utf-8");
-            const relDir = path9.relative(base, dirPath).replace(/\\/g, "/");
+            const relDir = path10.relative(base, dirPath).replace(/\\/g, "/");
             const rules3 = content.split(/\r?\n/).map((line) => {
               const trimmed = line.trim();
               if (!trimmed || trimmed.startsWith("#")) return "";
@@ -2436,7 +2521,7 @@ var init_guard = __esm({
         }
         for (const entry of entries) {
           if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
-            await scanIgnoreFilesRecursive(path9.join(dirPath, entry.name), base, engine);
+            await scanIgnoreFilesRecursive(path10.join(dirPath, entry.name), base, engine);
           }
         }
       } catch {
@@ -2507,7 +2592,7 @@ var init_guard = __esm({
 // ../core/src/tool/registry/background.ts
 import { spawn as spawn2, execFileSync } from "child_process";
 import fsSync2 from "fs";
-import path10 from "path";
+import path11 from "path";
 function appendOutput(task, chunk) {
   task.outputBuffer += chunk;
   if (task.outputBuffer.length > MAX_BUFFER_CHARS) {
@@ -2532,7 +2617,7 @@ async function killTree(proc) {
   }
 }
 async function killBackgroundTasksUnder(dirPath) {
-  const norm = (p) => path10.resolve(p).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+  const norm = (p) => path11.resolve(p).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
   const target = norm(dirPath);
   let killed = 0;
   for (const task of registry.values()) {
@@ -2577,9 +2662,9 @@ var init_background = __esm({
       if (envShell && envShell.toLowerCase() !== "cmd") candidates.push(envShell);
       const gitExe = whereLines("git")[0];
       if (gitExe) {
-        const dir = path10.dirname(gitExe);
-        const root = path10.dirname(dir);
-        candidates.push(path10.join(root, "bin", "bash.exe"), path10.join(dir, "bash.exe"), path10.join(path10.dirname(root), "bin", "bash.exe"));
+        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 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);
@@ -3322,13 +3407,13 @@ ${capped || JSON.stringify(result)}`;
 
 // ../core/src/tool/mcp/loader.ts
 import fs8 from "fs/promises";
-import path11 from "path";
+import path12 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 || path11.join(appConfig.dataDir, "mcp.json");
+  const configPath = process.env.MCP_CONFIG || path12.join(appConfig.dataDir, "mcp.json");
   let raw;
   try {
     raw = await fs8.readFile(configPath, "utf-8");
@@ -3899,7 +3984,6 @@ var init_planMode = __esm({
   "../core/src/agent/planMode.ts"() {
     "use strict";
     PLAN_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
-      "getTime",
       "read_file",
       "list_dir",
       "view_symbol_outline",
@@ -4104,7 +4188,7 @@ ${AGENT_USAGE_HINT}`);
 
 // ../core/src/projectGuide/loader.ts
 import fs10 from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 var CANDIDATES, MAX_GUIDE_BYTES, cached, initProjectGuide, getProjectGuide;
 var init_loader2 = __esm({
   "../core/src/projectGuide/loader.ts"() {
@@ -4121,7 +4205,7 @@ var init_loader2 = __esm({
       try {
         for (const name of CANDIDATES) {
           try {
-            const raw = await fs10.readFile(path12.join(WORKSPACE_ROOT, name), "utf-8");
+            const raw = await fs10.readFile(path13.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;
@@ -4293,36 +4377,6 @@ var init_systemInjections = __esm({
   }
 });
 
-// ../core/src/tool/registry/system.ts
-var systemTools;
-var init_system = __esm({
-  "../core/src/tool/registry/system.ts"() {
-    "use strict";
-    init_type();
-    systemTools = [
-      {
-        type: "function",
-        function: {
-          name: "getTime",
-          description: "\u8FD4\u56DE\u5F53\u524D\u670D\u52A1\u5668\u7684\u65E5\u671F\u4E0E\u65F6\u95F4\uFF08\u672C\u5730\u65F6\u533A\uFF09",
-          parameters: {
-            type: "object",
-            properties: {
-              // Q-7：location 改为可选——旧版 required 却完全不消费，迫使模型填无意义城市名。
-              location: { type: "string", description: "\u57CE\u5E02\u540D\u79F0\uFF08\u53EF\u9009\uFF0C\u4EC5\u4F5C\u8BB0\u5F55\uFF1B\u670D\u52A1\u5668\u59CB\u7EC8\u8FD4\u56DE\u5176\u672C\u5730\u65F6\u95F4\uFF09" }
-            }
-          },
-          safetyLevel: "safe" /* SAFE */,
-          isSync: true,
-          async execute() {
-            return (/* @__PURE__ */ new Date()).toLocaleString("zh-CN", { dateStyle: "medium", timeStyle: "medium" });
-          }
-        }
-      }
-    ];
-  }
-});
-
 // ../core/src/tool/registry/agent.ts
 var createAgentTools;
 var init_agent = __esm({
@@ -4371,8 +4425,8 @@ var init_agent = __esm({
 });
 
 // ../core/src/tool/worktree/manager.ts
-import path13 from "path";
-import os3 from "os";
+import path14 from "path";
+import os4 from "os";
 import fs11 from "fs";
 var runMainGit, worktreeRootDir, worktreeDir, isNotARepoError, createWorktree, harvestDiff, runInWorktree, removeWorktree, sweepOrphanedWorktrees, disposeAllSessionWorktrees;
 var init_manager = __esm({
@@ -4384,8 +4438,8 @@ var init_manager = __esm({
     init_background();
     init_sessionRegistry();
     runMainGit = (args, maxBuffer = 1024 * 1024 * 5) => execFileSmart("git", args, { cwd: WORKSPACE_ROOT, maxBuffer });
-    worktreeRootDir = () => path13.join(os3.tmpdir(), "deepseeker-code-worktrees", appConfig.userWorkspaceDir);
-    worktreeDir = (sessionId, stepId) => path13.join(worktreeRootDir(), sessionId, stepId);
+    worktreeRootDir = () => path14.join(os4.tmpdir(), "deepseeker-code-worktrees", appConfig.userWorkspaceDir);
+    worktreeDir = (sessionId, stepId) => path14.join(worktreeRootDir(), sessionId, stepId);
     isNotARepoError = (e) => {
       const text = `${e?.message || ""} ${e?.stderr || ""}`.toLowerCase();
       return text.includes("not a git repository");
@@ -4396,7 +4450,7 @@ 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(path13.dirname(wtPath), { recursive: true });
+      await fs11.promises.mkdir(path14.dirname(wtPath), { recursive: true });
       try {
         await runMainGit(["worktree", "add", "-b", branch, wtPath, "HEAD"]);
       } catch (e) {
@@ -4472,7 +4526,7 @@ var init_manager = __esm({
       }
       let swept = 0;
       for (const sessionIdDir of entries) {
-        const sessionPath = path13.join(root, sessionIdDir);
+        const sessionPath = path14.join(root, sessionIdDir);
         let stepDirs;
         try {
           stepDirs = await fs11.promises.readdir(sessionPath);
@@ -4480,7 +4534,7 @@ var init_manager = __esm({
           continue;
         }
         for (const stepDir of stepDirs) {
-          const wtPath = path13.join(sessionPath, stepDir);
+          const wtPath = path14.join(sessionPath, stepDir);
           try {
             await runMainGit(["worktree", "remove", "--force", wtPath]);
           } catch {
@@ -4761,7 +4815,7 @@ var init_workflow = __esm({
 
 // ../core/src/tool/tsHost.ts
 import fsSync3 from "fs";
-import path14 from "path";
+import path15 from "path";
 var _ts, _tsTried, getTs, buildDefaultOptions, findTsConfigBounded, resolveTsConfig, createProjectHost, lsCache, getLanguageService, realpathNative, posToLineCol, lineColToPos;
 var init_tsHost = __esm({
   "../core/src/tool/tsHost.ts"() {
@@ -4794,16 +4848,16 @@ var init_tsHost = __esm({
       strict: false
     });
     findTsConfigBounded = (ts, absPath) => {
-      const root = path14.resolve(getContainingRoot(absPath));
-      let dir = path14.dirname(absPath);
+      const root = path15.resolve(getContainingRoot(absPath));
+      let dir = path15.dirname(absPath);
       while (true) {
-        const candidate = path14.join(dir, "tsconfig.json");
+        const candidate = path15.join(dir, "tsconfig.json");
         try {
           if (fsSync3.existsSync(candidate)) return candidate;
         } catch {
         }
-        if (path14.resolve(dir) === root) break;
-        const parent = path14.dirname(dir);
+        if (path15.resolve(dir) === root) break;
+        const parent = path15.dirname(dir);
         if (parent === dir) break;
         dir = parent;
       }
@@ -4814,7 +4868,7 @@ var init_tsHost = __esm({
       if (!tsConfigPath) {
         return { options: buildDefaultOptions(ts), fileNames: [], projectRoot: getContainingRoot(absPath) };
       }
-      const basePath = path14.dirname(tsConfigPath);
+      const basePath = path15.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);
@@ -4825,7 +4879,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(path14.resolve(f)).replace(/\\/g, "/");
+      const keyOf = (f) => canonical(path15.resolve(f)).replace(/\\/g, "/");
       rootFileNames.forEach((f) => roots.add(keyOf(f)));
       const fresh = (fileName) => {
         const key = keyOf(fileName);
@@ -4914,10 +4968,10 @@ var init_tsHost = __esm({
 
 // ../core/src/tool/registry/fs.ts
 import fs12 from "fs/promises";
-import path15 from "path";
+import path16 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, fsTools;
+var isSensitiveReadTarget, stripReadFileLineNumbers, maskSecretsInContent, makeTmpPath, ATOMIC_TMP_RE, sweepStaleAtomicTmp, assertReadable, stripEdgeBlankLines, matchLineBlockWith, diagnoseOldStr, reindentToBase, alignIndentsByAnchor, applyOneEditToContent, fsTools;
 var init_fs = __esm({
   "../core/src/tool/registry/fs.ts"() {
     "use strict";
@@ -4975,7 +5029,7 @@ var init_fs = __esm({
           return;
         }
         for (const e of entries) {
-          const full = path15.join(dir, e.name);
+          const full = path16.join(dir, e.name);
           if (e.isDirectory()) {
             if (!skipDirs.has(e.name)) await walk(full);
             continue;
@@ -5005,7 +5059,7 @@ var init_fs = __esm({
       while (lines.length > 1 && lines[lines.length - 1].trim() === "") lines.pop();
       return lines.join("\n");
     };
-    matchLineBlockWith = (content, oldBlock, newBlock, replaceAll, norm) => {
+    matchLineBlockWith = (content, oldBlock, newBlock, replaceAll, norm, anchorAlign) => {
       const contentLines = content.split("\n");
       const oldLines = oldBlock.split("\n");
       if (oldLines.length === 0 || oldLines.length > contentLines.length) {
@@ -5034,7 +5088,11 @@ var init_fs = __esm({
             break;
           }
         }
-        const aligned = baseIndent ? reindentToBase(newBlock, baseIndent) : newBlock;
+        let aligned = baseIndent ? reindentToBase(newBlock, baseIndent) : newBlock;
+        if (anchorAlign) {
+          const anchored = alignIndentsByAnchor(newBlock, oldLines, contentLines, start);
+          if (anchored !== null) aligned = anchored;
+        }
         out.splice(start, oldLines.length, ...aligned.split("\n"));
       }
       return { ok: true, content: out.join("\n"), count: hits.length };
@@ -5069,6 +5127,92 @@ var init_fs = __esm({
         return baseIndent + (l.startsWith(common) ? l.slice(common.length) : l);
       }).join("\n");
     };
+    alignIndentsByAnchor = (newBlock, oldLines, contentLines, start) => {
+      const stripLead = (l) => l.replace(/^[ \t]+/, "");
+      const out = [];
+      let cursor = 0;
+      let lastIndent = null;
+      let anchors = 0;
+      for (const line of newBlock.split("\n")) {
+        if (line.trim() === "") {
+          out.push(line);
+          continue;
+        }
+        const bare = stripLead(line);
+        let idx = -1;
+        for (let i = cursor; i < oldLines.length; i++) {
+          if (oldLines[i].trim() !== "" && stripLead(oldLines[i]) === bare) {
+            idx = i;
+            break;
+          }
+        }
+        if (idx === -1) {
+          out.push(lastIndent === null ? line : lastIndent + bare);
+          continue;
+        }
+        cursor = idx + 1;
+        lastIndent = contentLines[start + idx].match(/^[ \t]*/)?.[0] ?? "";
+        anchors++;
+        out.push(lastIndent + bare);
+      }
+      return anchors > 0 ? out.join("\n") : null;
+    };
+    applyOneEditToContent = (normalizedContent, oldStr, newStr, replaceAll) => {
+      const normalizedNew = newStr.replace(/\r\n/g, "\n");
+      const normalizedOldRaw = oldStr.replace(/\r\n/g, "\n");
+      const lnStripped = stripReadFileLineNumbers(normalizedOldRaw);
+      const candidates = [
+        { old: normalizedOldRaw, note: "" },
+        { old: stripEdgeBlankLines(normalizedOldRaw), note: "\uFF08\u5DF2\u5BB9\u9519\u9996\u5C3E\u7A7A\u884C\uFF09" }
+      ];
+      if (lnStripped !== normalizedOldRaw) candidates.push({ old: lnStripped, note: "\uFF08\u5DF2\u5265\u79BB read_file \u884C\u53F7\u524D\u7F00\uFF09" });
+      let normalizedOld = null;
+      let note = "";
+      for (const c of candidates) {
+        if (c.old.length > 0 && normalizedContent.includes(c.old)) {
+          normalizedOld = c.old;
+          note = c.note;
+          break;
+        }
+      }
+      if (normalizedOld == null) {
+        const base = lnStripped !== normalizedOldRaw ? lnStripped : normalizedOldRaw;
+        const norms = [
+          // 行尾空白归一：old_str 前导缩进与文件一致（可信）→ 只对齐基线（anchor=false）
+          { norm: (l) => l.replace(/[ \t]+$/, ""), tag: "\u9010\u884C\u5C3E\u7A7A\u767D\u5BB9\u9519", anchor: false },
+          // 全空白归一：模型前导缩进已证明不符（不可信）→ 逐行锚定文件真实缩进（anchor=true）
+          { norm: (l) => l.trim(), tag: "\u9010\u884C\u5168\u7A7A\u767D\u5BB9\u9519\uFF08\u524D\u5BFC Tab/\u7A7A\u683C\uFF09", anchor: true }
+        ];
+        for (const { norm, tag, anchor } of norms) {
+          const lm = matchLineBlockWith(normalizedContent, base, normalizedNew, replaceAll, norm, anchor);
+          if (lm.ok) {
+            return {
+              ok: true,
+              content: lm.content,
+              summary: replaceAll ? `\u5DF2\u6279\u91CF\u66FF\u6362\u5168\u90E8 ${lm.count} \u5904\u5339\u914D\uFF08${tag}\uFF09\u3002` : `\u5DF2\u6210\u529F\u5B8C\u6210\u5C40\u90E8\u91CD\u6784\uFF08${tag}\uFF09\u3002`
+            };
+          }
+          if (lm.reason === "conflict") {
+            return { ok: false, error: `\u274C [\u4EE3\u7801\u4FEE\u8865\u5931\u8D25]\uFF1A\u4EE3\u7801\u51B2\u7A81\uFF01old_str\uFF08${tag}\u5F52\u4E00\u540E\uFF09\u5728\u5168\u6587\u4E2D\u4E0D\u552F\u4E00\uFF08\u5171 ${lm.count} \u5904\uFF09\u3002\u8BF7\u591A\u5305\u88F9\u51E0\u884C\u4E0A\u4E0B\u6587\uFF0C\u6216\u663E\u5F0F\u8BBE replace_all=true \u6279\u91CF\u66FF\u6362\u3002` };
+          }
+        }
+        const diag = diagnoseOldStr(normalizedContent, normalizedOldRaw);
+        return { ok: false, error: `\u274C [\u4EE3\u7801\u4FEE\u8865\u5931\u8D25]\uFF1A\u672A\u80FD\u5728\u6587\u4EF6\u4E2D\u627E\u5230\u6307\u5B9A\u7684 old_str \u65E7\u4EE3\u7801\u5757\u3002${diag}\u5E38\u89C1\u539F\u56E0\uFF1A\u2460 \u8BEF\u5E26\u4E86 read_file \u7684\u300C<\u884C\u53F7>: \u300D\u524D\u7F00\uFF1B\u2461 \u7F29\u8FDB\uFF08Tab/\u7A7A\u683C\uFF09\u4E0D\u4E00\u81F4\uFF1B\u2462 \u884C\u5C3E\u591A\u4F59\u7A7A\u683C\uFF1B\u2463 \u6587\u4EF6\u5DF2\u88AB\u6539\u52A8/old_str \u975E\u8FDE\u7EED\u6574\u6BB5\u3002\u8BF7\u7528 read_file \u91CD\u65B0\u6838\u5BF9\u8BE5\u5904\u7247\u6BB5\uFF08\u53BB\u6389\u300C<\u884C\u53F7>: \u300D\u524D\u7F00\u3001\u4FDD\u7559\u539F\u59CB Tab/\u7A7A\u683C\u7F29\u8FDB\uFF09\u540E\u91CD\u8BD5\u3002\u26A0\uFE0F \u4E25\u7981\u6539\u7528 run_command \u8C03\u7528 python/node/sed/awk \u7B49\u811A\u672C\u7ED5\u8FC7\u672C\u5DE5\u5177\u4FEE\u6539\u6587\u4EF6\u3002` };
+      }
+      const matchCount = normalizedContent.split(normalizedOld).length - 1;
+      if (!replaceAll && matchCount > 1) {
+        return { ok: false, error: `\u274C [\u4EE3\u7801\u4FEE\u8865\u5931\u8D25]\uFF1A\u4EE3\u7801\u51B2\u7A81\uFF01old_str \u5728\u5168\u6587\u4E2D\u4E0D\u552F\u4E00\uFF08\u5171\u53D1\u73B0\u4E86 ${matchCount} \u5904\uFF09\u3002\u8BF7\u5411\u4E0A\u6216\u5411\u4E0B\u591A\u5305\u88F9\u51E0\u884C\u4E0A\u4E0B\u6587\u518D\u63D0\u8BF7\u4FEE\u6539\uFF0C\u6216\u663E\u5F0F\u8BBE replace_all=true \u6279\u91CF\u66FF\u6362\u3002` };
+      }
+      const oldFirstNonBlank = normalizedOld.split("\n").find((l) => l.trim() !== "") ?? "";
+      const baseIndent = oldFirstNonBlank.match(/^[ \t]*/)?.[0] ?? "";
+      const alignedNew = baseIndent ? reindentToBase(normalizedNew, baseIndent) : normalizedNew;
+      const updatedContent = replaceAll ? normalizedContent.split(normalizedOld).join(alignedNew) : normalizedContent.replace(normalizedOld, () => alignedNew);
+      return {
+        ok: true,
+        content: updatedContent,
+        summary: replaceAll ? `\u5DF2\u6279\u91CF\u66FF\u6362\u5168\u90E8 ${matchCount} \u5904\u5339\u914D\u3002${note}` : `\u5DF2\u6210\u529F\u5B8C\u6210\u552F\u4E00\u6027\u5C40\u90E8\u91CD\u6784\u3002${note}`
+      };
+    };
     fsTools = [
       {
         type: "function",
@@ -5159,8 +5303,8 @@ ${formattedCode}${hasMore ? `
                 const entries = await fs12.readdir(currentPath, { withFileTypes: true });
                 const validEntries = entries.filter((entry) => {
                   if (entry.isSymbolicLink()) return false;
-                  const fullPath = path15.join(currentPath, entry.name);
-                  const relPath = path15.relative(getActiveWorkspaceRoot(), fullPath).replace(/\\/g, "/");
+                  const fullPath = path16.join(currentPath, entry.name);
+                  const relPath = path16.relative(getActiveWorkspaceRoot(), fullPath).replace(/\\/g, "/");
                   return !checkIsPathIgnored(entry.isDirectory() ? `${relPath}/` : relPath);
                 });
                 let output = "";
@@ -5179,7 +5323,7 @@ ${formattedCode}${hasMore ? `
 `;
                   if (entry.isDirectory()) {
                     const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
-                    const fullPath = path15.join(currentPath, entry.name);
+                    const fullPath = path16.join(currentPath, entry.name);
                     const subTree = await buildTreeText(fullPath, currentDepth + 1, nextPrefix);
                     output += subTree;
                   }
@@ -5200,78 +5344,65 @@ ${treeResult}`;
         type: "function",
         function: {
           name: "edit_file",
-          description: "\u9488\u5BF9\u6307\u5B9A\u7684\u6587\u4EF6\u8FDB\u884C\u5C40\u90E8\u7CBE\u51C6\u4FEE\u6539\u3002old_str \u5FC5\u987B\u4E0E\u6587\u4EF6\u4E2D\u7684\u539F\u59CB\u4EE3\u7801\u9010\u5B57\u7B26\u4E00\u81F4\uFF1A\u8BF7\u53BB\u6389 read_file \u8FD4\u56DE\u7684\u300C<\u884C\u53F7>: \u300D\u524D\u7F00\uFF0C\u5E76\u4FDD\u7559\u539F\u6709\u7F29\u8FDB\uFF08Tab/\u7A7A\u683C\uFF09\u4E0E\u884C\u5C3E\u7A7A\u767D\uFF1B\u9ED8\u8BA4\u8981\u6C42\u5728\u5168\u6587\u4E2D\u552F\u4E00\uFF0C\u82E5\u8BBE replace_all=true \u5219\u66FF\u6362\u5168\u90E8\u5339\u914D\u5904\uFF08\u9002\u5408\u6279\u91CF\u91CD\u547D\u540D/\u7EDF\u4E00\u6539\u5199\uFF09\u3002",
+          description: "\u9488\u5BF9\u6307\u5B9A\u7684\u6587\u4EF6\u8FDB\u884C\u5C40\u90E8\u7CBE\u51C6\u4FEE\u6539\u3002\u2605 \u540C\u4E00\u6587\u4EF6\u6709\u591A\u5904\u8981\u6539\u65F6\uFF0C\u52A1\u5FC5\u4E00\u6B21\u8C03\u7528\u4F20 edits \u6570\u7EC4\u5168\u90E8\u5B8C\u6210\uFF08\u6309\u5E8F\u5E94\u7528\u3001\u6574\u4F53\u539F\u5B50\uFF1A\u4EFB\u4E00\u5904\u5931\u8D25\u5219\u5168\u90E8\u4E0D\u5199\u5165\uFF09\uFF0C\u52FF\u9010\u5904\u591A\u6B21\u8C03\u7528\u3002old_str \u5FC5\u987B\u4E0E\u6587\u4EF6\u4E2D\u7684\u539F\u59CB\u4EE3\u7801\u9010\u5B57\u7B26\u4E00\u81F4\uFF1A\u8BF7\u53BB\u6389 read_file \u8FD4\u56DE\u7684\u300C<\u884C\u53F7>: \u300D\u524D\u7F00\uFF0C\u5E76\u4FDD\u7559\u539F\u6709\u7F29\u8FDB\uFF08Tab/\u7A7A\u683C\uFF09\u4E0E\u884C\u5C3E\u7A7A\u767D\uFF1B\u9ED8\u8BA4\u8981\u6C42\u5728\u5168\u6587\u4E2D\u552F\u4E00\uFF0C\u82E5\u8BBE replace_all=true \u5219\u66FF\u6362\u5168\u90E8\u5339\u914D\u5904\uFF08\u9002\u5408\u6279\u91CF\u91CD\u547D\u540D/\u7EDF\u4E00\u6539\u5199\uFF09\u3002",
           parameters: {
             type: "object",
             properties: {
               path: { type: "string", description: "\u51C6\u5907\u4FEE\u6539\u7684\u6587\u4EF6\u76F8\u5BF9\u8DEF\u5F84" },
-              old_str: { type: "string", description: "\u6587\u4EF6\u4E2D\u73B0\u6709\u7684\u5B8C\u6574\u65E7\u4EE3\u7801\u5757" },
-              new_str: { type: "string", description: "\u51C6\u5907\u66FF\u6362\u8FDB\u53BB\u7684\u65B0\u4EE3\u7801\u5757" },
-              replace_all: { type: "boolean", description: "\u662F\u5426\u66FF\u6362\u5168\u6587\u6240\u6709\u5339\u914D\u5904\uFF08\u9ED8\u8BA4 false \u4EC5\u66FF\u6362\u552F\u4E00\u5339\u914D\uFF1B\u6279\u91CF\u91CD\u547D\u540D/\u7EDF\u4E00\u6539\u5199\u65F6\u8BBE true\uFF09" }
+              old_str: { type: "string", description: "\u6587\u4EF6\u4E2D\u73B0\u6709\u7684\u5B8C\u6574\u65E7\u4EE3\u7801\u5757\uFF08\u5355\u5904\u4FEE\u6539\u7528\uFF1B\u591A\u5904\u4FEE\u6539\u8BF7\u6539\u7528 edits \u6570\u7EC4\u4E00\u6B21\u5B8C\u6210\uFF09" },
+              new_str: { type: "string", description: "\u51C6\u5907\u66FF\u6362\u8FDB\u53BB\u7684\u65B0\u4EE3\u7801\u5757\uFF08\u5355\u5904\u4FEE\u6539\u7528\uFF09" },
+              replace_all: { type: "boolean", description: "\u662F\u5426\u66FF\u6362\u5168\u6587\u6240\u6709\u5339\u914D\u5904\uFF08\u9ED8\u8BA4 false \u4EC5\u66FF\u6362\u552F\u4E00\u5339\u914D\uFF1B\u6279\u91CF\u91CD\u547D\u540D/\u7EDF\u4E00\u6539\u5199\u65F6\u8BBE true\uFF09\u3002\u9876\u5C42\u53C2\u6570\u4EC5\u4F5C\u7528\u4E8E\u5355\u6761 old_str/new_str\uFF1Bedits \u5185\u6BCF\u6761\u53EF\u72EC\u7ACB\u8BBE\u7F6E" },
+              edits: {
+                type: "array",
+                description: "\u2605 \u540C\u4E00\u6587\u4EF6\u591A\u5904\u4FEE\u6539\u65F6\u4F18\u5148\u4F7F\u7528\uFF1A\u4E00\u6B21\u8C03\u7528\u6309\u5E8F\u5B8C\u6210\u5168\u90E8\u66FF\u6362\uFF0C\u7701\u53BB\u9010\u5904\u5F80\u8FD4\u3002\u7B2C N \u6761\u7684 old_str \u987B\u57FA\u4E8E\u524D N-1 \u6761\u5E94\u7528\u540E\u7684\u6587\u4EF6\u5185\u5BB9\u6784\u9020\uFF1B\u4EFB\u4E00\u6761\u672A\u547D\u4E2D\u5219\u6574\u4F53\u4E0D\u5199\u5165\uFF08\u539F\u5B50\uFF09\uFF0C\u4FEE\u6B63\u8BE5\u6761\u540E\u6574\u7EC4\u91CD\u8BD5",
+                items: {
+                  type: "object",
+                  properties: {
+                    old_str: { type: "string", description: "\u6587\u4EF6\u4E2D\u73B0\u6709\u7684\u5B8C\u6574\u65E7\u4EE3\u7801\u5757" },
+                    new_str: { type: "string", description: "\u51C6\u5907\u66FF\u6362\u8FDB\u53BB\u7684\u65B0\u4EE3\u7801\u5757" },
+                    replace_all: { type: "boolean", description: "\u8BE5\u6761\u662F\u5426\u66FF\u6362\u5168\u6587\u6240\u6709\u5339\u914D\u5904\uFF08\u9ED8\u8BA4 false\uFF09" }
+                  },
+                  required: ["old_str", "new_str"]
+                }
+              }
             },
-            required: ["path", "old_str", "new_str"]
+            required: ["path"]
           },
           safetyLevel: "mutation" /* MUTATION */,
           isSync: true,
-          requireApproval: (args) => `\u7533\u8BF7\u4FEE\u6539\u6587\u4EF6 [${args.path}]${args.replace_all ? "\uFF08\u{1F525} \u6279\u91CF\u66FF\u6362\u5168\u90E8\u5339\u914D\u5904\uFF09" : ""}
+          requireApproval: (args) => {
+            const list = args.edits && args.edits.length > 0 ? args.edits : [{ old_str: args.old_str ?? "", new_str: args.new_str ?? "", replace_all: args.replace_all }];
+            const patches = list.map((e, i) => `\u2014\u2014 \u7B2C ${i + 1} \u5904${e.replace_all ? "\uFF08\u{1F525} \u6279\u91CF\u66FF\u6362\u5168\u90E8\u5339\u914D\u5904\uFF09" : ""} \u2014\u2014
 \u3010\u51CF\u5C11\u3011:
-${args.old_str}
+${e.old_str}
 \u3010\u589E\u52A0\u3011:
-${args.new_str}`,
+${e.new_str}`).join("\n\n");
+            return `\u7533\u8BF7\u4FEE\u6539\u6587\u4EF6 [${args.path}]\uFF08\u5171 ${list.length} \u5904\u4FEE\u6539\uFF0C\u4EFB\u4E00\u5904\u5931\u8D25\u5C06\u6574\u4F53\u4E0D\u5199\u5165\uFF09
+${patches}`;
+          },
           async execute(args) {
             try {
+              const editList = args.edits && args.edits.length > 0 ? args.edits : [{ old_str: args.old_str ?? "", new_str: args.new_str ?? "", replace_all: args.replace_all }];
+              if (editList.length === 0 || editList.some((e) => typeof e.old_str !== "string" || e.old_str.length === 0)) {
+                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 isCRLF = rawContent.includes("\r\n");
-              const normalizedContent = rawContent.replace(/\r\n/g, "\n");
-              const normalizedNew = args.new_str.replace(/\r\n/g, "\n");
-              const normalizedOldRaw = args.old_str.replace(/\r\n/g, "\n");
-              const lnStripped = stripReadFileLineNumbers(normalizedOldRaw);
-              const candidates = [
-                { old: normalizedOldRaw, note: "" },
-                { old: stripEdgeBlankLines(normalizedOldRaw), note: "\uFF08\u5DF2\u5BB9\u9519\u9996\u5C3E\u7A7A\u884C\uFF09" }
-              ];
-              if (lnStripped !== normalizedOldRaw) candidates.push({ old: lnStripped, note: "\uFF08\u5DF2\u5265\u79BB read_file \u884C\u53F7\u524D\u7F00\uFF09" });
-              let normalizedOld = null;
-              let note = "";
-              for (const c of candidates) {
-                if (c.old.length > 0 && normalizedContent.includes(c.old)) {
-                  normalizedOld = c.old;
-                  note = c.note;
-                  break;
-                }
-              }
-              if (normalizedOld == null) {
-                const base = lnStripped !== normalizedOldRaw ? lnStripped : normalizedOldRaw;
-                const norms = [
-                  { norm: (l) => l.replace(/[ \t]+$/, ""), tag: "\u9010\u884C\u5C3E\u7A7A\u767D\u5BB9\u9519" },
-                  { norm: (l) => l.trim(), tag: "\u9010\u884C\u5168\u7A7A\u767D\u5BB9\u9519\uFF08\u524D\u5BFC Tab/\u7A7A\u683C\uFF09" }
-                ];
-                for (const { norm, tag } of norms) {
-                  const lm = matchLineBlockWith(normalizedContent, base, normalizedNew, !!args.replace_all, norm);
-                  if (lm.ok) {
-                    assertWithinWorkspace(absPath);
-                    await fs12.writeFile(absPath, isCRLF ? lm.content.replace(/\n/g, "\r\n") : lm.content, "utf-8");
-                    return args.replace_all ? `\u2705 [\u4EE3\u7801\u4FEE\u8865\u6210\u529F]\uFF1A\u6587\u4EF6 [${args.path}] \u5DF2\u6279\u91CF\u66FF\u6362\u5168\u90E8 ${lm.count} \u5904\u5339\u914D\uFF08${tag}\uFF09\u3002` : `\u2705 [\u4EE3\u7801\u4FEE\u8865\u6210\u529F]\uFF1A\u6587\u4EF6 [${args.path}] \u5DF2\u6210\u529F\u5B8C\u6210\u5C40\u90E8\u91CD\u6784\uFF08${tag}\uFF09\u3002`;
-                  }
-                  if (lm.reason === "conflict") {
-                    return `\u274C [\u4EE3\u7801\u4FEE\u8865\u5931\u8D25]\uFF1A\u4EE3\u7801\u51B2\u7A81\uFF01old_str\uFF08${tag}\u5F52\u4E00\u540E\uFF09\u5728\u5168\u6587\u4E2D\u4E0D\u552F\u4E00\uFF08\u5171 ${lm.count} \u5904\uFF09\u3002\u8BF7\u591A\u5305\u88F9\u51E0\u884C\u4E0A\u4E0B\u6587\uFF0C\u6216\u663E\u5F0F\u8BBE replace_all=true \u6279\u91CF\u66FF\u6362\u3002`;
-                  }
+              let content = rawContent.replace(/\r\n/g, "\n");
+              const summaries = [];
+              for (let i = 0; i < editList.length; i++) {
+                const r = applyOneEditToContent(content, editList[i].old_str, editList[i].new_str ?? "", !!editList[i].replace_all);
+                if (!r.ok) {
+                  return editList.length === 1 ? r.error : `\u274C [\u4EE3\u7801\u4FEE\u8865\u5931\u8D25]\uFF1Aedits \u7B2C ${i + 1}/${editList.length} \u6761\u672A\u547D\u4E2D\uFF0C\u5DF2\u6574\u4F53\u653E\u5F03\uFF08\u6587\u4EF6\u672A\u505A\u4EFB\u4F55\u6539\u52A8\uFF0C\u53EF\u4FEE\u6B63\u8BE5\u6761\u540E\u6574\u7EC4\u91CD\u8BD5\uFF09\u3002${r.error.replace(/^❌ \[代码修补失败\]：/, "")}`;
                 }
-                const diag = diagnoseOldStr(normalizedContent, normalizedOldRaw);
-                return `\u274C [\u4EE3\u7801\u4FEE\u8865\u5931\u8D25]\uFF1A\u672A\u80FD\u5728\u6587\u4EF6\u4E2D\u627E\u5230\u6307\u5B9A\u7684 old_str \u65E7\u4EE3\u7801\u5757\u3002${diag}\u5E38\u89C1\u539F\u56E0\uFF1A\u2460 \u8BEF\u5E26\u4E86 read_file \u7684\u300C<\u884C\u53F7>: \u300D\u524D\u7F00\uFF1B\u2461 \u7F29\u8FDB\uFF08Tab/\u7A7A\u683C\uFF09\u4E0D\u4E00\u81F4\uFF1B\u2462 \u884C\u5C3E\u591A\u4F59\u7A7A\u683C\uFF1B\u2463 \u6587\u4EF6\u5DF2\u88AB\u6539\u52A8/old_str \u975E\u8FDE\u7EED\u6574\u6BB5\u3002\u8BF7\u7528 read_file \u91CD\u65B0\u6838\u5BF9\u5E94\u8D34\u7247\u6BB5\u3002\u26A0\uFE0F \u4E25\u7981\u6539\u7528 run_command \u8C03\u7528 python/node/sed/awk \u7B49\u811A\u672C\u7ED5\u8FC7\u672C\u5DE5\u5177\u4FEE\u6539\u6587\u4EF6\u2014\u2014\u8BF7\u7528 read_file \u91CD\u65B0\u8BFB\u53D6\u76EE\u6807\u7247\u6BB5\uFF08\u53BB\u6389\u300C<\u884C\u53F7>: \u300D\u524D\u7F00\u3001\u4FDD\u7559\u539F\u59CB Tab/\u7A7A\u683C\u7F29\u8FDB\uFF09\uFF0C\u518D\u6B21\u8C03\u7528 edit_file \u91CD\u8BD5\u3002`;
+                content = r.content;
+                summaries.push(editList.length === 1 ? r.summary : `  ${i + 1}. ${r.summary}`);
               }
-              const matchCount = normalizedContent.split(normalizedOld).length - 1;
-              if (!args.replace_all && matchCount > 1) {
-                return `\u274C [\u4EE3\u7801\u4FEE\u8865\u5931\u8D25]\uFF1A\u4EE3\u7801\u51B2\u7A81\uFF01old_str \u5728\u5168\u6587\u4E2D\u4E0D\u552F\u4E00\uFF08\u5171\u53D1\u73B0\u4E86 ${matchCount} \u5904\uFF09\u3002\u8BF7\u5411\u4E0A\u6216\u5411\u4E0B\u591A\u5305\u88F9\u51E0\u884C\u4E0A\u4E0B\u6587\u518D\u63D0\u8BF7\u4FEE\u6539\uFF0C\u6216\u663E\u5F0F\u8BBE replace_all=true \u6279\u91CF\u66FF\u6362\u3002`;
-              }
-              const oldFirstNonBlank = normalizedOld.split("\n").find((l) => l.trim() !== "") ?? "";
-              const baseIndent = oldFirstNonBlank.match(/^[ \t]*/)?.[0] ?? "";
-              const alignedNew = baseIndent ? reindentToBase(normalizedNew, baseIndent) : normalizedNew;
-              const updatedContent = args.replace_all ? normalizedContent.split(normalizedOld).join(alignedNew) : normalizedContent.replace(normalizedOld, () => alignedNew);
               assertWithinWorkspace(absPath);
-              await fs12.writeFile(absPath, isCRLF ? updatedContent.replace(/\n/g, "\r\n") : updatedContent, "utf-8");
-              return args.replace_all ? `\u2705 [\u4EE3\u7801\u4FEE\u8865\u6210\u529F]\uFF1A\u6587\u4EF6 [${args.path}] \u5DF2\u6279\u91CF\u66FF\u6362\u5168\u90E8 ${matchCount} \u5904\u5339\u914D\u3002${note}` : `\u2705 [\u4EE3\u7801\u4FEE\u8865\u6210\u529F]\uFF1A\u6587\u4EF6 [${args.path}] \u5DF2\u6210\u529F\u5B8C\u6210\u552F\u4E00\u6027\u5C40\u90E8\u91CD\u6784\u3002${note}`;
+              await fs12.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) {
               return `\u64CD\u4F5C\u5931\u8D25: ${error.message}`;
             }
@@ -5306,7 +5437,7 @@ ${args.new_str}`,
               }
               const content = args.content ?? "";
               assertWithinWorkspace(absPath);
-              await fs12.mkdir(path15.dirname(absPath), { recursive: true });
+              await fs12.mkdir(path16.dirname(absPath), { recursive: true });
               tmpPath = makeTmpPath(absPath);
               await fs12.writeFile(tmpPath, content, "utf-8");
               await fs12.rename(tmpPath, absPath);
@@ -5345,7 +5476,7 @@ ${args.new_str}`,
             }
             let rel = "";
             try {
-              rel = path15.relative(getActiveWorkspaceRoot(), resolveSafePath(cleanPath));
+              rel = path16.relative(getActiveWorkspaceRoot(), resolveSafePath(cleanPath));
             } catch {
             }
             if (rel === "" || rel === "src") {
@@ -5366,8 +5497,8 @@ ${args.new_str}`,
                 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 = path15.relative(getActiveWorkspaceRoot(), absPath);
-              if (!rel || rel === "" || rel === "src" || rel.startsWith("..") || path15.isAbsolute(rel)) {
+              const rel = path16.relative(getActiveWorkspaceRoot(), absPath);
+              if (!rel || rel === "" || rel === "src" || rel.startsWith("..") || path16.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;
@@ -5412,7 +5543,7 @@ ${args.new_str}`,
             try {
               const absPath = resolveSafePath(args.path);
               assertWithinWorkspace(absPath);
-              await fs12.mkdir(path15.dirname(absPath), { recursive: true });
+              await fs12.mkdir(path16.dirname(absPath), { recursive: true });
               tmpPath = makeTmpPath(absPath);
               await fs12.writeFile(tmpPath, args.content, "utf-8");
               await fs12.rename(tmpPath, absPath);
@@ -5546,7 +5677,7 @@ ${args.new_str}`,
               }
               assertWithinWorkspace(srcAbs);
               assertWithinWorkspace(dstAbs);
-              await fs12.mkdir(path15.dirname(dstAbs), { recursive: true });
+              await fs12.mkdir(path16.dirname(dstAbs), { recursive: true });
               await fs12.rename(srcAbs, dstAbs);
               return `\u2705 [\u79FB\u52A8\u6210\u529F]\uFF1A[${args.source}] \u2192 [${args.destination}]\u3002`;
             } catch (error) {
@@ -5561,7 +5692,7 @@ ${args.new_str}`,
 
 // ../core/src/tool/registry/search.ts
 import { rgPath } from "vscode-ripgrep";
-import path16 from "path";
+import path17 from "path";
 import fs13 from "fs/promises";
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -5579,13 +5710,14 @@ var init_search = __esm({
         type: "function",
         function: {
           name: "search_grep",
-          description: "\u5728\u5DE5\u4F5C\u533A\u7684\u6240\u6709\u6587\u4EF6\u4E2D\u68C0\u7D22\u5339\u914D\u7684\u4EE3\u7801\u884C\uFF0C\u6BCF\u4E2A\u547D\u4E2D\u5E26\u524D\u540E\u5404 2 \u884C\u4E0A\u4E0B\u6587\uFF08\u53EF\u76F4\u63A5\u5224\u65AD\u7528\u6CD5\u3001\u514D\u7D27\u8DDF\u4E00\u6B21 read_file\uFF09\uFF1B\u9ED8\u8BA4\u6309\u5B57\u9762\u91CF\u5173\u952E\u8BCD\u5339\u914D\uFF0C\u5982\u9700\u6B63\u5219\u4F20 is_regex=true\u3002\u591A\u6839\u5DE5\u4F5C\u533A\u4E0B\u7528 path \u9650\u5B9A\u641C\u7D22\u76EE\u5F55\uFF1A\u53EF\u4F20\u9879\u76EE\u76EE\u5F55\u540D\uFF08\u5982 'frontend'\uFF09\u81EA\u52A8\u5339\u914D\u5DE5\u4F5C\u533A\u6839\uFF0C\u6216\u4F20\u7EDD\u5BF9\u8DEF\u5F84 / \u76F8\u5BF9\u9ED8\u8BA4\u6839\u7684 ../\u5144\u5F1F\u76EE\u5F55\u3002\u2605 \u5F53\u7528\u6237\u5728\u5BF9\u8BDD\u91CC\u6307\u660E\u4E86\u67D0\u4E2A\u9879\u76EE\u65F6\uFF0C\u52A1\u5FC5\u628A\u8BE5\u9879\u76EE\u4F5C\u4E3A path \u4F20\u5165\u2014\u2014\u5426\u5219\u53EA\u4F1A\u641C\u7D22 IDE \u5934\u90E8\u6240\u793A\u7684\u6D3B\u52A8\u6839\uFF0C\u5E38\u4E0E\u7528\u6237\u610F\u56FE\u4E0D\u7B26\u3002",
+          description: "\u5728\u5DE5\u4F5C\u533A\u7684\u6240\u6709\u6587\u4EF6\u4E2D\u68C0\u7D22\u5339\u914D\u7684\u4EE3\u7801\u884C\uFF0C\u6BCF\u4E2A\u547D\u4E2D\u9ED8\u8BA4\u5E26\u524D\u540E\u5404 2 \u884C\u4E0A\u4E0B\u6587\uFF08\u53EF\u76F4\u63A5\u5224\u65AD\u7528\u6CD5\u3001\u514D\u7D27\u8DDF\u4E00\u6B21 read_file\uFF1B\u6784\u9020 edit_file \u7684 old_str \u524D\u53EF\u7528 context \u53C2\u6570\u8C03\u5927\u4E00\u6B21\u62FF\u8DB3\uFF09\uFF1B\u9ED8\u8BA4\u6309\u5B57\u9762\u91CF\u5173\u952E\u8BCD\u5339\u914D\uFF0C\u5982\u9700\u6B63\u5219\u4F20 is_regex=true\u3002\u2605 \u68C0\u7D22\u591A\u4E2A\u5173\u952E\u8BCD\u65F6\uFF0C\u7528 is_regex=true \u4EE5 | \u5408\u5E76\uFF08\u5982 'uploadVisible|uploadTip'\uFF09\u4E00\u6B21\u67E5\u5B8C\uFF0C\u52FF\u9010\u4E2A\u5173\u952E\u8BCD\u591A\u6B21\u8C03\u7528\u3002path \u53EF\u9650\u5B9A\u5230\u76EE\u5F55\u6216\u5177\u4F53\u6587\u4EF6\uFF08\u5728\u5355\u4E2A\u5927\u6587\u4EF6\u5185\u591A\u5904\u5B9A\u4F4D\u65F6\u4F20\u6587\u4EF6\u8DEF\u5F84\u6700\u9AD8\u6548\uFF09\u3002\u591A\u6839\u5DE5\u4F5C\u533A\u4E0B\uFF1A\u53EF\u4F20\u9879\u76EE\u76EE\u5F55\u540D\uFF08\u5982 'frontend'\uFF09\u81EA\u52A8\u5339\u914D\u5DE5\u4F5C\u533A\u6839\uFF0C\u6216\u4F20\u7EDD\u5BF9\u8DEF\u5F84 / \u76F8\u5BF9\u9ED8\u8BA4\u6839\u7684 ../\u5144\u5F1F\u76EE\u5F55\u3002\u2605 \u5F53\u7528\u6237\u5728\u5BF9\u8BDD\u91CC\u6307\u660E\u4E86\u67D0\u4E2A\u9879\u76EE\u65F6\uFF0C\u52A1\u5FC5\u628A\u8BE5\u9879\u76EE\u4F5C\u4E3A path \u4F20\u5165\u2014\u2014\u5426\u5219\u53EA\u4F1A\u641C\u7D22 IDE \u5934\u90E8\u6240\u793A\u7684\u6D3B\u52A8\u6839\uFF0C\u5E38\u4E0E\u7528\u6237\u610F\u56FE\u4E0D\u7B26\u3002",
           parameters: {
             type: "object",
             properties: {
-              query: { type: "string", description: "\u68C0\u7D22\u5185\u5BB9\u3002\u9ED8\u8BA4\u4E3A\u5B57\u9762\u91CF\u5173\u952E\u8BCD\uFF08\u5982 'function runAgent'\uFF09\uFF1Bis_regex=true \u65F6\u6309\u6B63\u5219\u89E3\u6790\uFF08\u5982 'function\\s+runAgent'\uFF09\u3002" },
+              query: { type: "string", description: "\u68C0\u7D22\u5185\u5BB9\u3002\u9ED8\u8BA4\u4E3A\u5B57\u9762\u91CF\u5173\u952E\u8BCD\uFF08\u5982 'function runAgent'\uFF09\uFF1Bis_regex=true \u65F6\u6309\u6B63\u5219\u89E3\u6790\uFF08\u5982 'function\\s+runAgent'\uFF0C\u591A\u5173\u952E\u8BCD\u7528 | \u5408\u5E76\uFF09" },
               is_regex: { type: "boolean", description: "\u662F\u5426\u5C06 query \u4F5C\u4E3A\u6B63\u5219\u8868\u8FBE\u5F0F\u89E3\u6790\uFF0C\u9ED8\u8BA4 false\uFF08\u5B57\u9762\u91CF\u5339\u914D\uFF0C\u81EA\u52A8\u8F6C\u4E49\u7279\u6B8A\u5B57\u7B26\uFF09" },
-              path: { type: "string", description: "\u9650\u5B9A\u641C\u7D22\u7684\u76EE\u5F55\uFF08\u53EF\u9009\uFF09\u3002\u9ED8\u8BA4\u641C\u7D22 IDE \u5934\u90E8\u6240\u793A\u6D3B\u52A8\u6839\u3002\u591A\u6839\u573A\u666F\u4E0B\uFF1A\u4F20\u9879\u76EE\u76EE\u5F55\u540D\uFF08\u5982 'frontend'\uFF09\u81EA\u52A8\u5339\u914D\u5DE5\u4F5C\u533A\u6839\uFF1B\u6216\u4F20\u7EDD\u5BF9\u8DEF\u5F84 / \u76F8\u5BF9\u9ED8\u8BA4\u6839\u7684 ../<\u5144\u5F1F\u76EE\u5F55>\uFF1B\u5747\u7ECF\u6C99\u7BB1\u6821\u9A8C\u3002\u7528\u6237\u63D0\u5230\u5177\u4F53\u9879\u76EE\u65F6\u5FC5\u586B\u3002" }
+              path: { type: "string", description: "\u9650\u5B9A\u641C\u7D22\u7684\u76EE\u5F55\u6216\u5177\u4F53\u6587\u4EF6\uFF08\u53EF\u9009\uFF09\u3002\u4F20\u5177\u4F53\u6587\u4EF6\u8DEF\u5F84\u65F6\u76F8\u5F53\u4E8E\u8BE5\u6587\u4EF6\u5185\u5168\u6587\u68C0\u7D22\uFF08\u5927\u6587\u4EF6\u591A\u5904\u5B9A\u4F4D\u9996\u9009\uFF09\u3002\u9ED8\u8BA4\u641C\u7D22 IDE \u5934\u90E8\u6240\u793A\u6D3B\u52A8\u6839\u3002\u591A\u6839\u573A\u666F\u4E0B\uFF1A\u4F20\u9879\u76EE\u76EE\u5F55\u540D\uFF08\u5982 'frontend'\uFF09\u81EA\u52A8\u5339\u914D\u5DE5\u4F5C\u533A\u6839\uFF1B\u6216\u4F20\u7EDD\u5BF9\u8DEF\u5F84 / \u76F8\u5BF9\u9ED8\u8BA4\u6839\u7684 ../<\u5144\u5F1F\u76EE\u5F55>\uFF1B\u5747\u7ECF\u6C99\u7BB1\u6821\u9A8C\u3002\u7528\u6237\u63D0\u5230\u5177\u4F53\u9879\u76EE\u65F6\u5FC5\u586B\u3002" },
+              context: { type: "number", description: "\u6BCF\u4E2A\u547D\u4E2D\u9644\u5E26\u7684\u524D\u540E\u4E0A\u4E0B\u6587\u884C\u6570\uFF080-10\uFF0C\u9ED8\u8BA4 2\uFF09\u3002\u9700\u8981\u62FF\u8DB3\u4E00\u6BB5\u5B8C\u6574\u4EE3\u7801\u4F5C edit_file \u7684 old_str \u65F6\u53EF\u8C03\u5927\uFF08\u5982 5-8\uFF09\uFF0C\u514D\u5F97\u4E8C\u6B21\u68C0\u7D22" }
             },
             required: ["query"]
           },
@@ -5603,10 +5735,10 @@ var init_search = __esm({
               const resolveSearchRoot = () => {
                 if (!args.path) return ctx?.cwd ?? getActiveWorkspaceRoot();
                 const p = args.path.trim();
-                const looksLikeBareName = !path16.isAbsolute(p) && !p.includes("/") && !p.includes("\\");
+                const looksLikeBareName = !path17.isAbsolute(p) && !p.includes("/") && !p.includes("\\");
                 if (looksLikeBareName) {
                   const hit = getAllowedWorkspaceRoots().find((r) => {
-                    const bn = path16.basename(r);
+                    const bn = path17.basename(r);
                     return bn === p || bn.toLowerCase() === p.toLowerCase();
                   });
                   if (hit) return hit;
@@ -5614,6 +5746,7 @@ var init_search = __esm({
                 return resolveReadablePath(args.path);
               };
               const searchRoot = resolveSearchRoot().replace(/\\/g, "/");
+              const contextLines = Math.min(Math.max(args.context ?? 2, 0), 10);
               const rgArgs = [
                 "--threads",
                 "1",
@@ -5624,8 +5757,8 @@ var init_search = __esm({
                 "--color",
                 "never",
                 "-C",
-                "2",
-                // ★ 每个命中带前后各 2 行上下文：模型一次看懂用法，免去紧跟的 read_file 往返（减调用次数的关键）
+                String(contextLines),
+                // ★ 每个命中带前后上下文：模型一次看懂用法，免去紧跟的 read_file 往返（减调用次数的关键）
                 "--max-count",
                 "10",
                 "--glob",
@@ -5694,7 +5827,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(path16.join(getActiveWorkspaceRoot(), name), "utf-8");
+                const content = await fs13.readFile(path17.join(getActiveWorkspaceRoot(), name), "utf-8");
                 return `[Project Guide via ${name}]
 
 ${content}`;
@@ -5927,49 +6060,91 @@ ${tail}`,
 
 // ../core/src/tool/registry/glob.ts
 import fs14 from "fs/promises";
-import path17 from "path";
-var globToRegex2, globTools;
+import path18 from "path";
+var findMatchingBrace, splitTopLevel, globToRegex2, globTools;
 var init_glob = __esm({
   "../core/src/tool/registry/glob.ts"() {
     "use strict";
     init_type();
     init_guard();
+    findMatchingBrace = (s, start) => {
+      let depth = 0;
+      for (let i = start; i < s.length; i++) {
+        if (s[i] === "{") depth++;
+        else if (s[i] === "}") {
+          depth--;
+          if (depth === 0) return i;
+        }
+      }
+      return -1;
+    };
+    splitTopLevel = (s) => {
+      const parts = [];
+      let depth = 0, cur = "";
+      for (const ch of s) {
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+        if (ch === "," && depth === 0) {
+          parts.push(cur);
+          cur = "";
+          continue;
+        }
+        cur += ch;
+      }
+      parts.push(cur);
+      return parts;
+    };
     globToRegex2 = (pattern) => {
-      let re = "";
-      let i = 0;
-      while (i < pattern.length) {
-        const c = pattern[i];
-        if (c === "*" && pattern[i + 1] === "*") {
-          if (pattern[i + 2] === "/") {
-            re += "(?:.*/)?";
-            i += 3;
+      const walk = (s) => {
+        let re = "";
+        let i = 0;
+        while (i < s.length) {
+          const c = s[i];
+          if (c === "{") {
+            const close = findMatchingBrace(s, i);
+            if (close === -1) {
+              re += "\\{";
+              i++;
+              continue;
+            }
+            const alts = splitTopLevel(s.slice(i + 1, close));
+            re += `(?:${alts.map((a) => walk(a)).join("|")})`;
+            i = close + 1;
+            continue;
+          }
+          if (c === "*" && s[i + 1] === "*") {
+            if (s[i + 2] === "/") {
+              re += "(?:.*/)?";
+              i += 3;
+            } else {
+              re += ".*";
+              i += 2;
+            }
+          } else if (c === "*") {
+            re += "[^/]*";
+            i++;
+          } else if (c === "?") {
+            re += ".";
+            i++;
           } else {
-            re += ".*";
-            i += 2;
+            re += /[.+^$}()|[\]\\]/.test(c) ? "\\" + c : c;
+            i++;
           }
-        } else if (c === "*") {
-          re += "[^/]*";
-          i++;
-        } else if (c === "?") {
-          re += ".";
-          i++;
-        } else {
-          re += /[.+^${}()|[\]\\]/.test(c) ? "\\" + c : c;
-          i++;
         }
-      }
-      return new RegExp(`^${re}$`);
+        return re;
+      };
+      return new RegExp(`^${walk(pattern)}$`);
     };
     globTools = [
       {
         type: "function",
         function: {
           name: "glob",
-          description: "\u6309\u6587\u4EF6\u540D glob \u6A21\u5F0F\u5FEB\u901F\u67E5\u627E\u6587\u4EF6\uFF08\u5982 '**/*.ts'\u3001'src/**/test*'\u3001'**/*.test.ts'\uFF09\u3002\u4E0E search_grep\uFF08\u6309\u5185\u5BB9\u68C0\u7D22\uFF09\u4E92\u8865\u3002\u81EA\u52A8\u5957\u7528 .gitignore / \u901A\u7528\u9ED1\u540D\u5355\u8FC7\u6EE4\u3002",
+          description: "\u6309\u6587\u4EF6\u540D glob \u6A21\u5F0F\u5FEB\u901F\u67E5\u627E\u6587\u4EF6\uFF08\u5982 '**/*.ts'\u3001'src/**/test*'\u3001'**/*.test.ts'\uFF09\u3002\u2605 \u652F\u6301\u82B1\u62EC\u53F7\u591A\u9009\uFF1A'**/*.{ts,tsx,vue}'\u3001'src/{api,components}/**' \u4E00\u6B21\u67E5\u591A\u7C7B\u578B/\u591A\u76EE\u5F55\uFF0C\u52FF\u5206\u591A\u6B21\u8C03\u7528\u3002\u4E0E search_grep\uFF08\u6309\u5185\u5BB9\u68C0\u7D22\uFF09\u4E92\u8865\u3002\u81EA\u52A8\u5957\u7528 .gitignore / \u901A\u7528\u9ED1\u540D\u5355\u8FC7\u6EE4\u3002",
           parameters: {
             type: "object",
             properties: {
-              pattern: { type: "string", description: "glob \u6A21\u5F0F\uFF0C\u5982 '**/*.ts' \u6216 'src/**/*.test.ts'" },
+              pattern: { type: "string", description: "glob \u6A21\u5F0F\uFF0C\u652F\u6301 * / ** / ? \u4E0E\u82B1\u62EC\u53F7\u591A\u9009 {a,b}\uFF08\u5982 '**/*.{ts,vue}'\u3001'src/{api,components}/**'\uFF09" },
               path: { type: "string", description: "\u9650\u5B9A\u641C\u7D22\u7684\u8D77\u59CB\u76EE\u5F55\uFF08\u76F8\u5BF9\u8DEF\u5F84\uFF0C\u53EF\u9009\uFF0C\u9ED8\u8BA4\u5DE5\u4F5C\u533A\u6839\uFF09" }
             },
             required: ["pattern"]
@@ -5991,16 +6166,16 @@ var init_glob = __esm({
                 if (scannedCount > MAX_SCAN_LIMIT) return;
                 const entries = await fs14.readdir(dir, { withFileTypes: true });
                 const validEntries = entries.filter((e) => {
-                  const full = path17.join(dir, e.name);
-                  const rel = path17.relative(activeRoot, full).replace(/\\/g, "/");
+                  const full = path18.join(dir, e.name);
+                  const rel = path18.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 = path17.join(dir, e.name);
-                  const rel = path17.relative(activeRoot, full).replace(/\\/g, "/");
+                  const full = path18.join(dir, e.name);
+                  const rel = path18.relative(activeRoot, full).replace(/\\/g, "/");
                   if (e.isDirectory()) {
                     if (cleanPattern.endsWith("/") && re.test(`${rel}/`)) {
                       hits.push(`${rel}/`);
@@ -6217,7 +6392,7 @@ ${summary}`;
 
 // ../core/src/tool/registry/inspect_dependencies.ts
 import * as fs15 from "fs/promises";
-import * as path18 from "path";
+import * as path19 from "path";
 var dependencyTools;
 var init_inspect_dependencies = __esm({
   "../core/src/tool/registry/inspect_dependencies.ts"() {
@@ -6238,7 +6413,7 @@ var init_inspect_dependencies = __esm({
           isSync: true,
           async execute() {
             try {
-              const pjsPath = path18.join(getActiveWorkspaceRoot(), "package.json");
+              const pjsPath = path19.join(getActiveWorkspaceRoot(), "package.json");
               const raw = await fs15.readFile(pjsPath, "utf-8");
               const pjs = JSON.parse(raw);
               const result = {
@@ -6540,13 +6715,13 @@ async function safeFetchFollow(startUrl, baseHeaders, signals, allowPrivate = fa
     return res;
   }
 }
-var FETCH_TIMEOUT_MS, SEARCH_TIMEOUT_MS, DEFAULT_MAX_CHARS, USER_AGENT, BROWSER_UA, TAVILY_ENDPOINT, formatHostBlockMessage, MAX_REDIRECTS, pinnedSsrfDispatcher, pinnedMetadataGuardDispatcher, readBodyCapped, webTools;
+var FETCH_TIMEOUT_MS2, SEARCH_TIMEOUT_MS, DEFAULT_MAX_CHARS, USER_AGENT, BROWSER_UA, TAVILY_ENDPOINT, formatHostBlockMessage, MAX_REDIRECTS, pinnedSsrfDispatcher, pinnedMetadataGuardDispatcher, readBodyCapped, webTools;
 var init_web = __esm({
   "../core/src/tool/registry/web.ts"() {
     "use strict";
     init_type();
     init_config();
-    FETCH_TIMEOUT_MS = 15e3;
+    FETCH_TIMEOUT_MS2 = 15e3;
     SEARCH_TIMEOUT_MS = 2e4;
     DEFAULT_MAX_CHARS = 16e3;
     USER_AGENT = "DeepSeeker-Code-Agent/1.0 (+web_fetch tool)";
@@ -6676,7 +6851,7 @@ var init_web = __esm({
             if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
               return `\u274C [\u5B89\u5168\u7194\u65AD]\uFF1A\u4EC5\u5141\u8BB8 http/https \u534F\u8BAE\uFF0C\u62D2\u7EDD ${parsed.protocol}`;
             }
-            const signals = [AbortSignal.timeout(FETCH_TIMEOUT_MS)];
+            const signals = [AbortSignal.timeout(FETCH_TIMEOUT_MS2)];
             if (ctx?.abortSignal) signals.push(ctx.abortSignal);
             try {
               const res = await safeFetchFollow(parsed.href, {
@@ -6713,7 +6888,7 @@ var init_web = __esm({
 ${body}${truncNote}`;
             } catch (error) {
               if (error?.name === "TimeoutError") {
-                return `\u274C [\u6293\u53D6\u8D85\u65F6]\uFF1A${FETCH_TIMEOUT_MS / 1e3}s \u5185\u672A\u54CD\u5E94\uFF1A${parsed.href}`;
+                return `\u274C [\u6293\u53D6\u8D85\u65F6]\uFF1A${FETCH_TIMEOUT_MS2 / 1e3}s \u5185\u672A\u54CD\u5E94\uFF1A${parsed.href}`;
               }
               if (error?.name === "AbortError") {
                 return `\u23F9\uFE0F [\u5DF2\u4E2D\u6B62]\uFF1A\u7528\u6237\u4E2D\u65AD\u4E86\u6293\u53D6\uFF1A${parsed.href}`;
@@ -6882,8 +7057,8 @@ var init_http = __esm({
 
 // ../core/src/tool/registry/typescript.ts
 import fs16 from "fs/promises";
-import path19 from "path";
-var MAX_FILE_BYTES, toDisplayPath, precheck, MAX_DIAG_ENTRIES, typescriptTools;
+import path20 from "path";
+var MAX_FILE_BYTES, toDisplayPath, precheck, MAX_DIAG_ENTRIES, MAX_DIAG_FILES, diagnoseOneFile, typescriptTools;
 var init_typescript = __esm({
   "../core/src/tool/registry/typescript.ts"() {
     "use strict";
@@ -6893,8 +7068,8 @@ var init_typescript = __esm({
     init_fs();
     MAX_FILE_BYTES = 1024 * 1024;
     toDisplayPath = (wsRoot, abs) => {
-      const rel = path19.relative(wsRoot, abs);
-      if (rel && !rel.startsWith("..") && !path19.isAbsolute(rel)) return rel.replace(/\\/g, "/");
+      const rel = path20.relative(wsRoot, abs);
+      if (rel && !rel.startsWith("..") && !path20.isAbsolute(rel)) return rel.replace(/\\/g, "/");
       return abs.replace(/\\/g, "/").split("/").slice(-3).join("/");
     };
     precheck = async (displayPath, absPath) => {
@@ -6907,74 +7082,108 @@ var init_typescript = __esm({
       return null;
     };
     MAX_DIAG_ENTRIES = 300;
+    MAX_DIAG_FILES = 20;
+    diagnoseOneFile = async (TS, displayPath, checkJs) => {
+      try {
+        const absPath = realpathNative(resolveReadablePath(displayPath));
+        const block = await precheck(displayPath, absPath);
+        if (block) return { ok: false, text: block };
+        const { ls } = await getLanguageService(TS, absPath, { checkJs });
+        const syntactic = ls.getSyntacticDiagnostics(absPath);
+        const semantic = ls.getSemanticDiagnostics(absPath);
+        const all = [...syntactic, ...semantic];
+        if (all.length === 0) return { ok: true, errors: 0, warnings: 0, text: `\u2713 No diagnostics (0 errors, 0 warnings) for ${displayPath}` };
+        const entries = [];
+        let errors = 0, warnings = 0;
+        for (const d of all) {
+          const cat = d.category;
+          let label;
+          if (cat === TS.DiagnosticCategory.Error) {
+            label = "error";
+            errors++;
+          } else if (cat === TS.DiagnosticCategory.Warning) {
+            label = "warning";
+            warnings++;
+          } else if (cat === TS.DiagnosticCategory.Suggestion) label = "suggestion";
+          else label = "info";
+          let line = 0, column = 0;
+          if (d.file && typeof d.start === "number") {
+            ({ line, column } = posToLineCol(TS, d.file, d.start));
+          }
+          entries.push({
+            line,
+            column,
+            label,
+            code: typeof d.code === "number" ? `TS${d.code}` : "",
+            msg: TS.flattenDiagnosticMessageText(d.messageText, "\n")
+          });
+        }
+        entries.sort((a, b) => a.line - b.line || a.column - b.column);
+        const overflow = entries.length > MAX_DIAG_ENTRIES ? entries.length - MAX_DIAG_ENTRIES : 0;
+        const shown = overflow ? entries.slice(0, MAX_DIAG_ENTRIES) : entries;
+        const body = shown.map(
+          (e) => `${displayPath}:${e.line}:${e.column}  ${e.label}${e.code ? " " + e.code : ""}  ${e.msg}`
+        ).join("\n");
+        const tail = overflow ? `
+\u2026(\u53E6\u6709 ${overflow} \u6761\u8BCA\u65AD\u672A\u663E\u793A\uFF0C\u8BF7\u7F29\u5C0F\u8303\u56F4\u6216\u7528 run_command \u8DD1 tsc \u770B\u5168\u91CF)\u2026` : "";
+        return { ok: true, errors, warnings, text: `[Diagnostics: ${displayPath}] ${errors} error(s), ${warnings} warning(s)
+${body}${tail}` };
+      } catch (e) {
+        return { ok: false, text: `\u274C \u7C7B\u578B\u8BCA\u65AD\u5931\u8D25 [${displayPath}]: ${e?.message ?? e}` };
+      }
+    };
     typescriptTools = [
       {
         type: "function",
         function: {
           name: "get_diagnostics",
-          description: "\u5BF9\u5355\u4E2A TS/JS \u6587\u4EF6\u53D6 TypeScript \u8BED\u6CD5 + \u8BED\u4E49\u8BCA\u65AD\uFF08\u7C7B\u578B\u9519\u8BEF\u3001\u672A\u7528\u53D8\u91CF\u3001\u4E0D\u53EF\u8FBE\u4EE3\u7801\u7B49\uFF09\uFF0C\u8F93\u51FA\u5E26\u884C\u53F7/\u5217/\u4E25\u91CD\u5EA6/TS \u9519\u8BEF\u7801\uFF0C\u683C\u5F0F\u5BF9\u9F50 tsc\u3002\u7528\u4E8E\u7CBE\u51C6\u5B9A\u4F4D\u7F16\u8BD1/\u7C7B\u578B\u95EE\u9898\uFF0C\u66FF\u4EE3\u624B\u52A8\u8DD1 tsc \u518D\u89E3\u6790\u8F93\u51FA\u3002\u652F\u6301 .ts/.tsx/.js/.jsx/.mjs/.cjs\uFF1B.vue SFC \u4E0D\u652F\u6301\uFF08\u9700 vue-tsc\uFF09\u3002\u9879\u76EE\u7EA7\u5168\u91CF\u8BCA\u65AD\u8BF7\u7528 run_command \u8DD1 `tsc --noEmit`\u3002\u4F9D\u8D56 typescript \u6A21\u5757\uFF08VSCode \u6269\u5C55\u5185\u53EF\u7528\uFF1B\u7F3A\u5931\u5219\u672C\u5DE5\u5177\u81EA\u52A8\u9690\u85CF\uFF09\u3002",
+          description: "\u5BF9\u4E00\u4E2A\u6216\u591A\u4E2A TS/JS \u6587\u4EF6\u53D6 TypeScript \u8BED\u6CD5 + \u8BED\u4E49\u8BCA\u65AD\uFF08\u7C7B\u578B\u9519\u8BEF\u3001\u672A\u7528\u53D8\u91CF\u3001\u4E0D\u53EF\u8FBE\u4EE3\u7801\u7B49\uFF09\uFF0C\u8F93\u51FA\u5E26\u884C\u53F7/\u5217/\u4E25\u91CD\u5EA6/TS \u9519\u8BEF\u7801\uFF0C\u683C\u5F0F\u5BF9\u9F50 tsc\u3002\u7528\u4E8E\u7CBE\u51C6\u5B9A\u4F4D\u7F16\u8BD1/\u7C7B\u578B\u95EE\u9898\uFF0C\u66FF\u4EE3\u624B\u52A8\u8DD1 tsc \u518D\u89E3\u6790\u8F93\u51FA\u3002\u2605 \u6539\u5B8C\u591A\u4E2A\u6587\u4EF6\u540E\u9A8C\u8BC1\uFF1A\u4F20 paths \u6570\u7EC4\u4E00\u6B21\u8BCA\u65AD\u5168\u90E8\uFF08\u6700\u591A 20 \u4E2A\uFF09\uFF0C\u52FF\u9010\u6587\u4EF6\u591A\u6B21\u8C03\u7528\u3002\u652F\u6301 .ts/.tsx/.js/.jsx/.mjs/.cjs\uFF1B.vue SFC \u4E0D\u652F\u6301\uFF08\u9700 vue-tsc\uFF09\u3002\u9879\u76EE\u7EA7\u5168\u91CF\u8BCA\u65AD\u8BF7\u7528 run_command \u8DD1 `tsc --noEmit`\u3002\u4F9D\u8D56 typescript \u6A21\u5757\uFF08VSCode \u6269\u5C55\u5185\u53EF\u7528\uFF1B\u7F3A\u5931\u5219\u672C\u5DE5\u5177\u81EA\u52A8\u9690\u85CF\uFF09\u3002",
           parameters: {
             type: "object",
             properties: {
-              path: { type: "string", description: "\u76EE\u6807\u6587\u4EF6\u76F8\u5BF9\u8DEF\u5F84\uFF08\u5982 'src/services/user.ts'\uFF09" },
+              path: { type: "string", description: "\u76EE\u6807\u6587\u4EF6\u76F8\u5BF9\u8DEF\u5F84\uFF08\u5982 'src/services/user.ts'\uFF09\u3002\u5355\u6587\u4EF6\u8BCA\u65AD\u7528\uFF1B\u6279\u91CF\u8BF7\u6539\u7528 paths" },
+              paths: { type: "array", items: { type: "string" }, description: "\u2605 \u6279\u91CF\u8BCA\u65AD\uFF1A\u591A\u4E2A\u6587\u4EF6\u4E00\u6B21\u9A8C\u8BC1\uFF08\u5355\u6B21\u6700\u591A 20 \u4E2A\uFF0C\u8D85\u51FA\u4F1A\u62D2\u7EDD\uFF09\u3002\u4F20\u4E86 paths \u5219\u5FFD\u7565 path" },
               check_js: { type: "boolean", description: "\u5BF9 .js/.jsx \u6587\u4EF6\u5F00\u542F\u8BED\u4E49\u68C0\u67E5\uFF08\u9ED8\u8BA4\u9075 tsconfig \u7684 checkJs\uFF1B\u76EE\u6807\u4E3A JS \u4E14\u60F3\u8981\u7C7B\u578B\u8BCA\u65AD\u65F6\u6309\u9700\u7F6E true\uFF09" }
             },
-            required: ["path"]
+            required: []
           },
           safetyLevel: "safe" /* SAFE */,
           isSync: true,
-          maxOutputCharacters: 24e3,
+          maxOutputCharacters: 48e3,
+          // ★ 批量多文件后上调（原单文件 24K；中心 truncateToolResult 仍是最终兜底）
           privacyMaskingRules: maskSecretsInContent,
           validateEnvironment: async () => !!await getTs(),
           async execute(args, _ctx) {
             try {
               const TS = await getTs();
               if (!TS) return `\u26A0\uFE0F [\u7C7B\u578B\u8BCA\u65AD\u4E0D\u53EF\u7528]\uFF1Atypescript \u6A21\u5757\u672A\u52A0\u8F7D\uFF08VSCode \u6269\u5C55\u5185\u53EF\u7528\uFF1BCLI \u73AF\u5883\u672A\u5FC5\u5B89\u88C5 typescript\uFF09\u3002\u53EF\u6539\u7528 run_command \u8DD1 \`tsc --noEmit\`\u3002`;
-              const absPath = realpathNative(resolveReadablePath(args.path));
-              const block = await precheck(args.path, absPath);
-              if (block) return block;
-              const { ls } = await getLanguageService(TS, absPath, { checkJs: args.check_js });
-              const syntactic = ls.getSyntacticDiagnostics(absPath);
-              const semantic = ls.getSemanticDiagnostics(absPath);
-              const all = [...syntactic, ...semantic];
-              if (all.length === 0) return `\u2713 No diagnostics (0 errors, 0 warnings) for ${args.path}`;
-              const entries = [];
-              let errors = 0, warnings = 0;
-              for (const d of all) {
-                const cat = d.category;
-                let label;
-                if (cat === TS.DiagnosticCategory.Error) {
-                  label = "error";
-                  errors++;
-                } else if (cat === TS.DiagnosticCategory.Warning) {
-                  label = "warning";
-                  warnings++;
-                } else if (cat === TS.DiagnosticCategory.Suggestion) label = "suggestion";
-                else label = "info";
-                let line = 0, column = 0;
-                if (d.file && typeof d.start === "number") {
-                  ({ line, column } = posToLineCol(TS, d.file, d.start));
+              const targets = args.paths && args.paths.length > 0 ? args.paths : args.path ? [args.path] : [];
+              if (targets.length === 0) return `\u274C [\u53C2\u6570\u7F3A\u5931]\uFF1A\u8BF7\u4F20 path\uFF08\u5355\u6587\u4EF6\uFF09\u6216 paths\uFF08\u6279\u91CF\uFF0C\u6539\u5B8C\u591A\u4E2A\u6587\u4EF6\u540E\u4E00\u6B21\u9A8C\u8BC1\uFF09\u3002`;
+              if (targets.length > MAX_DIAG_FILES) return `\u274C [\u53C2\u6570\u8D85\u9650]\uFF1A\u5355\u6B21\u6279\u91CF\u8BCA\u65AD\u6700\u591A ${MAX_DIAG_FILES} \u4E2A\u6587\u4EF6\uFF08\u6536\u5230 ${targets.length} \u4E2A\uFF09\u3002\u8BF7\u5206\u6279\u8C03\u7528\uFF0C\u6216\u7528 run_command \u8DD1 \`tsc --noEmit\` \u505A\u9879\u76EE\u7EA7\u5168\u91CF\u8BCA\u65AD\u3002`;
+              const results = [];
+              for (const p of targets) results.push(await diagnoseOneFile(TS, p, args.check_js));
+              if (results.length === 1) return results[0].text;
+              let totalErr = 0, totalWarn = 0, clean = 0, failed = 0;
+              const sections = [];
+              for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                if (!r.ok) {
+                  failed++;
+                  sections.push(`\u2014\u2014 ${targets[i]}\uFF08\u8BCA\u65AD\u672A\u4EA7\u51FA\uFF09\u2014\u2014
+${r.text}`);
+                  continue;
                 }
-                entries.push({
-                  line,
-                  column,
-                  label,
-                  code: typeof d.code === "number" ? `TS${d.code}` : "",
-                  msg: TS.flattenDiagnosticMessageText(d.messageText, "\n")
-                });
+                totalErr += r.errors;
+                totalWarn += r.warnings;
+                if (r.errors === 0 && r.warnings === 0) clean++;
+                sections.push(`\u2014\u2014 ${targets[i]} \u2014\u2014
+${r.text}`);
               }
-              entries.sort((a, b) => a.line - b.line || a.column - b.column);
-              const overflow = entries.length > MAX_DIAG_ENTRIES ? entries.length - MAX_DIAG_ENTRIES : 0;
-              const shown = overflow ? entries.slice(0, MAX_DIAG_ENTRIES) : entries;
-              const body = shown.map(
-                (e) => `${args.path}:${e.line}:${e.column}  ${e.label}${e.code ? " " + e.code : ""}  ${e.msg}`
-              ).join("\n");
-              const tail = overflow ? `
-\u2026(\u53E6\u6709 ${overflow} \u6761\u8BCA\u65AD\u672A\u663E\u793A\uFF0C\u8BF7\u7F29\u5C0F\u8303\u56F4\u6216\u7528 run_command \u8DD1 tsc \u770B\u5168\u91CF)\u2026` : "";
-              return `[Diagnostics: ${args.path}] ${errors} error(s), ${warnings} warning(s)
-${body}${tail}`;
+              return `[\u6279\u91CF\u8BCA\u65AD: ${targets.length} \u4E2A\u6587\u4EF6] \u5171 ${totalErr} error(s), ${totalWarn} warning(s)\uFF1B${clean} \u4E2A\u6587\u4EF6\u5E72\u51C0${failed ? `\uFF0C${failed} \u4E2A\u8BCA\u65AD\u5931\u8D25` : ""}
+
+${sections.join("\n\n")}`;
             } catch (e) {
-              return `\u274C \u7C7B\u578B\u8BCA\u65AD\u5931\u8D25 [${args.path}]: ${e?.message ?? e}`;
+              return `\u274C \u7C7B\u578B\u8BCA\u65AD\u5931\u8D25: ${e?.message ?? e}`;
             }
           }
         }
@@ -7119,7 +7328,7 @@ var init_todo = __esm({
 
 // ../core/src/observability/traceCalculate.ts
 import fs17 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 var getDirBytes, getTodayDateString;
 var init_traceCalculate = __esm({
   "../core/src/observability/traceCalculate.ts"() {
@@ -7136,7 +7345,7 @@ var init_traceCalculate = __esm({
           continue;
         }
         for (const e of entries) {
-          const p = path20.join(cur, e.name);
+          const p = path21.join(cur, e.name);
           if (e.isDirectory()) {
             stack.push(p);
           } else {
@@ -7160,7 +7369,7 @@ var init_traceCalculate = __esm({
 });
 
 // ../core/src/tool/undo/store.ts
-import path21 from "path";
+import path22 from "path";
 import fs18 from "fs/promises";
 var getUndoRootPath, getUndoClockPath, getUndoDirPath, getUndoBackupRoot, ensureUndoDir, getUndoIndexPath;
 var init_store2 = __esm({
@@ -7169,14 +7378,14 @@ var init_store2 = __esm({
     init_config();
     init_common();
     init_traceCalculate();
-    getUndoRootPath = () => path21.join(appConfig.dataDir, "undo");
-    getUndoClockPath = () => path21.join(getUndoRootPath(), "undo-cleanup-clock.json");
+    getUndoRootPath = () => path22.join(appConfig.dataDir, "undo");
+    getUndoClockPath = () => path22.join(getUndoRootPath(), "undo-cleanup-clock.json");
     getUndoDirPath = (mainSessionId) => {
       const rootId = getFileName(mainSessionId);
       assertSafeSessionId(rootId, "undoSessionId");
-      return path21.join(getUndoRootPath(), appConfig.userWorkspaceDir, rootId);
+      return path22.join(getUndoRootPath(), appConfig.userWorkspaceDir, rootId);
     };
-    getUndoBackupRoot = (mainSessionId) => path21.join(getUndoDirPath(mainSessionId), "backups");
+    getUndoBackupRoot = (mainSessionId) => path22.join(getUndoDirPath(mainSessionId), "backups");
     ensureUndoDir = async (mainSessionId) => {
       await fs18.mkdir(getUndoDirPath(mainSessionId), { recursive: true, mode: 448 });
     };
@@ -7188,14 +7397,14 @@ var init_store2 = __esm({
       const files = await fs18.readdir(dir);
       const existedFile = files.find((f) => f.endsWith(`__${rootId}.jsonl`));
       const fileName = existedFile ?? `undo-${getTodayDateString()}__${rootId}.jsonl`;
-      return path21.join(dir, fileName);
+      return path22.join(dir, fileName);
     };
   }
 });
 
 // ../core/src/tool/undo/index.ts
 import fs19 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 var undoLocks, withUndoLock, appendUndoRecord, readUndoIndex, markRestored;
 var init_undo = __esm({
   "../core/src/tool/undo/index.ts"() {
@@ -7245,7 +7454,7 @@ var init_undo = __esm({
       for (const f of files) {
         if (!f.startsWith("undo-") || !f.endsWith(".jsonl")) continue;
         try {
-          const raw = await fs19.readFile(path22.join(dir, f), "utf-8");
+          const raw = await fs19.readFile(path23.join(dir, f), "utf-8");
           for (const line of raw.split("\n")) {
             const trimmed = line.trim();
             if (!trimmed) continue;
@@ -7276,7 +7485,7 @@ var init_undo = __esm({
         }
         for (const f of files) {
           if (!f.startsWith("undo-") || !f.endsWith(".jsonl")) continue;
-          const fp = path22.join(dir, f);
+          const fp = path23.join(dir, f);
           let raw;
           try {
             raw = await fs19.readFile(fp, "utf-8");
@@ -7314,7 +7523,7 @@ var init_undo = __esm({
 
 // ../core/src/tool/undo/cleanup.ts
 import fs20 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 async function maybeCleanupAfterUndoAppend(_sessionId) {
   if (cleanupInProgress) return;
   cleanupInProgress = true;
@@ -7340,7 +7549,7 @@ async function maybeCleanupAfterUndoAppend(_sessionId) {
     lastSizeCleanupAt = now;
     diskLastCleanupAt = now;
     const clockPath = getUndoClockPath();
-    await fs20.mkdir(path23.dirname(clockPath), { recursive: true });
+    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");
     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) {
@@ -7365,12 +7574,12 @@ async function cleanupOldUndoFiles() {
   const re = /^undo-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   let deleted = 0;
   for (const rp of relativePaths) {
-    const fileName = path23.basename(rp);
+    const fileName = path24.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 = path23.join(dir, rp);
+    const fullPath = path24.join(dir, rp);
     try {
       const st = await fs20.stat(fullPath);
       if (now - st.mtimeMs < ACTIVE_GRACE_MS) continue;
@@ -7392,10 +7601,10 @@ async function evictOldestForSize(targetBytes) {
   const re = /^undo-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   const candidates = [];
   for (const rp of relativePaths) {
-    if (!re.test(path23.basename(rp))) continue;
+    if (!re.test(path24.basename(rp))) continue;
     try {
-      const st = await fs20.stat(path23.join(dir, rp));
-      candidates.push({ mtime: st.mtimeMs, fullPath: path23.join(dir, rp), size: st.size });
+      const st = await fs20.stat(path24.join(dir, rp));
+      candidates.push({ mtime: st.mtimeMs, fullPath: path24.join(dir, rp), size: st.size });
     } catch {
     }
   }
@@ -7424,7 +7633,7 @@ async function gcOrphanBackups() {
     return 0;
   }
   for (const ws of workspaces) {
-    const wsDir = path23.join(root, ws);
+    const wsDir = path24.join(root, ws);
     let stWs;
     try {
       stWs = await fs20.stat(wsDir);
@@ -7439,7 +7648,7 @@ async function gcOrphanBackups() {
       continue;
     }
     for (const sess of sessions2) {
-      const sessDir = path23.join(wsDir, sess);
+      const sessDir = path24.join(wsDir, sess);
       const liveIds = /* @__PURE__ */ new Set();
       let files;
       try {
@@ -7450,7 +7659,7 @@ async function gcOrphanBackups() {
       for (const f of files) {
         if (!f.startsWith("undo-") || !f.endsWith(".jsonl")) continue;
         try {
-          const raw = await fs20.readFile(path23.join(sessDir, f), "utf-8");
+          const raw = await fs20.readFile(path24.join(sessDir, f), "utf-8");
           for (const line of raw.split("\n")) {
             const t = line.trim();
             if (!t) continue;
@@ -7463,7 +7672,7 @@ async function gcOrphanBackups() {
         } catch {
         }
       }
-      const backupsDir = path23.join(sessDir, "backups");
+      const backupsDir = path24.join(sessDir, "backups");
       let undoDirs;
       try {
         undoDirs = await fs20.readdir(backupsDir);
@@ -7473,7 +7682,7 @@ async function gcOrphanBackups() {
       for (const ud of undoDirs) {
         if (liveIds.has(ud)) continue;
         try {
-          await fs20.rm(path23.join(backupsDir, ud), { recursive: true, force: true });
+          await fs20.rm(path24.join(backupsDir, ud), { recursive: true, force: true });
           deleted += 1;
         } catch {
         }
@@ -7516,7 +7725,7 @@ var init_cleanup = __esm({
         return 0;
       }
       for (const e of entries) {
-        const full = path23.join(dir, e.name);
+        const full = path24.join(dir, e.name);
         if (e.isDirectory()) {
           total += await getDirBytesRecursive(full);
         } else if (e.isFile()) {
@@ -7533,7 +7742,7 @@ var init_cleanup = __esm({
 
 // ../core/src/tool/undo/backup.ts
 import fs21 from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import crypto from "crypto";
 async function beforeMutationBackup(toolName, args, toolCallId, sessionId) {
   if (appConfig.undoEnabled === false) return null;
@@ -7548,7 +7757,7 @@ async function beforeMutationBackup(toolName, args, toolCallId, sessionId) {
   }
   await ensureUndoDir(sessionId);
   const undoId = createUUID();
-  const undoDir = path24.join(getUndoBackupRoot(sessionId), undoId);
+  const undoDir = path25.join(getUndoBackupRoot(sessionId), undoId);
   const now = /* @__PURE__ */ new Date();
   const common = {
     undoId,
@@ -7598,7 +7807,7 @@ async function backupFileOverwrite(common, undoDir, args) {
   }
   const content = await fs21.readFile(absPath);
   await fs21.mkdir(undoDir, { recursive: true, mode: 448 });
-  const contentPath = path24.join(undoDir, "content");
+  const contentPath = path25.join(undoDir, "content");
   await fs21.writeFile(contentPath, content, { mode: 384 });
   return {
     ...common,
@@ -7635,7 +7844,7 @@ 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 = path24.join(undoDir, "tree");
+    const treeDest = path25.join(undoDir, "tree");
     const sensitiveSet = new Set(sensitiveInTree);
     await fs21.cp(absPath, treeDest, {
       recursive: true,
@@ -7643,7 +7852,7 @@ async function backupDelete(common, undoDir, relativePath) {
       preserveTimestamps: true,
       filter: (src) => {
         if (src === absPath) return true;
-        const relWithin = path24.relative(absPath, src).replace(/\\/g, "/");
+        const relWithin = path25.relative(absPath, src).replace(/\\/g, "/");
         return !sensitiveSet.has(relWithin);
       }
     });
@@ -7660,7 +7869,7 @@ async function backupDelete(common, undoDir, relativePath) {
     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 = path24.join(undoDir, "content");
+  const contentPath = path25.join(undoDir, "content");
   await fs21.writeFile(contentPath, content, { mode: 384 });
   return {
     ...common,
@@ -7712,8 +7921,8 @@ var init_backup = __esm({
         }
         entries.sort((a, b) => a.name.localeCompare(b.name));
         for (const e of entries) {
-          const full = path24.join(d, e.name);
-          const rel = path24.relative(dir, full).replace(/\\/g, "/");
+          const full = path25.join(d, e.name);
+          const rel = path25.relative(dir, full).replace(/\\/g, "/");
           if (e.isDirectory()) {
             h.update(`D ${rel}
 `);
@@ -7739,7 +7948,7 @@ var init_backup = __esm({
         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 getDirTreeBytes(full);
         else if (e.isFile()) {
           try {
@@ -7760,11 +7969,11 @@ var init_backup = __esm({
           return;
         }
         for (const e of entries) {
-          const full = path24.join(d, e.name);
+          const full = path25.join(d, e.name);
           if (e.isDirectory()) {
             await walk(full);
           } else if (e.isFile()) {
-            const relWithin = path24.relative(dir, full).replace(/\\/g, "/");
+            const relWithin = path25.relative(dir, full).replace(/\\/g, "/");
             if (isSensitivePath(`${wsRelDir}/${relWithin}`)) found.push(relWithin);
           }
         }
@@ -7777,7 +7986,7 @@ var init_backup = __esm({
 
 // ../core/src/tool/undo/restore.ts
 import fs22 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 import crypto2 from "crypto";
 async function doRestore(target, sessionId) {
   if (target.backupKind === "directory_tree") {
@@ -7835,16 +8044,16 @@ async function ensureReverseBackup(target, sessionId) {
     }
   }
   const reverseId = createUUID();
-  const reverseDir = path25.join(getUndoBackupRoot(sessionId), reverseId);
+  const reverseDir = path26.join(getUndoBackupRoot(sessionId), reverseId);
   await fs22.mkdir(reverseDir, { recursive: true, mode: 448 });
   assertWithinWorkspace(absPath);
   const st = await fs22.stat(absPath);
   if (st.isDirectory()) {
-    const dest2 = path25.join(reverseDir, "tree");
+    const dest2 = path26.join(reverseDir, "tree");
     await fs22.cp(absPath, dest2, { recursive: true, force: true, preserveTimestamps: true });
     return { reverseId, backupKind: "directory_tree", backupPath: dest2 };
   }
-  const dest = path25.join(reverseDir, "content");
+  const dest = path26.join(reverseDir, "content");
   await fs22.writeFile(dest, await fs22.readFile(absPath));
   return { reverseId, backupKind: "file_content", backupPath: dest };
 }
@@ -7857,15 +8066,15 @@ async function dispatchRestore(r) {
       return `\u5DF2\u5220\u9664\u65B0\u5EFA\u6587\u4EF6 [${r.relativePath}]`;
     }
     case "file_content": {
-      await fs22.mkdir(path25.dirname(absPath), { recursive: true });
-      const backupAbs = path25.join(getUndoBackupRoot(r.sessionId), r.undoId, "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);
       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(path25.dirname(absPath), { recursive: true });
-      const src = path25.join(getUndoBackupRoot(r.sessionId), r.undoId, "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 });
       return `\u5DF2\u6062\u590D\u76EE\u5F55\u6811 [${r.relativePath}]\uFF08\u7EA6 ${r.fileSizeBefore ?? 0} \u5B57\u8282\uFF09`;
     }
@@ -8349,7 +8558,7 @@ var init_frontmatter = __esm({
 
 // ../core/src/memory/loader.ts
 import fs24 from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 var GLOBAL_MEMORY_DIR, SOURCES, VALID_TYPES, parseMemoryAt, loadMemories, initMemories;
 var init_loader3 = __esm({
   "../core/src/memory/loader.ts"() {
@@ -8358,10 +8567,10 @@ var init_loader3 = __esm({
     init_frontmatter();
     init_registry6();
     init_registry2();
-    GLOBAL_MEMORY_DIR = path26.join(appConfig.dataDir, "memory");
+    GLOBAL_MEMORY_DIR = path27.join(appConfig.dataDir, "memory");
     SOURCES = [
       { dir: GLOBAL_MEMORY_DIR, source: "global" },
-      { dir: path26.join(process.cwd(), ".deepseeker-code", "memory"), source: "project" }
+      { dir: path27.join(process.cwd(), ".deepseeker-code", "memory"), source: "project" }
     ];
     VALID_TYPES = ["user", "feedback", "project", "reference"];
     parseMemoryAt = async (file, _dir, source) => {
@@ -8401,7 +8610,7 @@ var init_loader3 = __esm({
       clearMemories();
       const picked = await scanSources(
         filterSources(SOURCES, includeProject),
-        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path26.join(dir, e.name) : void 0,
+        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path27.join(dir, e.name) : void 0,
         parseMemoryAt
       );
       for (const { item } of picked) registerMemory(item);
@@ -8420,7 +8629,7 @@ var init_loader3 = __esm({
 
 // ../core/src/tool/registry/memory.ts
 import fs25 from "fs/promises";
-import path27 from "path";
+import path28 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"() {
@@ -8432,7 +8641,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 ? path27.join(process.cwd(), ".deepseeker-code", "memory", `${name}.md`) : path27.join(GLOBAL_MEMORY_DIR, `${name}.md`);
+    memoryFilePath = (name, project) => project ? path28.join(process.cwd(), ".deepseeker-code", "memory", `${name}.md`) : path28.join(GLOBAL_MEMORY_DIR, `${name}.md`);
     sanitizeLine = (s) => String(s ?? "").replace(/[\r\n]+/g, " ").trim();
     buildMemoryMd = (name, description, type, body) => `---
 name: ${name}
@@ -8444,7 +8653,7 @@ ${body.trim()}
 `;
     writeAndRegister = async (name, description, type, body, project) => {
       const file = memoryFilePath(name, project);
-      await fs25.mkdir(path27.dirname(file), { recursive: true });
+      await fs25.mkdir(path28.dirname(file), { recursive: true });
       const tmp = makeTmpPath(file);
       await fs25.writeFile(tmp, buildMemoryMd(name, description, type, body), "utf-8");
       await fs25.rename(tmp, file);
@@ -8818,7 +9027,6 @@ var agentTools, agentSubTools, workflowTools;
 var init_tool = __esm({
   "../core/src/tool/index.ts"() {
     "use strict";
-    init_system();
     init_agent();
     init_workflow();
     init_fs();
@@ -8844,7 +9052,6 @@ var init_tool = __esm({
     agentSubTools = createAgentTools(() => agentTools);
     workflowTools = createWorkflowTools(() => agentTools);
     agentTools.push(
-      ...systemTools,
       ...agentSubTools,
       ...workflowTools,
       ...fsTools,
@@ -8986,7 +9193,7 @@ var init_backgroundTool = __esm({
 });
 
 // ../core/src/tool/autoPermission.ts
-import path28 from "path";
+import path29 from "path";
 var AUTO_SCOPE, AUTO_DEFAULT_EXTRA, AUTO_AGGRESSIVE_EXTRA, isMcpTool, BUILTIN_AUTO_DENY, matchBuiltinDeny, COMMAND_DENY, matchCommandDeny, hasShellMetachars, READONLY_HEADS, hasWriteModifier, SENSITIVE_FILE_ARG_RE, hasSensitiveFileArg, isReadOnlyCommand, isWithinWorkspace, runAutoCheck;
 var init_autoPermission = __esm({
   "../core/src/tool/autoPermission.ts"() {
@@ -9121,9 +9328,9 @@ var init_autoPermission = __esm({
     isWithinWorkspace = (p, cwd) => {
       if (!p || !cwd) return false;
       try {
-        const abs = path28.isAbsolute(p) ? p : path28.resolve(cwd, p);
-        const rel = path28.relative(cwd, abs);
-        return rel === "" || !rel.startsWith("..") && !path28.isAbsolute(rel);
+        const abs = path29.isAbsolute(p) ? p : path29.resolve(cwd, p);
+        const rel = path29.relative(cwd, abs);
+        return rel === "" || !rel.startsWith("..") && !path29.isAbsolute(rel);
       } catch {
         return false;
       }
@@ -10415,7 +10622,7 @@ var init_subagent = __esm({
 
 // ../core/src/hooks/loader.ts
 import fs27 from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 var readHooksConfig, appendValidated, validateRule, parseStdoutDecision, parseAgentDecision, compileRule2, loadHooks, initHooks;
 var init_loader4 = __esm({
   "../core/src/hooks/loader.ts"() {
@@ -10430,9 +10637,9 @@ var init_loader4 = __esm({
     readHooksConfig = async (includeProject) => {
       const merged = {};
       const paths = [
-        path29.join(appConfig.dataDir, "settings.json"),
+        path30.join(appConfig.dataDir, "settings.json"),
         // 全局用户级
-        ...includeProject ? [path29.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
+        ...includeProject ? [path30.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
         // 项目级（叠加）；未信任时省略
       ];
       for (const configPath of paths) {
@@ -10769,8 +10976,8 @@ ${m.context}`;
 
 // ../core/src/skills/loader.ts
 import fs28 from "fs/promises";
-import path30 from "path";
-import { fileURLToPath } from "url";
+import path31 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var BUILTIN_DIR, SOURCES2, MAX_SKILL_BODY_BYTES, splitList, parseSkillAt, loadSkills, initSkills;
 var init_loader5 = __esm({
   "../core/src/skills/loader.ts"() {
@@ -10780,11 +10987,11 @@ var init_loader5 = __esm({
     init_registry3();
     init_skill();
     init_registry2();
-    BUILTIN_DIR = path30.join(path30.dirname(fileURLToPath(import.meta.url)), "builtin");
+    BUILTIN_DIR = path31.join(path31.dirname(fileURLToPath2(import.meta.url)), "builtin");
     SOURCES2 = [
       { dir: BUILTIN_DIR, source: "builtin" },
-      { dir: path30.join(appConfig.dataDir, "skills"), source: "global" },
-      { dir: path30.join(process.cwd(), ".deepseeker-code", "skills"), source: "project" }
+      { dir: path31.join(appConfig.dataDir, "skills"), source: "global" },
+      { dir: path31.join(process.cwd(), ".deepseeker-code", "skills"), source: "project" }
     ];
     MAX_SKILL_BODY_BYTES = 64 * 1024;
     splitList = (raw) => (raw ?? "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -10830,7 +11037,7 @@ var init_loader5 = __esm({
     loadSkills = async (includeProject) => {
       const picked = await scanSources(
         filterSources(SOURCES2, includeProject),
-        (e, dir) => e.isDirectory() ? path30.join(dir, e.name, "SKILL.md") : void 0,
+        (e, dir) => e.isDirectory() ? path31.join(dir, e.name, "SKILL.md") : void 0,
         parseSkillAt
       );
       for (const { item } of picked) registerSkill(item);
@@ -10862,8 +11069,8 @@ var init_loader5 = __esm({
 
 // ../core/src/agents/loader.ts
 import fs29 from "fs/promises";
-import path31 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import path32 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var BUILTIN_DIR2, SOURCES3, parseAgentAt, initAgents;
 var init_loader6 = __esm({
   "../core/src/agents/loader.ts"() {
@@ -10872,11 +11079,11 @@ var init_loader6 = __esm({
     init_frontmatter();
     init_registry4();
     init_registry2();
-    BUILTIN_DIR2 = path31.join(path31.dirname(fileURLToPath2(import.meta.url)), "builtin");
+    BUILTIN_DIR2 = path32.join(path32.dirname(fileURLToPath3(import.meta.url)), "builtin");
     SOURCES3 = [
       { dir: BUILTIN_DIR2, source: "builtin" },
-      { dir: path31.join(appConfig.dataDir, "agents"), source: "global" },
-      { dir: path31.join(process.cwd(), ".deepseeker-code", "agents"), source: "project" }
+      { dir: path32.join(appConfig.dataDir, "agents"), source: "global" },
+      { dir: path32.join(process.cwd(), ".deepseeker-code", "agents"), source: "project" }
     ];
     parseAgentAt = async (file, dir, source) => {
       let raw;
@@ -10916,7 +11123,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") ? path31.join(dir, e.name) : void 0,
+          (e, dir) => e.isFile() && e.name.endsWith(".agent.md") ? path32.join(dir, e.name) : void 0,
           parseAgentAt
         );
         for (const { item: m, file, source } of picked) {
@@ -10954,8 +11161,8 @@ var init_registry7 = __esm({
 
 // ../core/src/commands/loader.ts
 import fs30 from "fs/promises";
-import path32 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import path33 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 var BUILTIN_DIR3, SOURCES4, MAX_COMMAND_BODY_BYTES, parseCommandAt, loadCommands, initCommands;
 var init_loader7 = __esm({
   "../core/src/commands/loader.ts"() {
@@ -10964,11 +11171,11 @@ var init_loader7 = __esm({
     init_frontmatter();
     init_registry7();
     init_registry2();
-    BUILTIN_DIR3 = path32.join(path32.dirname(fileURLToPath3(import.meta.url)), "builtin");
+    BUILTIN_DIR3 = path33.join(path33.dirname(fileURLToPath4(import.meta.url)), "builtin");
     SOURCES4 = [
       { dir: BUILTIN_DIR3, source: "builtin" },
-      { dir: path32.join(appConfig.dataDir, "commands"), source: "global" },
-      { dir: path32.join(process.cwd(), ".deepseeker-code", "commands"), source: "project" }
+      { dir: path33.join(appConfig.dataDir, "commands"), source: "global" },
+      { dir: path33.join(process.cwd(), ".deepseeker-code", "commands"), source: "project" }
     ];
     MAX_COMMAND_BODY_BYTES = 64 * 1024;
     parseCommandAt = async (file, _dir, source) => {
@@ -10985,7 +11192,7 @@ var init_loader7 = __esm({
       }
       const name = parsed.frontmatter.name;
       const description = parsed.frontmatter.description;
-      const fallbackName = path32.basename(file, ".md");
+      const fallbackName = path33.basename(file, ".md");
       const finalName = name || fallbackName;
       if (!description) {
         console.warn(`\u26A0\uFE0F [commands] \u7F3A\u5C11 description\uFF08${file}\uFF09\uFF0C\u5DF2\u8DF3\u8FC7`);
@@ -11011,7 +11218,7 @@ var init_loader7 = __esm({
     loadCommands = async (includeProject) => {
       const picked = await scanSources(
         filterSources(SOURCES4, includeProject),
-        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path32.join(dir, e.name) : void 0,
+        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path33.join(dir, e.name) : void 0,
         parseCommandAt
       );
       for (const { item } of picked) registerCommand(item);
@@ -11030,8 +11237,8 @@ var init_loader7 = __esm({
 
 // ../core/src/outputStyles/loader.ts
 import fs31 from "fs/promises";
-import path33 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import path34 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 var BUILTIN_DIR4, MAX_STYLE_BODY_BYTES, SOURCES5, parseStyleAt, loadOutputStyles, initOutputStyles;
 var init_loader8 = __esm({
   "../core/src/outputStyles/loader.ts"() {
@@ -11040,12 +11247,12 @@ var init_loader8 = __esm({
     init_frontmatter();
     init_registry5();
     init_registry2();
-    BUILTIN_DIR4 = path33.join(path33.dirname(fileURLToPath4(import.meta.url)), "builtin");
+    BUILTIN_DIR4 = path34.join(path34.dirname(fileURLToPath5(import.meta.url)), "builtin");
     MAX_STYLE_BODY_BYTES = 64 * 1024;
     SOURCES5 = [
       { dir: BUILTIN_DIR4, source: "builtin" },
-      { dir: path33.join(appConfig.dataDir, "output-styles"), source: "global" },
-      { dir: path33.join(process.cwd(), ".deepseeker-code", "output-styles"), source: "project" }
+      { dir: path34.join(appConfig.dataDir, "output-styles"), source: "global" },
+      { dir: path34.join(process.cwd(), ".deepseeker-code", "output-styles"), source: "project" }
     ];
     parseStyleAt = async (file, _dir, source) => {
       let raw;
@@ -11082,7 +11289,7 @@ var init_loader8 = __esm({
     loadOutputStyles = async (includeProject) => {
       const picked = await scanSources(
         filterSources(SOURCES5, includeProject),
-        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path33.join(dir, e.name) : void 0,
+        (e, dir) => e.isFile() && e.name.endsWith(".md") ? path34.join(dir, e.name) : void 0,
         parseStyleAt
       );
       for (const { item } of picked) registerOutputStyle(item);
@@ -11164,7 +11371,7 @@ var init_bootstrap = __esm({
 
 // ../core/src/statusLine/config.ts
 import fs32 from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 var parseBlock, readStatusLineConfig;
 var init_config2 = __esm({
   "../core/src/statusLine/config.ts"() {
@@ -11180,9 +11387,9 @@ var init_config2 = __esm({
     };
     readStatusLineConfig = async (includeProject) => {
       const paths = [
-        path34.join(appConfig.dataDir, "settings.json"),
+        path35.join(appConfig.dataDir, "settings.json"),
         // 全局用户级
-        ...includeProject ? [path34.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
+        ...includeProject ? [path35.join(process.cwd(), ".deepseeker-code", "settings.json")] : []
         // 项目级（覆盖）；未信任时省略
       ];
       let result = null;
@@ -11210,8 +11417,8 @@ var init_config2 = __esm({
 // ../core/src/statusLine/runner.ts
 import { spawn as spawn5 } from "child_process";
 import fs33 from "fs";
-import path35 from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import path36 from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
 var STATUSLINE_TIMEOUT_MS, cachedVersion, runStatusLine;
 var init_runner = __esm({
   "../core/src/statusLine/runner.ts"() {
@@ -11219,11 +11426,11 @@ var init_runner = __esm({
     init_guard();
     STATUSLINE_TIMEOUT_MS = 3e3;
     try {
-      const here = path35.dirname(fileURLToPath5(import.meta.url));
+      const here = path36.dirname(fileURLToPath6(import.meta.url));
       const candidates = [
-        path35.join(here, "../../../package.json"),
+        path36.join(here, "../../../package.json"),
         // src/core/package.json
-        path35.join(here, "../../../../package.json")
+        path36.join(here, "../../../../package.json")
         // 仓库根 package.json
       ];
       for (const p of candidates) {
@@ -11287,7 +11494,7 @@ var init_createModel = __esm({
 });
 
 // ../core/src/observability/store.ts
-import path36 from "path";
+import path37 from "path";
 import fs34 from "fs/promises";
 var getTraceDirPath, getTracePath, tracePathCache, ensuredTraceDirs, ensureTraceDir, getGlobalClockPath, getTraceStorePath;
 var init_store3 = __esm({
@@ -11298,10 +11505,10 @@ var init_store3 = __esm({
     init_common();
     getTraceDirPath = (mainTraceId) => {
       assertSafeSessionId(mainTraceId, "traceId");
-      return path36.join(appConfig.dataDir, "trace", appConfig.userWorkspaceDir, getFileName(mainTraceId));
+      return path37.join(appConfig.dataDir, "trace", appConfig.userWorkspaceDir, getFileName(mainTraceId));
     };
     getTracePath = () => {
-      return path36.join(appConfig.dataDir, "trace");
+      return path37.join(appConfig.dataDir, "trace");
     };
     tracePathCache = /* @__PURE__ */ new Map();
     ensuredTraceDirs = /* @__PURE__ */ new Set();
@@ -11312,7 +11519,7 @@ var init_store3 = __esm({
       ensuredTraceDirs.add(dir);
     };
     getGlobalClockPath = () => {
-      return path36.join(getTracePath(), "trace-cleanup-clock.json");
+      return path37.join(getTracePath(), "trace-cleanup-clock.json");
     };
     getTraceStorePath = async (mainTraceId) => {
       assertSafeSessionId(mainTraceId, "traceId");
@@ -11330,7 +11537,7 @@ var init_store3 = __esm({
         const todayStr = getTodayDateString();
         fileName = `trace-${todayStr}__${rootId}.jsonl`;
       }
-      const resolved = path36.join(dir, fileName);
+      const resolved = path37.join(dir, fileName);
       tracePathCache.set(rootId, resolved);
       return resolved;
     };
@@ -11339,7 +11546,7 @@ var init_store3 = __esm({
 
 // ../core/src/observability/trace.ts
 import fs35 from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 async function emitTrace(base) {
   const event = {
     sessionId: base.sessionId,
@@ -11393,7 +11600,7 @@ async function maybeCleanupAfterAppend(sessionId) {
     lastSizeCleanupAt2 = now;
     diskLastCleanupAt2 = now;
     const clockPath = getGlobalClockPath();
-    await fs35.mkdir(path37.dirname(clockPath), { recursive: true });
+    await fs35.mkdir(path38.dirname(clockPath), { recursive: true });
     await fs35.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`);
@@ -11420,12 +11627,12 @@ async function cleanupOldTraceFiles() {
   }
   const re = /^trace-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   for (const relativePath of relativePaths) {
-    const fileName = path37.basename(relativePath);
+    const fileName = path38.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 = path37.join(dir, relativePath);
+    const fullPath = path38.join(dir, relativePath);
     try {
       const st = await fs35.stat(fullPath);
       if (now - st.mtimeMs < ACTIVE_GRACE_MS2) continue;
@@ -11447,11 +11654,11 @@ async function evictOldestForSize2(targetBytes) {
   const re = /^trace-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   const candidates = [];
   for (const relativePath of relativePaths) {
-    const fileName = path37.basename(relativePath);
+    const fileName = path38.basename(relativePath);
     if (!re.test(fileName)) continue;
     try {
-      const st = await fs35.stat(path37.join(dir, relativePath));
-      candidates.push({ mtime: st.mtimeMs, fullPath: path37.join(dir, relativePath), size: st.size });
+      const st = await fs35.stat(path38.join(dir, relativePath));
+      candidates.push({ mtime: st.mtimeMs, fullPath: path38.join(dir, relativePath), size: st.size });
     } catch {
     }
   }
@@ -11638,7 +11845,7 @@ ${PLAN_MODE_AUTO_ENTER_HINT}
 });
 
 // ../core/src/serve/chatProcessing.ts
-import path38 from "path";
+import path39 from "path";
 import fs36 from "fs";
 var handleUnifiedChat;
 var init_chatProcessing = __esm({
@@ -11696,14 +11903,14 @@ ${inject}`;
           activeReal = fs36.realpathSync(activeReal);
         } catch {
         }
-        const lines = roots.map((r) => `- ${path38.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) => `- ${path39.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${path38.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 ${path38.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${path39.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 ${path39.basename(activeReal) || activeReal} \u751F\u6548\u3002`;
       }
       let replyText = "";
       try {
@@ -12442,14 +12649,17 @@ var init_useChatState = __esm({
           await runOnce(sid, `\uFF08\u7528\u6237\u5DF2\u6279\u51C6\u4EE5\u4E0B\u65B9\u6848\uFF0C\u8BF7\u4E25\u683C\u6309\u65B9\u6848\u5F00\u59CB\u5B9E\u73B0\uFF09\uFF1A
 
 ${finalPlan}`, false, res.autoExecute);
-        } else {
-          pushInfo(S.planRejected);
+          return true;
         }
+        planModeRef.current = true;
+        pushInfo(S.planKeepPlanning);
+        return false;
       }, [runOnce, setPlan, pushInfo]);
       const runPlanStage = useCallback(async (sid, researchPrompt) => {
         await runOnce(sid, researchPrompt, true);
         const plan = takeProposedPlan();
-        if (plan != null) await approveAndImplement(sid, plan);
+        if (plan == null) return false;
+        return await approveAndImplement(sid, plan);
       }, [runOnce, takeProposedPlan, approveAndImplement]);
       const queueInput = useCallback((content) => {
         const text = content.trim();
@@ -12472,7 +12682,8 @@ ${finalPlan}`, false, res.autoExecute);
           const sid = sessionIdRef.current;
           pushUser(text);
           if (planModeRef.current) {
-            await runPlanStage(sid, text);
+            const kept = await runPlanStage(sid, text);
+            if (kept) planModeRef.current = false;
           } else {
             await runOnce(sid, text, false);
             const proposedPlan = takeProposedPlan();
@@ -12483,8 +12694,8 @@ ${finalPlan}`, false, res.autoExecute);
               if (enterReason != null) {
                 pushInfo(`\u{1F4CB} \u6A21\u578B\u8BF7\u6C42\u8FDB\u5165\u8BA1\u5212\u6A21\u5F0F${enterReason ? `\uFF1A${enterReason}` : ""}\uFF0C\u5DF2\u5207\u6362\u2026`);
                 planModeRef.current = true;
-                await runPlanStage(sid, ENTER_PLAN_RESEARCH_PROMPT);
-                planModeRef.current = false;
+                const kept = await runPlanStage(sid, ENTER_PLAN_RESEARCH_PROMPT);
+                if (kept) planModeRef.current = false;
               }
             }
           }
@@ -12748,6 +12959,8 @@ var init_MessageBlock = __esm({
       return { bullet: `${m[2]} `, rest: m[3] };
     };
     AssistantLine = ({ line }) => {
+      const heading = line.match(/^#{1,6}\s+(.*)$/);
+      if (heading) return /* @__PURE__ */ jsx3(Text3, { bold: true, color: "#ffffff", children: heading[1] });
       const list = listPrefix(line);
       if (list) {
         return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
@@ -12897,6 +13110,149 @@ var init_ThinkingBlock = __esm({
   }
 });
 
+// src/lineDiff.ts
+var splitLines, lineDiff, collapseContext;
+var init_lineDiff = __esm({
+  "src/lineDiff.ts"() {
+    "use strict";
+    splitLines = (s) => {
+      const t = String(s ?? "").replace(/\r\n/g, "\n");
+      return t === "" ? [] : t.split("\n");
+    };
+    lineDiff = (oldStr, newStr) => {
+      const a = splitLines(oldStr);
+      const b = splitLines(newStr);
+      let s = 0;
+      while (s < a.length && s < b.length && a[s] === b[s]) s++;
+      let e = 0;
+      while (e < a.length - s && e < b.length - s && a[a.length - 1 - e] === b[b.length - 1 - e]) e++;
+      const m1 = a.slice(s, a.length - e);
+      const m2 = b.slice(s, b.length - e);
+      const rows = [];
+      for (let i = 0; i < s; i++) rows.push({ t: "ctx", s: a[i] });
+      const n = m1.length, m = m2.length;
+      if (n === 0 && m === 0) {
+      } else if (n * m > 4e6) {
+        for (const l of m1) rows.push({ t: "del", s: l });
+        for (const l of m2) rows.push({ t: "add", s: l });
+      } else {
+        const w = m + 1;
+        const dp = new Uint32Array((n + 1) * w);
+        for (let i2 = n - 1; i2 >= 0; i2--) {
+          for (let j2 = m - 1; j2 >= 0; j2--) {
+            dp[i2 * w + j2] = m1[i2] === m2[j2] ? dp[(i2 + 1) * w + j2 + 1] + 1 : Math.max(dp[(i2 + 1) * w + j2], dp[i2 * w + j2 + 1]);
+          }
+        }
+        let i = 0, j = 0;
+        while (i < n && j < m) {
+          if (m1[i] === m2[j]) {
+            rows.push({ t: "ctx", s: m1[i] });
+            i++;
+            j++;
+          } else if (dp[(i + 1) * w + j] >= dp[i * w + j + 1]) {
+            rows.push({ t: "del", s: m1[i] });
+            i++;
+          } else {
+            rows.push({ t: "add", s: m2[j] });
+            j++;
+          }
+        }
+        while (i < n) {
+          rows.push({ t: "del", s: m1[i] });
+          i++;
+        }
+        while (j < m) {
+          rows.push({ t: "add", s: m2[j] });
+          j++;
+        }
+      }
+      for (let k = 0; k < e; k++) rows.push({ t: "ctx", s: a[a.length - e + k] });
+      return rows;
+    };
+    collapseContext = (rows, keep = 2) => {
+      const out = [];
+      let i = 0;
+      while (i < rows.length) {
+        if (rows[i].t !== "ctx") {
+          out.push(rows[i]);
+          i++;
+          continue;
+        }
+        let j = i;
+        while (j < rows.length && rows[j].t === "ctx") j++;
+        const run = j - i;
+        if (run > keep * 2 + 1) {
+          for (let k = 0; k < keep; k++) out.push(rows[i + k]);
+          out.push({ t: "ellip", n: run - keep * 2 });
+          for (let k = run - keep; k < run; k++) out.push(rows[i + k]);
+        } else {
+          for (let k = 0; k < run; k++) out.push(rows[i + k]);
+        }
+        i = j;
+      }
+      return out;
+    };
+  }
+});
+
+// src/diffView.ts
+var EDIT_TOOL_NAMES, extractEditPairs, pairsToDisplayRows, parseApprovalDiff;
+var init_diffView = __esm({
+  "src/diffView.ts"() {
+    "use strict";
+    init_lineDiff();
+    EDIT_TOOL_NAMES = ["edit_file", "create_file", "write_file"];
+    extractEditPairs = (toolName, args) => {
+      if (args == null || typeof args !== "object") return null;
+      const o = args;
+      if (toolName === "edit_file") {
+        const list = Array.isArray(o.edits) && o.edits.length > 0 ? o.edits : [o];
+        const pairs = list.filter((e) => typeof e.old_str === "string" && e.old_str.length > 0);
+        if (pairs.length === 0) return null;
+        return pairs.map((e, i) => ({
+          label: pairs.length > 1 ? `\u7B2C ${i + 1} \u5904${e.replace_all ? "\uFF08\u6279\u91CF\u66FF\u6362\u5168\u90E8\u5339\u914D\uFF09" : ""}` : "",
+          old: e.old_str,
+          new: typeof e.new_str === "string" ? e.new_str : ""
+        }));
+      }
+      if (toolName === "create_file" || toolName === "write_file") {
+        return typeof o.content === "string" && o.content.length > 0 ? [{ label: "", old: "", new: o.content }] : null;
+      }
+      return null;
+    };
+    pairsToDisplayRows = (pairs, keep = 2) => {
+      const out = [];
+      let changed = false;
+      for (const p of pairs) {
+        const collapsed = collapseContext(lineDiff(p.old, p.new), keep);
+        if (!collapsed.some((r) => r.t !== "ctx" && r.t !== "ellip")) continue;
+        changed = true;
+        if (p.label) {
+          if (out.length > 0) out.push({ t: "ellip", n: 0 });
+          out.push({ t: "ctx", s: `\u2014\u2014 ${p.label} \u2014\u2014` });
+        }
+        out.push(...collapsed);
+      }
+      return changed ? out : null;
+    };
+    parseApprovalDiff = (detail, toolName) => {
+      if (toolName !== "edit_file" || !detail.includes("\u3010\u51CF\u5C11\u3011:")) return null;
+      const parts = detail.split(/\n(?=—— 第 )/);
+      const sections = [];
+      for (const part of parts.slice(1)) {
+        const label = (part.match(/^—— (第 \d+ 处[^\n]*)——/)?.[1] ?? "").trim();
+        const rIdx = part.indexOf("\u3010\u51CF\u5C11\u3011:");
+        const aIdx = part.indexOf("\u3010\u589E\u52A0\u3011:");
+        if (rIdx < 0 || aIdx < 0 || aIdx < rIdx) continue;
+        const old = part.slice(rIdx + "\u3010\u51CF\u5C11\u3011:".length, aIdx).replace(/^\n+|\n+$/g, "");
+        const neu = part.slice(aIdx + "\u3010\u589E\u52A0\u3011:".length).replace(/^\n+|\n+$/g, "");
+        sections.push({ label, old, new: neu });
+      }
+      return sections.length > 0 ? { header: parts[0], sections } : null;
+    };
+  }
+});
+
 // src/components/ToolCard.tsx
 import { Box as Box3, Text as Text5 } from "ink";
 import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
@@ -12906,6 +13262,7 @@ var init_ToolCard = __esm({
     "use strict";
     init_theme();
     init_util();
+    init_diffView();
     ToolCard = ({ toolName, args, result, ok, status, progress, wrapW }) => {
       const tool = findTool(toolName);
       const level = tool?.function?.safetyLevel;
@@ -12922,6 +13279,15 @@ var init_ToolCard = __esm({
         const last = progress.replace(/\r/g, "").split("\n").map((s) => s.trim()).filter(Boolean).pop() ?? "";
         return truncateMiddle(last, Math.max(20, wrapW - 6));
       })();
+      const MAX_DIFF_LINES2 = 14;
+      const diffAll = (() => {
+        if (status !== "done" || !ok) return null;
+        if (!EDIT_TOOL_NAMES.includes(toolName)) return null;
+        const pairs = extractEditPairs(toolName, args);
+        return pairs ? pairsToDisplayRows(pairs) : null;
+      })();
+      const diffRows = diffAll ? diffAll.slice(0, MAX_DIFF_LINES2) : null;
+      const diffHidden = diffAll ? Math.max(0, diffAll.length - MAX_DIFF_LINES2) : 0;
       return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 0.3, marginBottom: 0.3, children: [
         /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", flexShrink: 0, children: [
           /* @__PURE__ */ jsx5(Text5, { color: markerColor, bold: true, children: "\u23FA " }),
@@ -12935,6 +13301,14 @@ var init_ToolCard = __esm({
         ] }, i)) : status === "running" ? /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", flexShrink: 0, children: [
           /* @__PURE__ */ jsx5(Text5, { color: THEME.grayDim, children: "  \u23BF  " }),
           /* @__PURE__ */ jsx5(Text5, { color: THEME.gray, children: runningLine || "\u8FD0\u884C\u4E2D\u2026" })
+        ] }) : null,
+        diffRows && diffRows.length > 0 ? diffRows.map((r, i) => /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", flexShrink: 0, children: [
+          /* @__PURE__ */ jsx5(Text5, { color: THEME.grayDim, children: "     " }),
+          r.t === "ellip" ? /* @__PURE__ */ jsx5(Text5, { color: THEME.grayDim, children: r.n > 0 ? `  \u22EF ${r.n} \u884C\u672A\u53D8` : "  \u22EF" }) : /* @__PURE__ */ jsx5(Text5, { color: r.t === "del" ? THEME.danger : r.t === "add" ? THEME.ok : THEME.grayDim, children: `${r.t === "del" ? "- " : r.t === "add" ? "+ " : "  "}${truncateMiddle(r.s, Math.max(20, wrapW - 8))}` })
+        ] }, `diff-${i}`)) : null,
+        diffHidden > 0 ? /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", flexShrink: 0, children: [
+          /* @__PURE__ */ jsx5(Text5, { color: THEME.grayDim, children: "     " }),
+          /* @__PURE__ */ jsx5(Text5, { color: THEME.grayDim, children: `  \u2026\uFF08\u53E6\u6709 ${diffHidden} \u884C\u6539\u52A8\u672A\u663E\u793A\uFF09` })
         ] }) : null
       ] });
     };
@@ -12978,28 +13352,36 @@ var init_TodosPanel = __esm({
 
 // src/components/ApprovalModal.tsx
 import { Box as Box5, Text as Text7 } from "ink";
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
-var OPTIONS, ApprovalModal;
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var OPTIONS, MAX_DIFF_LINES, ApprovalModal;
 var init_ApprovalModal = __esm({
   "src/components/ApprovalModal.tsx"() {
     "use strict";
     init_theme();
     init_strings();
     init_util();
+    init_diffView();
     OPTIONS = [
       { label: S.approvalAllow, value: "allow-once", color: THEME.ok },
       { label: S.approvalAllowAlways, value: "allow-always", color: THEME.warn },
       { label: S.approvalDeny, value: "deny", color: THEME.danger }
     ];
+    MAX_DIFF_LINES = 18;
     ApprovalModal = ({ toolName, detail, selectedIndex, wrapW }) => {
       const contentW = Math.max(16, wrapW);
+      const parsed = parseApprovalDiff(detail, toolName);
+      const diffRows = parsed ? pairsToDisplayRows(parsed.sections) : null;
       return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: THEME.warn, paddingX: 1, paddingY: 1, marginTop: 1, children: [
         /* @__PURE__ */ jsxs5(Text7, { color: THEME.warn, bold: true, children: [
           S.approvalTitle,
           " \xB7 ",
           toolName
         ] }),
-        /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", marginTop: 0.5, marginBottom: 0.5, children: wrapText(detail || "(\u65E0\u8BF4\u660E)", contentW).map((line, j) => /* @__PURE__ */ jsx7(Text7, { color: THEME.white, children: line }, j)) }),
+        /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", marginTop: 0.5, marginBottom: 0.5, children: parsed && diffRows ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+          wrapText(parsed.header, contentW).map((line, j) => /* @__PURE__ */ jsx7(Text7, { color: THEME.white, children: line }, `h-${j}`)),
+          diffRows.slice(0, MAX_DIFF_LINES).map((r, i) => /* @__PURE__ */ jsx7(Text7, { color: r.t === "del" ? THEME.danger : r.t === "add" ? THEME.ok : THEME.grayDim, children: r.t === "ellip" ? r.n > 0 ? `  \u22EF ${r.n} \u884C\u672A\u53D8` : "  \u22EF" : `${r.t === "del" ? "- " : r.t === "add" ? "+ " : "  "}${truncateMiddle(r.s, Math.max(20, contentW - 2))}` }, `d-${i}`)),
+          diffRows.length > MAX_DIFF_LINES ? /* @__PURE__ */ jsx7(Text7, { color: THEME.grayDim, children: `  \u2026\uFF08\u53E6\u6709 ${diffRows.length - MAX_DIFF_LINES} \u884C\u672A\u663E\u793A\uFF09` }) : null
+        ] }) : wrapText(detail || "(\u65E0\u8BF4\u660E)", contentW).map((line, j) => /* @__PURE__ */ jsx7(Text7, { color: THEME.white, children: line }, j)) }),
         /* @__PURE__ */ jsx7(Text7, { color: THEME.grayDim, children: S.approvalPrompt }),
         OPTIONS.map((opt, i) => {
           const active = i === selectedIndex;
@@ -13539,7 +13921,7 @@ __export(App_exports, {
 });
 import { useCallback as useCallback2, useEffect as useEffect4, useMemo, useRef as useRef2, useState as useState4 } from "react";
 import { Box as Box15, Static, Text as Text17, useApp, useInput as useInput2, useStdout } from "ink";
-import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
 var KNOWN_MODELS, CWD2, RowView, isDynamicRow, App;
 var init_App = __esm({
   "src/App.tsx"() {
@@ -14068,9 +14450,10 @@ ${listText}`);
             state.pendingFork ? /* @__PURE__ */ jsx17(ForkPicker, { anchors: state.pendingFork.anchors, selectedIndex: selectIdx, wrapW }) : null,
             slashVisible ? /* @__PURE__ */ jsx17(SlashMenu, { entries: filteredCommands, selectedIndex: selectIdx, cols }) : null
           ] }),
-          /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", paddingX: 1, marginTop: 1, flexShrink: 0, children: [
-            /* @__PURE__ */ jsx17(Text17, { dimColor: true, color: THEME.gray, children: dimRule(cols) }),
-            /* @__PURE__ */ jsx17(
+          /* @__PURE__ */ jsx17(Box15, { flexDirection: "column", paddingX: 1, marginTop: 1, flexShrink: 0, children: (() => {
+            const planOn = state.getPlanMode();
+            const autoOn = !planOn && state.getAutoMode();
+            const inputEl = /* @__PURE__ */ jsx17(
               MultilineInput,
               {
                 value: input,
@@ -14086,8 +14469,18 @@ ${listText}`);
                 suppressSubmit: slashVisible,
                 placeholder: S.placeholder
               }
-            )
-          ] }),
+            );
+            if (planOn || autoOn) {
+              return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", borderStyle: "round", borderColor: planOn ? THEME.thinking : THEME.warn, paddingX: 1, children: [
+                /* @__PURE__ */ jsx17(Text17, { color: planOn ? THEME.thinking : THEME.warn, children: planOn ? S.inputBadgePlan : S.inputBadgeAuto }),
+                inputEl
+              ] });
+            }
+            return /* @__PURE__ */ jsxs15(Fragment3, { children: [
+              /* @__PURE__ */ jsx17(Text17, { dimColor: true, color: THEME.gray, children: dimRule(cols) }),
+              inputEl
+            ] });
+          })() }),
           /* @__PURE__ */ jsx17(Box15, { paddingX: 1, marginTop: 1, flexShrink: 0, children: /* @__PURE__ */ jsx17(StatusStrip, { model: modelDisplay, busy: state.busy, aborting: state.aborting, planMode: state.getPlanMode(), autoMode: state.getAutoMode(), sessionShort, cols, customLine: statusLineText }) })
         ] })
       ] });
@@ -14095,81 +14488,6 @@ ${listText}`);
   }
 });
 
-// src/updateCheck.ts
-var updateCheck_exports = {};
-__export(updateCheck_exports, {
-  getCachedLatestIfNewer: () => getCachedLatestIfNewer,
-  readLocalVersion: () => readLocalVersion,
-  refreshUpdateCache: () => refreshUpdateCache
-});
-import { readFileSync as readFileSync4, writeFileSync, mkdirSync } from "node:fs";
-import path39 from "node:path";
-import os4 from "os";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
-var PKG_NAME, REGISTRY, CACHE_TTL_MS, FETCH_TIMEOUT_MS2, cacheFile, readLocalVersion, parseSemver, compareVersion, readCache, writeCache, getCachedLatestIfNewer, refreshUpdateCache;
-var init_updateCheck = __esm({
-  "src/updateCheck.ts"() {
-    "use strict";
-    PKG_NAME = "deepseeker-code";
-    REGISTRY = "https://registry.npmjs.org";
-    CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
-    FETCH_TIMEOUT_MS2 = 3e3;
-    cacheFile = () => path39.join(os4.homedir(), ".deepseeker-code", "update-check.json");
-    readLocalVersion = () => {
-      try {
-        const here = path39.dirname(fileURLToPath6(import.meta.url));
-        return JSON.parse(readFileSync4(path39.join(here, "..", "package.json"), "utf8")).version ?? "0.0.0";
-      } catch {
-        return "0.0.0";
-      }
-    };
-    parseSemver = (v) => {
-      const m = String(v ?? "").match(/^(\d+)\.(\d+)\.(\d+)/);
-      return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : [0, 0, 0];
-    };
-    compareVersion = (a, b) => {
-      const [a1, a2, a3] = parseSemver(a);
-      const [b1, b2, b3] = parseSemver(b);
-      return a1 - b1 || a2 - b2 || a3 - b3;
-    };
-    readCache = () => {
-      try {
-        const obj = JSON.parse(readFileSync4(cacheFile(), "utf8"));
-        return typeof obj.latestVersion === "string" && typeof obj.lastCheck === "number" ? obj : null;
-      } catch {
-        return null;
-      }
-    };
-    writeCache = (latestVersion) => {
-      try {
-        mkdirSync(path39.dirname(cacheFile()), { recursive: true });
-        writeFileSync(cacheFile(), JSON.stringify({ lastCheck: Date.now(), latestVersion }), "utf8");
-      } catch {
-      }
-    };
-    getCachedLatestIfNewer = (currentVersion) => {
-      const cache = readCache();
-      if (!cache) return null;
-      return compareVersion(cache.latestVersion, currentVersion) > 0 ? cache.latestVersion : null;
-    };
-    refreshUpdateCache = () => {
-      const cache = readCache();
-      if (cache && Date.now() - cache.lastCheck < CACHE_TTL_MS) return;
-      void (async () => {
-        try {
-          const res = await fetch(`${REGISTRY}/${PKG_NAME}/latest`, {
-            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS2)
-          });
-          if (!res.ok) return;
-          const info = await res.json();
-          if (info.version) writeCache(info.version);
-        } catch {
-        }
-      })();
-    };
-  }
-});
-
 // src/preload-config.ts
 import { readFileSync } from "node:fs";
 import path from "node:path";
@@ -14217,6 +14535,7 @@ applyConfigToEnv(loadConfigFile());
 // src/main.tsx
 init_strings();
 init_prefs();
+init_updateCheck();
 init_trust();
 import { render } from "ink";
 import os5 from "os";
@@ -14233,6 +14552,7 @@ var parseArgs = (argv) => {
     else if (a === "--continue" || a === "-c") out.continue = true;
     else if (a === "--trust") out.trust = true;
     else if (a === "--no-update-check") out.noUpdateCheck = true;
+    else if (a === "--version" || a === "-v") out.version = true;
   }
   return out;
 };
@@ -14293,6 +14613,11 @@ var main = async () => {
   console.debug = silence;
   console.warn = silence;
   const args = parseArgs(process.argv.slice(2));
+  if (args.version) {
+    process.stdout.write(`deepseeker-code v${readLocalVersion()}
+`);
+    process.exit(0);
+  }
   if (!process.env.DEEP_SEEK_API_KEY) {
     console.error(S.noApiKey("DEEP_SEEK_API_KEY"));
     process.exit(1);