npm - deepseeker-code - Versions diffs - 1.0.41 → 1.0.43 - Mend

deepseeker-code 1.0.41 → 1.0.43

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/cli.mjs +525 -374
package/package.json +1 -1

package/dist/cli.mjs CHANGED Viewed

@@ -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",
@@ -317,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,
@@ -352,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}`;
       })(),
@@ -451,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;
         }
@@ -493,7 +569,7 @@ import { randomUUID } from "node:crypto";
 import fs from "fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-var getFileName, createUUID, SAFE_SESSION_ID_RE, isSafeSessionId, assertSafeSessionId, readJSONFile, atomicWriteJSON, createSemaphore, injectMarkedBlock, decodeProcessOutput, execFileSmart;
+var getFileName, createUUID, SAFE_SESSION_ID_RE, isSafeSessionId, assertSafeSessionId, detectTextLocale, readJSONFile, atomicWriteJSON, createSemaphore, injectMarkedBlock, decodeProcessOutput, execFileSmart;
 var init_common = __esm({
   "../core/src/common/index.ts"() {
     "use strict";
@@ -516,6 +592,15 @@ var init_common = __esm({
         throw new Error(`\u{1F6D1} [SECURITY] \u975E\u6CD5 ${label}: ${JSON.stringify(sessionId.slice(0, 48))}\uFF08\u4EC5\u5141\u8BB8\u5B57\u6BCD/\u6570\u5B57/\u4E0B\u5212\u7EBF/\u8FDE\u5B57\u7B26\uFF09`);
       }
     };
+    detectTextLocale = (text) => {
+      const stripped = (text || "").replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ").replace(/\s+/g, " ");
+      const cjk = (stripped.match(/[㐀-䶿一-鿿]/g) || []).length;
+      const latin = (stripped.match(/[A-Za-z]/g) || []).length;
+      if (cjk === 0 && latin === 0) return null;
+      if (cjk === 0) return "en";
+      if (latin === 0) return "zh";
+      return cjk / (cjk + latin) >= 0.2 ? "zh" : "en";
+    };
     readJSONFile = async (file, fallback = null) => {
       try {
         const raw = await fs.readFile(file, "utf-8");
@@ -596,7 +681,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({
@@ -604,7 +689,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 : {};
@@ -625,7 +710,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({
@@ -633,9 +718,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;
     };
@@ -978,7 +1063,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"() {
@@ -993,7 +1078,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}`);
       }
@@ -1113,7 +1198,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) {
@@ -1160,16 +1245,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 });
@@ -1179,7 +1264,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;
@@ -1304,7 +1389,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 = "";
@@ -1481,7 +1566,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"() {
@@ -1527,7 +1612,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;
       }
@@ -1732,7 +1817,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, "");
 }
@@ -1771,10 +1856,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 {
           }
         }
@@ -2041,7 +2126,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"() {
@@ -2103,9 +2188,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) {
@@ -2196,7 +2281,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);
@@ -2208,7 +2293,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);
@@ -2248,7 +2333,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;
@@ -2304,8 +2389,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;
         }
       }
@@ -2322,16 +2407,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) {
@@ -2345,8 +2430,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}`);
@@ -2355,12 +2440,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;
         }
       }
@@ -2373,9 +2458,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) {
@@ -2389,8 +2474,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}`);
@@ -2417,7 +2502,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();
@@ -2432,9 +2517,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 "";
@@ -2445,7 +2530,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 {
@@ -2516,7 +2601,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) {
@@ -2541,7 +2626,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()) {
@@ -2586,9 +2671,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);
@@ -2729,12 +2814,13 @@ task_id: ${taskId}
         type: "function",
         function: {
           name: "get_background_output",
-          description: "\u67E5\u770B\u6307\u5B9A\u540E\u53F0\u4EFB\u52A1\u7684\u6700\u8FD1\u8F93\u51FA\u65E5\u5FD7\u4E0E\u8FD0\u884C\u72B6\u6001\uFF08running/exited/killed + \u9000\u51FA\u7801\uFF09\u3002\u7EAF\u8BFB\uFF0C\u514D\u5BA1\u6279\u3002\u7528\u4E8E\u786E\u8BA4 dev server \u662F\u5426\u542F\u52A8\u6210\u529F\u3001\u67E5\u770B\u62A5\u9519\u7B49\u3002",
+          description: "\u67E5\u770B\u6307\u5B9A\u540E\u53F0\u4EFB\u52A1\u7684\u6700\u8FD1\u8F93\u51FA\u65E5\u5FD7\u4E0E\u8FD0\u884C\u72B6\u6001\uFF08running/exited/killed + \u9000\u51FA\u7801\uFF09\u3002\u7EAF\u8BFB\uFF0C\u514D\u5BA1\u6279\u3002\u7528\u4E8E\u786E\u8BA4 dev server \u662F\u5426\u542F\u52A8\u6210\u529F\u3001\u67E5\u770B\u62A5\u9519\u7B49\u3002\u7B49\u957F\u4EFB\u52A1\uFF08\u6784\u5EFA/\u6D4B\u8BD5\uFF09\u8DD1\u5B8C\uFF1A\u5E26 wait_seconds \u963B\u585E\u7B49\u5F85\u4EFB\u52A1\u9000\u51FA\u540E\u518D\u8FD4\u56DE\uFF08\u4ECD\u5728\u8DD1\u5219\u7B49\u5230\u8D85\u65F6\u8FD4\u56DE\u5F53\u524D\u72B6\u6001\uFF09\u2014\u2014\u7528\u5B83\u7B49\uFF0C\u4E0D\u8981\u4E0D\u5E26 wait \u53CD\u590D\u8F6E\u8BE2\u67E5\u8BE2\u3002",
           parameters: {
             type: "object",
             properties: {
               task_id: { type: "string", description: "run_in_background \u8FD4\u56DE\u7684 task_id" },
-              tail_lines: { type: "number", description: "\u53EA\u8FD4\u56DE\u6700\u540E N \u884C\u65E5\u5FD7\uFF08\u9ED8\u8BA4 50\uFF0C\u907F\u514D\u4E00\u6B21\u704C\u5165\u8FC7\u591A\uFF09" }
+              tail_lines: { type: "number", description: "\u53EA\u8FD4\u56DE\u6700\u540E N \u884C\u65E5\u5FD7\uFF08\u9ED8\u8BA4 50\uFF0C\u907F\u514D\u4E00\u6B21\u704C\u5165\u8FC7\u591A\uFF09" },
+              wait_seconds: { type: "number", description: "\u963B\u585E\u7B49\u5F85\u4EFB\u52A1\u9000\u51FA\uFF08\u6216\u5230\u8FBE\u6B64\u65F6\u957F\uFF09\u540E\u518D\u8FD4\u56DE\uFF0C\u4E0A\u9650 120 \u79D2\uFF1B\u4EFB\u52A1\u5DF2\u5728\u8DD1\u4E14\u9700\u8981\u7B49\u7ED3\u679C\u65F6\u4F7F\u7528\uFF0C\u4E0D\u9700\u8981\u7B49\u5C31\u7701\u7565" }
             },
             required: ["task_id"]
           },
@@ -2745,6 +2831,13 @@ task_id: ${taskId}
             if (!task || task.sessionId !== ctx?.sessionId) {
               return `\u274C [\u67E5\u8BE2\u5931\u8D25]\uFF1A\u672A\u627E\u5230 task_id=${args.task_id}\uFF08\u53EF\u80FD\u5DF2\u968F\u670D\u52A1\u91CD\u542F\u4E22\u5931\uFF0C\u6216\u4E0D\u5C5E\u4E8E\u5F53\u524D\u4F1A\u8BDD\uFF09\u3002`;
             }
+            const waitMs = Math.min(Math.max(0, args.wait_seconds ?? 0), 120) * 1e3;
+            if (waitMs > 0 && task.status === "running") {
+              const deadline = Date.now() + waitMs;
+              while (task.status === "running" && Date.now() < deadline && !ctx?.abortSignal?.aborted) {
+                await new Promise((r) => setTimeout(r, 500));
+              }
+            }
             const tail = Math.max(1, args.tail_lines ?? 50);
             const allLines = task.outputBuffer.split("\n");
             const tailText = allLines.slice(-tail).join("\n").trim();
@@ -3331,13 +3424,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");
@@ -3807,26 +3900,31 @@ var init_repeatBreaker = __esm({
       const recentSignatures = [];
       const recentPollTargets = [];
       const POLL_TARGET_KEYS = { get_background_output: ["task_id"] };
+      const parseArgs2 = (tc) => {
+        try {
+          return JSON.parse(tc?.function?.arguments || "{}") ?? {};
+        } catch {
+          return {};
+        }
+      };
       const pollTarget = (tc) => {
         const name = tc?.function?.name;
         const keys = name ? POLL_TARGET_KEYS[name] : void 0;
         if (!keys) return null;
-        let args = {};
-        try {
-          args = JSON.parse(tc?.function?.arguments || "{}");
-        } catch {
-        }
+        const args = parseArgs2(tc);
         const picked = {};
         for (const k of keys) if (k in args) picked[k] = args[k];
         return `${name}:${JSON.stringify(picked)}`;
       };
+      const isWaitPoll = (tc) => tc?.function?.name === "get_background_output" && Number(parseArgs2(tc).wait_seconds ?? 0) > 0;
       const check = (toolCalls, round, lastContent) => {
-        const sig = toolCalls.map((t) => `${t.function.name}:${t.function.arguments}`).join("|");
+        const effCalls = toolCalls.filter((t) => !isWaitPoll(t));
+        const sig = effCalls.map((t) => `${t.function.name}:${t.function.arguments}`).join("|");
         const tooName = toolCalls.map((t) => `${t.function.name}`).join("|");
         recentSignatures.push(sig);
         if (recentSignatures.length > 6) recentSignatures.shift();
         const last3 = recentSignatures.slice(-3);
-        if (last3.length === 3 && last3.every((s) => s === last3[0])) {
+        if (sig && last3.length === 3 && last3.every((s) => s === sig)) {
           const text = (lastContent || "") + "\n\uFF08\u68C0\u6D4B\u5230\u91CD\u590D\u5DE5\u5177\u8C03\u7528\uFF0C\u5DF2\u505C\u6B62\uFF09";
           events({
             sessionId,
@@ -3845,31 +3943,28 @@ var init_repeatBreaker = __esm({
           });
           return { tripped: true, kind: "full", text, toolName: tooName };
         }
-        const pollTargets = toolCalls.map(pollTarget).filter(Boolean);
-        if (pollTargets.length) {
-          const pollSig = pollTargets.join("|");
-          recentPollTargets.push(pollSig);
-          if (recentPollTargets.length > 8) recentPollTargets.shift();
-          const last4 = recentPollTargets.slice(-4);
-          if (last4.length === 4 && last4.every((s) => s === last4[0])) {
-            const text = (lastContent || "") + "\n\uFF08\u68C0\u6D4B\u5230\u540E\u53F0\u4EFB\u52A1\u8F6E\u8BE2\u6B7B\u5FAA\u73AF\uFF08\u53CD\u590D\u67E5\u8BE2\u540C\u4E00\u4EFB\u52A1\uFF09\uFF0C\u5DF2\u505C\u6B62\uFF09";
-            events({
-              sessionId,
-              eventType: "tool.repeat_break",
-              metadata: {
-                depth,
-                decisionSource: llmDecisionSource,
-                durationMs: performance.now() - startTime,
-                round,
-                toolName: tooName,
-                toolSource: "builtin",
-                ok: false,
-                attempt: round
-              },
-              payload: { output: text }
-            });
-            return { tripped: true, kind: "names", text, toolName: tooName };
-          }
+        const pollSig = effCalls.map(pollTarget).filter(Boolean).join("|");
+        recentPollTargets.push(pollSig);
+        if (recentPollTargets.length > 8) recentPollTargets.shift();
+        const last4 = recentPollTargets.slice(-4);
+        if (pollSig && last4.length === 4 && last4.every((s) => s === pollSig)) {
+          const text = (lastContent || "") + "\n\uFF08\u68C0\u6D4B\u5230\u540E\u53F0\u4EFB\u52A1\u8F6E\u8BE2\u6B7B\u5FAA\u73AF\uFF08\u53CD\u590D\u67E5\u8BE2\u540C\u4E00\u4EFB\u52A1\uFF09\uFF0C\u5DF2\u505C\u6B62\uFF09";
+          events({
+            sessionId,
+            eventType: "tool.repeat_break",
+            metadata: {
+              depth,
+              decisionSource: llmDecisionSource,
+              durationMs: performance.now() - startTime,
+              round,
+              toolName: tooName,
+              toolSource: "builtin",
+              ok: false,
+              attempt: round
+            },
+            payload: { output: text }
+          });
+          return { tripped: true, kind: "names", text, toolName: tooName };
         }
         events({
           sessionId,
@@ -4112,7 +4207,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"() {
@@ -4129,7 +4224,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;
@@ -4287,10 +4382,23 @@ var init_systemInjections = __esm({
         function: { name: t.function.name, description: t.function.description, parameters: t.function.parameters }
       }));
       ensureSummarySlot(message);
-      if (locale2) {
-        const hint = locale2 === "zh" ? "\u8BF7\u59CB\u7EC8\u7528\u4E2D\u6587\u56DE\u590D\u7528\u6237\u3002" : "Always reply to the user in English.";
-        injectMarkedBlock(message, "\u27E6DSC:LOCALE\u27E7", hint);
-      }
+      const LOCALE_HINTS = {
+        zh: "\u59CB\u7EC8\u7528\u4E2D\u6587\u8F93\u51FA\u6240\u6709\u9762\u5411\u7528\u6237\u7684\u5185\u5BB9\uFF1A\u4F60\u7684\u56DE\u590D\u3001\u4E2D\u95F4\u53D9\u8FF0\u3001todo \u4EFB\u52A1\u9879\u6807\u9898\u3001\u901A\u8FC7 exit_plan_mode \u63D0\u4EA4\u7684\u65B9\u6848\u6587\u672C\u3001\u4EE3\u7801\u6CE8\u91CA\u4E0E\u63D0\u4EA4\u4FE1\u606F\u3002\u4EE3\u7801\u6807\u8BC6\u7B26\u4FDD\u6301\u539F\u6837\uFF1B\u5DE5\u5177\u7ED3\u679C\u4E0E\u7CFB\u7EDF\u6307\u4EE4\u53EF\u80FD\u5939\u6742\u5176\u4ED6\u8BED\u8A00\u2014\u2014\u5FC5\u8981\u65F6\u7167\u5F15\u539F\u6587\uFF0C\u4F46\u4F60\u81EA\u5DF1\u7684\u53D9\u8FF0\u4E0E\u89E3\u91CA\u4E00\u5F8B\u7528\u4E2D\u6587\u3002",
+        en: "Always produce ALL user-facing output in English: your replies, interim narration, todo item titles, the plan text you submit via exit_plan_mode, code comments, and commit messages. Keep code identifiers as-is; tool results and system instructions may arrive in Chinese \u2014 quote them verbatim where needed, but your own narration and explanations must stay in English."
+      };
+      const lastUserText = (() => {
+        for (let i = message.length - 1; i >= 0; i--) {
+          const m = message[i];
+          if (m?.role !== "user") continue;
+          const c = m.content;
+          if (typeof c === "string") return c;
+          if (Array.isArray(c)) return c.filter((p) => typeof p?.text === "string").map((p) => p.text).join(" ");
+          return "";
+        }
+        return "";
+      })();
+      const effLocale = detectTextLocale(lastUserText) ?? locale2;
+      if (effLocale) injectMarkedBlock(message, "\u27E6DSC:LOCALE\u27E7", LOCALE_HINTS[effLocale]);
       injectOutputStyle(message, outputStyle);
       injectSkillCatalog(message);
       injectAgentCatalog(message);
@@ -4313,13 +4421,14 @@ var init_agent = __esm({
         type: "function",
         function: {
           name: "spawn_agent",
-          description: "\u521B\u5EFA\u4E00\u4E2A\u62E5\u6709\u72EC\u7ACB\u6267\u884C\u73AF\u5883\u7684\u5B50 agent \u5904\u7406\u9694\u79BB\u7684\u7279\u5B9A\u5B50\u4EFB\u52A1\uFF0C\u5B50\u4EFB\u52A1\u5B8C\u6210\u540E\u81EA\u52A8\u6C47\u603B\u6539\u52A8\u70B9\u4E0E\u7ED3\u8BBA\u8FD4\u56DE\u3002\u53EF\u901A\u8FC7 name \u6307\u5B9A\u58F0\u660E\u5F0F\u5B50 Agent\uFF08\u89C1\u7CFB\u7EDF\u63D0\u793A\u8BCD\u3010\u53EF\u7528\u5B50 Agent \u76EE\u5F55\u3011\uFF09\u4EE5\u5957\u7528\u5176\u4E13\u957F\u7CFB\u7EDF\u8BCD/\u5DE5\u5177\u767D\u540D\u5355/model\uFF1B\u4E0D\u4F20 name \u8D70\u9ED8\u8BA4\u901A\u7528\u5B50 agent\u3002",
+          description: "\u521B\u5EFA\u4E00\u4E2A\u62E5\u6709\u72EC\u7ACB\u6267\u884C\u73AF\u5883\u7684\u5B50 agent \u5904\u7406\u9694\u79BB\u7684\u7279\u5B9A\u5B50\u4EFB\u52A1\uFF0C\u5B50\u4EFB\u52A1\u5B8C\u6210\u540E\u81EA\u52A8\u6C47\u603B\u6539\u52A8\u70B9\u4E0E\u7ED3\u8BBA\u8FD4\u56DE\u3002\u53EF\u901A\u8FC7 name \u6307\u5B9A\u58F0\u660E\u5F0F\u5B50 Agent\uFF08\u89C1\u7CFB\u7EDF\u63D0\u793A\u8BCD\u3010\u53EF\u7528\u5B50 Agent \u76EE\u5F55\u3011\uFF09\u4EE5\u5957\u7528\u5176\u4E13\u957F\u7CFB\u7EDF\u8BCD/\u5DE5\u5177\u767D\u540D\u5355/model\uFF1B\u4E0D\u4F20 name \u8D70\u9ED8\u8BA4\u901A\u7528\u5B50 agent\u3002\u652F\u6301\u7EED\u8DD1\uFF1A\u4F20 resume_session_id\uFF08\u6B64\u524D\u8FD4\u56DE\u7684 agent_id\uFF09\u590D\u7528\u8BE5\u5B50 Agent \u7684\u5B8C\u6574\u5386\u53F2\u8BB0\u5FC6\uFF0C\u9002\u5408\u8FFD\u95EE\u3001\u7EE7\u7EED\u672A\u5B8C\u6210\u7684\u4EFB\u52A1\u3002",
           parameters: {
             type: "object",
             properties: {
-              task: { type: "string", description: "\u4EA4\u7ED9\u5B50 agent \u7684\u5177\u4F53\u5FAE\u89C2\u4EFB\u52A1\u63CF\u8FF0\uFF08\u5982 '\u7F16\u5199 Button \u7EC4\u4EF6\u7684\u5355\u5143\u6D4B\u8BD5'\uFF09" },
+              task: { type: "string", description: "\u4EA4\u7ED9\u5B50 agent \u7684\u5177\u4F53\u5FAE\u89C2\u4EFB\u52A1\u63CF\u8FF0\uFF08\u5982 '\u7F16\u5199 Button \u7EC4\u4EF6\u7684\u5355\u5143\u6D4B\u8BD5'\uFF09\uFF1B\u7EED\u8DD1\u65F6\u4E3A\u65B0\u6307\u4EE4\uFF08\u5982 '\u7EE7\u7EED\u5B8C\u6210\u5269\u4F59\u7528\u4F8B'\uFF09" },
               name: { type: "string", description: "\u58F0\u660E\u5F0F\u5B50 Agent \u540D\u79F0\uFF08\u987B\u4E0E\u7CFB\u7EDF\u63D0\u793A\u8BCD\u4E2D\u3010\u53EF\u7528\u5B50 Agent \u76EE\u5F55\u3011\u4E00\u81F4\uFF09\u3002\u63D0\u4F9B\u65F6\u6309\u5176\u58F0\u660E\u52A0\u8F7D\u7CFB\u7EDF\u8BCD/\u5DE5\u5177\u767D\u540D\u5355/model\uFF1B\u4E0D\u63D0\u4F9B\u5219\u8D70\u9ED8\u8BA4\u901A\u7528\u5B50 agent\u3002" },
-              role: { type: "string", description: "\u5B50 agent \u7684\u89D2\u8272/\u4E13\u957F\uFF08\u53EF\u9009\uFF0C\u5982 '\u6D4B\u8BD5\u4E13\u5BB6'\u3001'\u91CD\u6784\u5148\u950B'\uFF09\u3002\u58F0\u660E\u5F0F agent \u81EA\u5E26 role \u65F6\u4F5C\u8865\u5145\u3002" }
+              role: { type: "string", description: "\u5B50 agent \u7684\u89D2\u8272/\u4E13\u957F\uFF08\u53EF\u9009\uFF0C\u5982 '\u6D4B\u8BD5\u4E13\u5BB6'\u3001'\u91CD\u6784\u5148\u950B'\uFF09\u3002\u58F0\u660E\u5F0F agent \u81EA\u5E26 role \u65F6\u4F5C\u8865\u5145\u3002" },
+              resume_session_id: { type: "string", description: "\u7EED\u8DD1\u65E2\u6709\u5B50 Agent\uFF1A\u4F20\u6B64\u524D spawn_agent \u8FD4\u56DE\u7684 agent_id\uFF0C\u5176\u78C1\u76D8\u4E0A\u7684\u5386\u53F2\u4E0E\u8BB0\u5FC6\u5C06\u5B8C\u6574\u6062\u590D\u3002\u6CE8\u610F\uFF1A\u5B50 Agent \u72B6\u6001\u4E0D\u968F\u4E3B\u4F1A\u8BDD fork \u56DE\u6EDA\u2014\u2014fork \u53EA\u5206\u53C9\u5BF9\u8BDD\uFF0C\u7EED\u8DD1\u62FF\u5230\u7684\u662F\u5B50\u4F1A\u8BDD\u78C1\u76D8\u6700\u65B0\u72B6\u6001\u3002\u7F3A\u7701\u5219\u65B0\u5EFA\u5B50 Agent\u3002" }
             },
             required: ["task"]
           },
@@ -4327,10 +4436,17 @@ var init_agent = __esm({
           isSync: true,
           async execute(args, ctx) {
             if (!ctx) return "\u274C [\u6D3E\u751F\u5931\u8D25]\uFF1Aspawn_agent \u7F3A\u5C11\u5FC5\u987B\u7684\u667A\u80FD\u4F53\u8FD0\u884C\u4E0A\u4E0B\u6587\u3002";
-            const res = await runSubagent(args, ctx, getGlobalTools);
+            const res = await runSubagent(
+              { task: args.task, name: args.name, role: args.role, resumeSessionId: args.resume_session_id },
+              ctx,
+              getGlobalTools
+            );
             if (!res.ok) return res.output;
             return [
-              `\u{1F389} [\u5B50 Agent \u6267\u884C\u5B8C\u6BD5] \u6D3E\u751F\u5B50\u4EFB\u52A1\u6C47\u62A5\u5982\u4E0B\uFF1A
+              `\u{1F389} [\u5B50 Agent \u6267\u884C\u5B8C\u6BD5${args.resume_session_id ? "\xB7\u7EED\u8DD1" : ""}] \u6D3E\u751F\u5B50\u4EFB\u52A1\u6C47\u62A5\u5982\u4E0B\uFF1A
+`,
+              `\u{1F194} agent_id: ${res.sessionId}
+\uFF08\u9700\u8981\u7EE7\u7EED\u8BE5\u5B50 Agent \u7684\u4EFB\u52A1\u6216\u8FFD\u95EE\u65F6\uFF0C\u8C03\u7528 spawn_agent \u4F20 resume_session_id=${res.sessionId}\uFF0C\u5176\u5386\u53F2\u8BB0\u5FC6\u5B8C\u6574\u4FDD\u7559\uFF09
 `,
               `==================================================
 `,
@@ -4349,8 +4465,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({
@@ -4362,8 +4478,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");
@@ -4374,7 +4490,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) {
@@ -4450,7 +4566,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);
@@ -4458,7 +4574,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 {
@@ -4739,7 +4855,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"() {
@@ -4772,16 +4888,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;
       }
@@ -4792,7 +4908,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);
@@ -4803,7 +4919,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);
@@ -4892,7 +5008,7 @@ 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, alignIndentsByAnchor, applyOneEditToContent, fsTools;
@@ -4953,7 +5069,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;
@@ -5227,8 +5343,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 = "";
@@ -5247,7 +5363,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;
                   }
@@ -5361,7 +5477,7 @@ ${summaries.join("\n")}`;
               }
               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);
@@ -5400,7 +5516,7 @@ ${summaries.join("\n")}`;
             }
             let rel = "";
             try {
-              rel = path15.relative(getActiveWorkspaceRoot(), resolveSafePath(cleanPath));
+              rel = path16.relative(getActiveWorkspaceRoot(), resolveSafePath(cleanPath));
             } catch {
             }
             if (rel === "" || rel === "src") {
@@ -5421,8 +5537,8 @@ ${summaries.join("\n")}`;
                 return `\u274C [\u5B89\u5168\u7194\u65AD]\uFF1A\u7981\u6B62\u901A\u8FC7\u672C\u5DE5\u5177\u76F4\u63A5\u6467\u6BC1\u9879\u76EE\u6839\u76EE\u5F55\u6216\u4F20\u5165\u7A7A\u8DEF\u5F84\uFF01`;
               }
               const absPath = resolveSafePath(cleanPath);
-              const rel = 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;
@@ -5467,7 +5583,7 @@ ${summaries.join("\n")}`;
             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);
@@ -5601,7 +5717,7 @@ ${summaries.join("\n")}`;
               }
               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) {
@@ -5616,7 +5732,7 @@ ${summaries.join("\n")}`;
 // ../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, "\\$&");
@@ -5659,10 +5775,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;
@@ -5751,7 +5867,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}`;
@@ -5984,7 +6100,7 @@ ${tail}`,
 // ../core/src/tool/registry/glob.ts
 import fs14 from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 var findMatchingBrace, splitTopLevel, globToRegex2, globTools;
 var init_glob = __esm({
   "../core/src/tool/registry/glob.ts"() {
@@ -6090,16 +6206,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}/`);
@@ -6316,7 +6432,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"() {
@@ -6337,7 +6453,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 = {
@@ -6639,13 +6755,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)";
@@ -6775,7 +6891,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, {
@@ -6812,7 +6928,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}`;
@@ -6981,7 +7097,7 @@ var init_http = __esm({
 // ../core/src/tool/registry/typescript.ts
 import fs16 from "fs/promises";
-import path19 from "path";
+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"() {
@@ -6992,8 +7108,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) => {
@@ -7252,7 +7368,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"() {
@@ -7269,7 +7385,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 {
@@ -7293,7 +7409,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({
@@ -7302,14 +7418,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 });
     };
@@ -7321,14 +7437,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"() {
@@ -7378,7 +7494,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;
@@ -7409,7 +7525,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");
@@ -7447,7 +7563,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;
@@ -7473,7 +7589,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) {
@@ -7498,12 +7614,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;
@@ -7525,10 +7641,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 {
     }
   }
@@ -7557,7 +7673,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);
@@ -7572,7 +7688,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 {
@@ -7583,7 +7699,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;
@@ -7596,7 +7712,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);
@@ -7606,7 +7722,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 {
         }
@@ -7649,7 +7765,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()) {
@@ -7666,7 +7782,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;
@@ -7681,7 +7797,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,
@@ -7731,7 +7847,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,
@@ -7768,7 +7884,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,
@@ -7776,7 +7892,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);
       }
     });
@@ -7793,7 +7909,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,
@@ -7845,8 +7961,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}
 `);
@@ -7872,7 +7988,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 {
@@ -7893,11 +8009,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);
           }
         }
@@ -7910,7 +8026,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") {
@@ -7968,16 +8084,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 };
 }
@@ -7990,15 +8106,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`;
     }
@@ -8482,7 +8598,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"() {
@@ -8491,10 +8607,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) => {
@@ -8534,7 +8650,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);
@@ -8553,7 +8669,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"() {
@@ -8565,7 +8681,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}
@@ -8577,7 +8693,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);
@@ -9117,7 +9233,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"() {
@@ -9252,9 +9368,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;
       }
@@ -9902,6 +10018,7 @@ var init_agentNudges = __esm({
     createNudgeScheduler = (opts = {}) => {
       const firstPrompt = opts.firstPrompt ?? "";
       const planMode = !!opts.planMode;
+      const noEarlyFinal = !!opts.noEarlyFinal;
       let phantomRetries = 0;
       let phantomPending = null;
       let earlyFinalNudges = 0;
@@ -9964,7 +10081,7 @@ ${TOOL_DIGEST_TEXT}` };
 ${PHANTOM_TEXT}` };
             return true;
           }
-          if (text !== "" && round <= EARLY_FINAL_TURN_THRESHOLD && earlyFinalNudges < EARLY_FINAL_MAX && !looksComplete(finalText)) {
+          if (!noEarlyFinal && text !== "" && round <= EARLY_FINAL_TURN_THRESHOLD && earlyFinalNudges < EARLY_FINAL_MAX && !looksComplete(finalText)) {
             earlyFinalNudges++;
             earlyFinalPending = { role: "system", content: `${EARLY_FINAL_FENCE}
 ${EARLY_FINAL_TEXT(round)}` };
@@ -10049,7 +10166,7 @@ async function* runAgent(message, options) {
     const m = message.find((x) => x?.role === "user");
     return typeof m?.content === "string" ? m.content : "";
   })();
-  const nudges = createNudgeScheduler({ firstPrompt, planMode: !!options.planMode });
+  const nudges = createNudgeScheduler({ firstPrompt, planMode: !!options.planMode, noEarlyFinal: !!options.noEarlyFinal });
   const userDecisionSource = depth > 0 ? "spawn_agent" : "user";
   const llmDecisionSource = depth > 0 ? "llm_spawn_agent" : "llm";
   const startTime = performance.now();
@@ -10178,7 +10295,6 @@ async function* runAgent(message, options) {
       if (assistantMessage.content) {
         lastContent = assistantMessage.content;
       }
-      const tcCount = assistantMessage.tool_calls?.length ?? 0;
       if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
         await appendEvent(sessionId, { dscEvent: "round.end", runId, round, usage: infResult.usage });
         const finalText = (typeof assistantMessage.content === "string" ? assistantMessage.content : "") || "";
@@ -10423,8 +10539,61 @@ var init_content = __esm({
   }
 });
+// ../core/src/session/lineage.ts
+import fs27 from "node:fs";
+var parentOfSubsession, stringAncestorsOf, readForkedFromSync, lineageClosureOf, ownerCanApprove;
+var init_lineage = __esm({
+  "../core/src/session/lineage.ts"() {
+    "use strict";
+    init_store();
+    parentOfSubsession = (sessionId) => {
+      const i = sessionId.lastIndexOf("__sub__");
+      return i > 0 ? sessionId.slice(0, i) : void 0;
+    };
+    stringAncestorsOf = (sessionId) => {
+      const out = [sessionId];
+      let cur = sessionId;
+      for (; ; ) {
+        const p = parentOfSubsession(cur);
+        if (p === void 0) break;
+        out.push(p);
+        cur = p;
+      }
+      return out;
+    };
+    readForkedFromSync = (sessionId) => {
+      try {
+        const raw = fs27.readFileSync(getStatePath(sessionId), "utf-8");
+        const v = JSON.parse(raw)?.forkedFrom;
+        return typeof v === "string" && v.length > 0 ? v : void 0;
+      } catch {
+        return void 0;
+      }
+    };
+    lineageClosureOf = (sessionId) => {
+      const closure = /* @__PURE__ */ new Set();
+      const expand = (id) => {
+        if (closure.has(id)) return;
+        const ancestors = stringAncestorsOf(id);
+        for (const a of ancestors) closure.add(a);
+        const root = ancestors[ancestors.length - 1];
+        const from = readForkedFromSync(root);
+        if (from && !closure.has(from)) expand(from);
+      };
+      expand(sessionId);
+      return closure;
+    };
+    ownerCanApprove = (entrySessionId, approverSessionId) => {
+      if (entrySessionId === approverSessionId) return true;
+      if (!entrySessionId.includes("__sub__")) return false;
+      const closure = lineageClosureOf(approverSessionId);
+      return stringAncestorsOf(entrySessionId).some((a, i) => i > 0 && closure.has(a));
+    };
+  }
+});
 // ../core/src/agent/subagent.ts
-var SUBAGENT_DENYLIST, runSubagent;
+var SUBAGENT_DENYLIST, activeSubagents, RESUME_NOTE, runSubagent;
 var init_subagent = __esm({
   "../core/src/agent/subagent.ts"() {
     "use strict";
@@ -10435,9 +10604,18 @@ var init_subagent = __esm({
     init_type();
     init_registry4();
     init_hooks();
+    init_lineage();
     SUBAGENT_DENYLIST = /* @__PURE__ */ new Set(["run_command", "delete_path"]);
+    activeSubagents = /* @__PURE__ */ new Set();
+    RESUME_NOTE = [
+      `
+# \u3010\u7EED\u8DD1\u8BF4\u660E\u3011`,
+      `\u4F60\u6B64\u524D\u7684\u5DE5\u4F5C\u5386\u53F2\u5DF2\u5B8C\u6574\u6062\u590D\u5230\u672C\u6B21\u4E0A\u4E0B\u6587\uFF08\u78C1\u76D8\u6700\u65B0\u72B6\u6001\uFF0C\u53EF\u80FD\u6BD4\u4F60\u4E0A\u6B21\u8BB0\u5FC6\u66F4\u65B0\uFF09\u3002`,
+      `\u8BF7\u5148\u5BF9\u7167\u5386\u53F2\u7B80\u8981\u56DE\u987E\u5DF2\u5B8C\u6210 / \u672A\u5B8C\u6210\u90E8\u5206\uFF0C\u518D\u7EE7\u7EED\u6267\u884C\u65B0\u4EFB\u52A1\uFF1B\u6700\u7EC8\u6C47\u62A5\u4E5F\u8BF7\u5148\u6982\u8FF0\u6B64\u524D\u8FDB\u5C55\u3002`
+    ].join("\n");
     runSubagent = async (spec, ctx, getGlobalTools) => {
-      const { task, name, role } = spec;
+      const { task, name, role, resumeSessionId } = spec;
+      const resuming = typeof resumeSessionId === "string" && resumeSessionId.length > 0;
       if (ctx.depth >= MAX_AGENT_DEPTH) {
         return {
           ok: false,
@@ -10445,7 +10623,39 @@ var init_subagent = __esm({
           sessionId: ""
         };
       }
-      const subSessionId = `${ctx.sessionId}__sub__${createUUID()}`;
+      if (resuming) {
+        const target = resumeSessionId;
+        if (!target.includes("__sub__")) {
+          return {
+            ok: false,
+            output: `\u274C [\u7EED\u8DD1\u5931\u8D25]\uFF1A${target} \u4E0D\u662F\u5B50 Agent \u4F1A\u8BDD ID\uFF08\u5E94\u5F62\u5982 <\u4F1A\u8BDD>__sub__<uuid>\uFF0C\u6765\u81EA\u6B64\u524D spawn_agent \u8FD4\u56DE\u7684 agent_id\uFF09\u3002`,
+            sessionId: ""
+          };
+        }
+        if (!ownerCanApprove(target, ctx.sessionId)) {
+          return {
+            ok: false,
+            output: `\u274C [\u7EED\u8DD1\u5931\u8D25]\uFF1A\u5B50\u4F1A\u8BDD ${target} \u4E0D\u5C5E\u4E8E\u5F53\u524D\u4F1A\u8BDD\uFF08\u53CA\u5176 fork \u8840\u7F18\uFF09\uFF0C\u7981\u6B62\u8DE8\u4F1A\u8BDD\u590D\u6D3B\u3002\u8BF7\u6838\u5BF9 agent_id \u6216\u6539\u7528\u65B0\u5EFA\u6D3E\u751F\u3002`,
+            sessionId: ""
+          };
+        }
+        if (activeSubagents.has(target)) {
+          return {
+            ok: false,
+            output: `\u274C [\u7EED\u8DD1\u5931\u8D25]\uFF1A\u5B50 Agent ${target} \u6B63\u5728\u6267\u884C\u4E2D\uFF0C\u7981\u6B62\u5E76\u53D1\u7EED\u8DD1\u540C\u4E00\u5B50\u4F1A\u8BDD\uFF08\u4F1A\u4EA4\u53C9\u5199\u574F\u8F6C\u5F55\uFF09\u3002\u8BF7\u7B49\u5F85\u5176\u5B8C\u6210\u540E\u518D\u8BD5\u3002`,
+            sessionId: ""
+          };
+        }
+        const existing = await readTranscriptLines(target);
+        if (existing.length === 0) {
+          return {
+            ok: false,
+            output: `\u274C [\u7EED\u8DD1\u5931\u8D25]\uFF1A\u5B50\u4F1A\u8BDD ${target} \u7684\u8F6C\u5F55\u4E0D\u5B58\u5728\u6216\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u7EED\u8DD1\u3002\u8BF7\u6539\u7528\u65B0\u5EFA\u6D3E\u751F\u3002`,
+            sessionId: ""
+          };
+        }
+      }
+      const subSessionId = resuming ? resumeSessionId : `${ctx.sessionId}__sub__${createUUID()}`;
       const parentSystemPrompt = ctx.parentSystemPrompt || "";
       const manifest = name ? getAgent(name) : void 0;
       if (name && !manifest) {
@@ -10455,7 +10665,7 @@ var init_subagent = __esm({
           sessionId: ""
         };
       }
-      const subSystem = manifest ? [
+      const subSystem = (manifest ? [
         `# \u5B50 Agent \u8EAB\u4EFD\uFF1A${manifest.name}`,
         manifest.body,
         `
@@ -10478,11 +10688,12 @@ var init_subagent = __esm({
         `
 # \u3010\u7EE7\u627F\u7684\u5168\u5C40\u4EE3\u7801\u89C4\u8303\u3011`,
         parentSystemPrompt
-      ].join("\n");
+      ].join("\n")) + (resuming ? RESUME_NOTE : "");
       const allTools = getGlobalTools();
       const wantsMcp = manifest?.tools.some((t) => t === "mcp_call" || t === "mcp_list_tools" || t.startsWith("mcp__")) ?? false;
       const toolSchemas = manifest && manifest.tools.length > 0 ? allTools.filter((t) => manifest.tools.includes(t.function.name) || wantsMcp && (t.function.name === "mcp_call" || t.function.name === "mcp_list_tools")) : allTools.filter((t) => !SUBAGENT_DENYLIST.has(t.function.name));
-      console.log(`\u{1F423} \u6D3E\u751F\u5B50 Agent [\u6DF1\u5EA6: ${ctx.depth + 1}/${MAX_AGENT_DEPTH}]${manifest ? ` \u58F0\u660E\u5F0F=${manifest.name}` : ""} \u4EFB\u52A1: "${task.slice(0, 50)}..."`);
+      console.log(`${resuming ? "\u{1F501} \u7EED\u8DD1" : "\u{1F423} \u6D3E\u751F"}\u5B50 Agent [\u6DF1\u5EA6: ${ctx.depth + 1}/${MAX_AGENT_DEPTH}][${subSessionId}]${manifest ? ` \u58F0\u660E\u5F0F=${manifest.name}` : ""} \u4EFB\u52A1: "${task.slice(0, 50)}..."`);
+      activeSubagents.add(subSessionId);
       try {
         const subMessages = await buildContextMessages(subSessionId, { role: "user", content: task }, subSystem);
         await appendMessage({ sessionId: subSessionId, role: "user", content: task });
@@ -10506,6 +10717,8 @@ var init_subagent = __esm({
           // ★ 同步透传宿主审批钩子，子 agent 高危工具仍走同一审批通道
           permissionMode: ctx.permissionMode,
           // ★ P1-6 透传：子 agent 工作区文件编辑也走 auto 分类器
+          noEarlyFinal: true,
+          // ★ 子 agent final 是交付父级的汇报，EARLY_FINAL 误推一轮纯浪费；父可经续跑纠错
           model: manifest?.model
           // ★ per-agent 模型覆盖；undefined 时 model.ts 回退全局 MODEL_NAME
         };
@@ -10539,14 +10752,16 @@ var init_subagent = __esm({
         return result ?? { ok: false, output: `\u274C [\u6D3E\u751F\u6267\u884C\u5931\u8D25]: \u672A\u77E5\u9519\u8BEF`, sessionId: subSessionId, manifestName: manifest?.name };
       } catch (error) {
         return { ok: false, output: `\u274C [\u6D3E\u751F\u6267\u884C\u5931\u8D25]: ${error.message}`, sessionId: subSessionId, manifestName: manifest?.name };
+      } finally {
+        activeSubagents.delete(subSessionId);
       }
     };
   }
 });
 // ../core/src/hooks/loader.ts
-import fs27 from "fs/promises";
-import path29 from "path";
+import fs28 from "fs/promises";
+import path30 from "path";
 var readHooksConfig, appendValidated, validateRule, parseStdoutDecision, parseAgentDecision, compileRule2, loadHooks, initHooks;
 var init_loader4 = __esm({
   "../core/src/hooks/loader.ts"() {
@@ -10561,15 +10776,15 @@ 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) {
         let raw;
         try {
-          raw = await fs27.readFile(configPath, "utf-8");
+          raw = await fs28.readFile(configPath, "utf-8");
         } catch {
           continue;
         }
@@ -10899,9 +11114,9 @@ ${m.context}`;
 });
 // ../core/src/skills/loader.ts
-import fs28 from "fs/promises";
-import path30 from "path";
-import { fileURLToPath } from "url";
+import fs29 from "fs/promises";
+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"() {
@@ -10911,18 +11126,18 @@ 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);
     parseSkillAt = async (skillFile, dir, source) => {
       let raw;
       try {
-        raw = await fs28.readFile(skillFile, "utf-8");
+        raw = await fs29.readFile(skillFile, "utf-8");
       } catch {
         return null;
       }
@@ -10961,7 +11176,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);
@@ -10992,9 +11207,9 @@ 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 fs30 from "fs/promises";
+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"() {
@@ -11003,16 +11218,16 @@ 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;
       try {
-        raw = await fs29.readFile(file, "utf-8");
+        raw = await fs30.readFile(file, "utf-8");
       } catch {
         return null;
       }
@@ -11047,7 +11262,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) {
@@ -11084,9 +11299,9 @@ 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 fs31 from "fs/promises";
+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"() {
@@ -11095,17 +11310,17 @@ 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) => {
       let raw;
       try {
-        raw = await fs30.readFile(file, "utf-8");
+        raw = await fs31.readFile(file, "utf-8");
       } catch {
         return null;
       }
@@ -11116,7 +11331,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`);
@@ -11142,7 +11357,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);
@@ -11160,9 +11375,9 @@ 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 fs32 from "fs/promises";
+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"() {
@@ -11171,17 +11386,17 @@ 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;
       try {
-        raw = await fs31.readFile(file, "utf-8");
+        raw = await fs32.readFile(file, "utf-8");
       } catch {
         return null;
       }
@@ -11213,7 +11428,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);
@@ -11294,8 +11509,8 @@ var init_bootstrap = __esm({
 });
 // ../core/src/statusLine/config.ts
-import fs32 from "fs/promises";
-import path34 from "path";
+import fs33 from "fs/promises";
+import path35 from "path";
 var parseBlock, readStatusLineConfig;
 var init_config2 = __esm({
   "../core/src/statusLine/config.ts"() {
@@ -11311,16 +11526,16 @@ 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;
       for (const configPath of paths) {
         let raw;
         try {
-          raw = await fs32.readFile(configPath, "utf-8");
+          raw = await fs33.readFile(configPath, "utf-8");
         } catch {
           continue;
         }
@@ -11340,9 +11555,9 @@ 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 fs34 from "fs";
+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"() {
@@ -11350,16 +11565,16 @@ 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) {
         try {
-          const pkg = JSON.parse(fs33.readFileSync(p, "utf-8"));
+          const pkg = JSON.parse(fs34.readFileSync(p, "utf-8"));
           if (typeof pkg.version === "string" && pkg.version) {
             cachedVersion = pkg.version;
             break;
@@ -11418,8 +11633,8 @@ var init_createModel = __esm({
 });
 // ../core/src/observability/store.ts
-import path36 from "path";
-import fs34 from "fs/promises";
+import path37 from "path";
+import fs35 from "fs/promises";
 var getTraceDirPath, getTracePath, tracePathCache, ensuredTraceDirs, ensureTraceDir, getGlobalClockPath, getTraceStorePath;
 var init_store3 = __esm({
   "../core/src/observability/store.ts"() {
@@ -11429,21 +11644,21 @@ 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();
     ensureTraceDir = async (mainTraceId) => {
       const dir = getTraceDirPath(mainTraceId);
       if (ensuredTraceDirs.has(dir)) return;
-      await fs34.mkdir(dir, { recursive: true });
+      await fs35.mkdir(dir, { recursive: true });
       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");
@@ -11452,7 +11667,7 @@ var init_store3 = __esm({
       if (cached2) return cached2;
       await ensureTraceDir(rootId);
       const dir = getTraceDirPath(rootId);
-      const files = await fs34.readdir(dir);
+      const files = await fs35.readdir(dir);
       const existedFile = files.find((f) => f.endsWith(`__${rootId}.jsonl`));
       let fileName = "";
       if (existedFile) {
@@ -11461,7 +11676,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;
     };
@@ -11469,8 +11684,8 @@ var init_store3 = __esm({
 });
 // ../core/src/observability/trace.ts
-import fs35 from "fs/promises";
-import path37 from "path";
+import fs36 from "fs/promises";
+import path38 from "path";
 async function emitTrace(base) {
   const event = {
     sessionId: base.sessionId,
@@ -11492,7 +11707,7 @@ async function emitTrace(base) {
 async function appendTraceEvent(event) {
   const p = await getTraceStorePath(event.sessionId);
   const line = JSON.stringify(event) + "\n";
-  await fs35.appendFile(p, line, "utf-8");
+  await fs36.appendFile(p, line, "utf-8");
   if (workspaceTraceBytes < 0) {
     workspaceTraceBytes = await getDirBytes(getTracePath());
   }
@@ -11524,8 +11739,8 @@ async function maybeCleanupAfterAppend(sessionId) {
     lastSizeCleanupAt2 = now;
     diskLastCleanupAt2 = now;
     const clockPath = getGlobalClockPath();
-    await fs35.mkdir(path37.dirname(clockPath), { recursive: true });
-    await fs35.writeFile(clockPath, JSON.stringify({ lastCleanupAt: now, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+    await fs36.mkdir(path38.dirname(clockPath), { recursive: true });
+    await fs36.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`);
     }
@@ -11545,22 +11760,22 @@ async function cleanupOldTraceFiles() {
   let deleted = 0;
   let relativePaths;
   try {
-    relativePaths = await fs35.readdir(dir, { recursive: true });
+    relativePaths = await fs36.readdir(dir, { recursive: true });
   } catch {
     return 0;
   }
   const re = /^trace-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   for (const relativePath of relativePaths) {
-    const fileName = 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);
+      const st = await fs36.stat(fullPath);
       if (now - st.mtimeMs < ACTIVE_GRACE_MS2) continue;
-      await fs35.unlink(fullPath);
+      await fs36.unlink(fullPath);
       deleted += 1;
     } catch {
     }
@@ -11571,18 +11786,18 @@ async function evictOldestForSize2(targetBytes) {
   const dir = getTracePath();
   let relativePaths;
   try {
-    relativePaths = await fs35.readdir(dir, { recursive: true });
+    relativePaths = await fs36.readdir(dir, { recursive: true });
   } catch {
     return 0;
   }
   const re = /^trace-(\d{4}-\d{2}-\d{2})__([\w-]+)\.jsonl$/;
   const candidates = [];
   for (const relativePath of relativePaths) {
-    const fileName = 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 fs36.stat(path38.join(dir, relativePath));
+      candidates.push({ mtime: st.mtimeMs, fullPath: path38.join(dir, relativePath), size: st.size });
     } catch {
     }
   }
@@ -11592,7 +11807,7 @@ async function evictOldestForSize2(targetBytes) {
   for (const c of candidates) {
     if (totalBytes <= targetBytes) break;
     try {
-      await fs35.unlink(c.fullPath);
+      await fs36.unlink(c.fullPath);
       totalBytes -= c.size;
       deleted += 1;
     } catch {
@@ -11624,7 +11839,7 @@ var init_trace = __esm({
       if (clockLoaded2) return;
       clockLoaded2 = true;
       try {
-        const rawClock = await fs35.readFile(getGlobalClockPath(), "utf-8");
+        const rawClock = await fs36.readFile(getGlobalClockPath(), "utf-8");
         diskLastCleanupAt2 = JSON.parse(rawClock).lastCleanupAt || 0;
       } catch {
         diskLastCleanupAt2 = 0;
@@ -11643,6 +11858,7 @@ var pendingLocks, waitForUserApproval, resolveUserApprovalLock;
 var init_approvalGate = __esm({
   "../core/src/tool/approvalGate.ts"() {
     "use strict";
+    init_lineage();
     pendingLocks = /* @__PURE__ */ new Map();
     waitForUserApproval = async (sessionId, toolsId, signal) => {
       if (signal?.aborted) return "deny";
@@ -11670,7 +11886,7 @@ var init_approvalGate = __esm({
     resolveUserApprovalLock = (sessionId, toolsId, decision) => {
       const entry = pendingLocks.get(toolsId);
       if (!entry) return false;
-      const isOwner = entry.sessionId === sessionId || entry.sessionId.startsWith(`${sessionId}__sub__`);
+      const isOwner = ownerCanApprove(entry.sessionId, sessionId);
       if (!isOwner) return false;
       entry.resolver(decision);
       pendingLocks.delete(toolsId);
@@ -11769,8 +11985,8 @@ ${PLAN_MODE_AUTO_ENTER_HINT}
 });
 // ../core/src/serve/chatProcessing.ts
-import path38 from "path";
-import fs36 from "fs";
+import path39 from "path";
+import fs37 from "fs";
 var handleUnifiedChat;
 var init_chatProcessing = __esm({
   "../core/src/serve/chatProcessing.ts"() {
@@ -11824,17 +12040,17 @@ ${inject}`;
       if (roots.length > 1) {
         let activeReal = getActiveWorkspaceRoot();
         try {
-          activeReal = fs36.realpathSync(activeReal);
+          activeReal = fs37.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 {
@@ -11921,7 +12137,7 @@ ${lines.join("\n")}
 });
 // ../core/src/session/fork.ts
-import fs37 from "fs/promises";
+import fs38 from "fs/promises";
 var listForkAnchors, derivePrefix, forkSession;
 var init_fork = __esm({
   "../core/src/session/fork.ts"() {
@@ -11993,7 +12209,7 @@ var init_fork = __esm({
       const prefix = derivePrefix(lines, upToLineId);
       const newId = createUUID();
       await ensureSessionsDir(newId);
-      const rawText = await fs37.readFile(getTranscriptPath(sourceId), "utf-8");
+      const rawText = await fs38.readFile(getTranscriptPath(sourceId), "utf-8");
       const kept = [];
       let good = 0;
       for (const s of rawText.split("\n")) {
@@ -12009,7 +12225,7 @@ var init_fork = __esm({
       }
       let payload = kept.join("\n");
       if (payload.length > 0 && !payload.endsWith("\n")) payload += "\n";
-      await fs37.writeFile(getTranscriptPath(newId), payload, "utf-8");
+      await fs38.writeFile(getTranscriptPath(newId), payload, "utf-8");
       const srcState = await readStore(sourceId);
       const srcRolling = await getRollingState(sourceId);
       const legacy = !lines.some(isEventLine);
@@ -12025,6 +12241,9 @@ var init_fork = __esm({
         rollingSummary,
         consecutiveFailures: 0,
         title: `${srcTitle}(\u5206\u53C9)`.slice(0, 200),
+        // ★ fork 血缘元数据：新 ID 是纯 UUID（字符串上无痕），血缘回溯全靠此字段
+        //   （session/lineage.ts 消费：审批网关归属 / 子 Agent 续跑归属）。
+        forkedFrom: sourceId,
         // ★ 校准数据透传：fork 首轮压缩判定不从 1.4 重来（纯收益，语义同源会话续接）
         calibRatio: srcRolling.calibRatio,
         lastRealPromptTokens: srcRolling.lastRealPromptTokens,
@@ -13703,7 +13922,7 @@ var init_TopPanel = __esm({
 });
 // src/inspect.ts
-import fs38 from "fs";
+import fs39 from "fs";
 var CWD, fmt, readTrace, inspectUsage, inspectContext, inspectPermissions, inspectMcp, inspectHooks, inspectDebug;
 var init_inspect = __esm({
   "src/inspect.ts"() {
@@ -13721,7 +13940,7 @@ var init_inspect = __esm({
       if (!sessionId) return [];
       try {
         const p = await getTraceStorePath(sessionId);
-        const text = await fs38.promises.readFile(p, "utf8");
+        const text = await fs39.promises.readFile(p, "utf8");
         const out = [];
         for (const line of text.split("\n")) {
           if (!line.trim()) continue;
@@ -14412,81 +14631,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";
@@ -14534,6 +14678,7 @@ applyConfigToEnv(loadConfigFile());
 // src/main.tsx
 init_strings();
 init_prefs();
+init_updateCheck();
 init_trust();
 import { render } from "ink";
 import os5 from "os";
@@ -14550,6 +14695,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;
 };
@@ -14610,6 +14756,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);