exomind 0.8.0 → 0.10.0

package/dist/cli.js

@@ -965,8 +965,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path8 = require("path");
-    var fs8 = require("fs");
+    var path9 = require("path");
+    var fs9 = require("fs");
     var process2 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1898,11 +1898,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path8.resolve(baseDir, baseName);
-          if (fs8.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path8.extname(baseName))) return void 0;
+          const localBin = path9.resolve(baseDir, baseName);
+          if (fs9.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path9.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs8.existsSync(`${localBin}${ext}`)
+            (ext) => fs9.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1914,21 +1914,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs8.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs9.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path8.resolve(
-            path8.dirname(resolvedScriptPath),
+          executableDir = path9.resolve(
+            path9.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path8.basename(
+            const legacyName = path9.basename(
               this._scriptPath,
-              path8.extname(this._scriptPath)
+              path9.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1939,7 +1939,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path8.extname(executableFile));
+        launchWithNode = sourceExt.includes(path9.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2779,7 +2779,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path8.basename(filename, path8.extname(filename));
+        this._name = path9.basename(filename, path9.extname(filename));
         return this;
       }
       /**
@@ -2793,9 +2793,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path9) {
-        if (path9 === void 0) return this._executableDir;
-        this._executableDir = path9;
+      executableDir(path10) {
+        if (path10 === void 0) return this._executableDir;
+        this._executableDir = path10;
         return this;
       }
       /**
@@ -3119,7 +3119,7 @@ var {
 // package.json
 var package_default = {
   name: "exomind",
-  version: "0.8.0",
+  version: "0.10.0",
   description: "ExoMind \u8DE8\u5E73\u53F0\u547D\u4EE4\u884C\u5BA2\u6237\u7AEF \u2014 \u901A\u8FC7 REST \u4E0E ExoMind \u77E5\u8BC6\u5E93\u4EA4\u4E92(ingest/query/search/review),\u66FF\u4EE3 Windows \u4E0D\u53EF\u7528\u7684 MCP \u5BA2\u6237\u7AEF\u3002",
   bin: {
     exomind: "dist/cli.js"
@@ -3465,6 +3465,45 @@ function sessionKey() {
 function dedupPath() {
   return path2.join(CACHE_DIR, `dedup-${sessionKey()}.json`);
 }
+var DISCOVER_STATE = path2.join(CACHE_DIR, "discover-state.json");
+var DISCOVER_FAIL_COOLDOWN_MS = 30 * 60 * 1e3;
+function buildDiscoverInjection(cards) {
+  if (!cards || !cards.length) return "";
+  const labels = { recap: "\u627E\u56DE", bridge: "\u65B0\u8FDE\u63A5", stub: "\u5F85\u8865\u5168", theme: "\u672C\u5468\u4E3B\u7EBF" };
+  const c = cards[0];
+  return `[ExoMind \u4ECA\u65E5\u53D1\u73B0\xB7${labels[c.type] || c.type}] ${c.reason}
+\u4ECA\u65E5\u5171 ${cards.length} \u5F20\u5361:\u8FD0\u884C \`exomind entity "${c.name}"\` \u67E5\u770B\u7B2C\u4E00\u6761,\u6216\u6253\u5F00 youhuale.cn/ui/discover \u9010\u5F20\u5904\u7406\u3002\u4E0E\u5F53\u524D\u8BDD\u9898\u65E0\u5173\u5219\u5FFD\u7565\u3002`;
+}
+function readDiscoverState() {
+  try {
+    return JSON.parse(fs3.readFileSync(DISCOVER_STATE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveDiscoverState(st) {
+  try {
+    fs3.mkdirSync(CACHE_DIR, { recursive: true });
+    fs3.writeFileSync(DISCOVER_STATE, JSON.stringify(st));
+  } catch {
+  }
+}
+async function dailyDiscoverInjection(client) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const st = readDiscoverState();
+  if (st.date === today && st.done) return "";
+  if (st.date === today && st.failed && Date.now() - st.failed < DISCOVER_FAIL_COOLDOWN_MS) {
+    return "";
+  }
+  try {
+    const data = await client.get("/daily-discovery", void 0, { timeoutMs: 8e3 });
+    saveDiscoverState({ date: today, done: true, ts: Date.now() });
+    return buildDiscoverInjection(data.discoveries || []);
+  } catch {
+    saveDiscoverState({ date: today, failed: Date.now() });
+    return "";
+  }
+}
 function safe(s) {
   return s.replace(/[^a-zA-Z0-9一-龥._-]/g, "_").slice(0, 64);
 }
@@ -3634,6 +3673,11 @@ async function runHook(client) {
     if (ctx) outputs.push(ctx);
   } catch {
   }
+  try {
+    const discover = await dailyDiscoverInjection(client);
+    if (discover) outputs.push(discover);
+  } catch {
+  }
   saveDedup(dedup);
   if (outputs.length) {
     process.stdout.write(outputs.join("\n\n") + "\n");
@@ -3794,24 +3838,70 @@ async function runMcpServer(client) {
   });
 }
 
+// src/update-check.ts
+var fs4 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function compareVersions(current, latest) {
+  const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
+  const a = parse(current);
+  const b = parse(latest);
+  if (a.length !== 3 || b.length !== 3 || [...a, ...b].some(Number.isNaN)) return 0;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return 0;
+}
+function statePath() {
+  return path3.join(CACHE_DIR, "update-check.json");
+}
+async function maybeNotifyUpdate(current, registry = "https://registry.npmjs.org") {
+  if (process.env.EXOMIND_SKIP_UPDATE_CHECK === "1") return;
+  const file = statePath();
+  try {
+    const st = JSON.parse(fs4.readFileSync(file, "utf-8"));
+    if (st.version === current && Date.now() - (st.ts ?? 0) < CHECK_INTERVAL_MS) return;
+  } catch {
+  }
+  let latest = "";
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    const r = await fetch(`${registry}/exomind/latest`, { signal: ctrl.signal });
+    clearTimeout(timer);
+    if (r.ok) latest = String((await r.json()).version || "");
+  } catch {
+  }
+  try {
+    fs4.mkdirSync(CACHE_DIR, { recursive: true });
+    fs4.writeFileSync(file, JSON.stringify({ version: current, ts: Date.now(), latest }));
+  } catch {
+  }
+  if (latest && compareVersions(current, latest) < 0) {
+    process.stderr.write(dim(`\u2197 \u53D1\u73B0\u65B0\u7248 v${latest}(\u5F53\u524D v${current}):npm i -g exomind \u5347\u7EA7
+`));
+  }
+}
+
 // src/commands/ingest.ts
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 
 // src/ingest_dir.ts
-var fs5 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 
 // src/manifest.ts
-var fs4 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var crypto = __toESM(require("crypto"));
-var MANIFEST_FILE = path3.join(CONFIG_DIR, "manifest.json");
+var MANIFEST_FILE = path4.join(CONFIG_DIR, "manifest.json");
 function sha256(s) {
   return crypto.createHash("sha256").update(s, "utf-8").digest("hex");
 }
 function loadManifest() {
   try {
-    const d = JSON.parse(fs4.readFileSync(MANIFEST_FILE, "utf-8"));
+    const d = JSON.parse(fs5.readFileSync(MANIFEST_FILE, "utf-8"));
     return d && typeof d === "object" ? d : {};
   } catch {
     return {};
@@ -3819,8 +3909,8 @@ function loadManifest() {
 }
 function saveManifest(m) {
   try {
-    fs4.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs4.writeFileSync(MANIFEST_FILE, JSON.stringify(m, null, 2));
+    fs5.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs5.writeFileSync(MANIFEST_FILE, JSON.stringify(m, null, 2));
   } catch {
   }
 }
@@ -3833,7 +3923,7 @@ function recordFile(manifest, absPath, rawContent, title) {
   };
 }
 function cleanupStale(m, dir, currentFiles) {
-  const prefix = path3.resolve(dir) + path3.sep;
+  const prefix = path4.resolve(dir) + path4.sep;
   const current = new Set(currentFiles);
   for (const key of Object.keys(m)) {
     if (key.startsWith(prefix) && !current.has(key)) {
@@ -3853,13 +3943,13 @@ function walkDir(dir, recursive, pattern) {
   const walk = (d) => {
     let entries;
     try {
-      entries = fs5.readdirSync(d, { withFileTypes: true });
+      entries = fs6.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path4.join(d, e.name);
+      const full = path5.join(d, e.name);
       if (e.isDirectory()) {
         if (recursive) walk(full);
       } else if (e.isFile() && rx.test(e.name)) {
@@ -3867,7 +3957,7 @@ function walkDir(dir, recursive, pattern) {
       }
     }
   };
-  walk(path4.resolve(dir));
+  walk(path5.resolve(dir));
   return out.sort();
 }
 function deriveTitle(file, content) {
@@ -3875,7 +3965,7 @@ function deriveTitle(file, content) {
     const m = line.match(/^#\s+(.+?)\s*$/);
     if (m) return m[1].trim();
   }
-  return path4.basename(file).replace(/\.[^.]+$/, "");
+  return path5.basename(file).replace(/\.[^.]+$/, "");
 }
 function planIngestest(files, manifest, force) {
   const toIngest = [];
@@ -3965,22 +4055,19 @@ async function ingestWithRetry(client, payload, timeoutMs, url = "/ingest") {
     }
   }
 }
-async function retryTransient(fn, maxAttempts = 3) {
-  let lastErr;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+async function retryWith429(fn, maxAttempts = 3) {
+  for (let attempt = 1; ; attempt++) {
     try {
       return await fn();
     } catch (e) {
-      lastErr = e;
-      const transient = e instanceof ApiError && ([502, 503, 504].includes(e.status) || e.status === 0);
-      if (transient && attempt < maxAttempts) {
-        await sleep(Math.pow(2, attempt - 1) * 1e3);
-        continue;
-      }
-      throw e;
+      if (!(e instanceof ApiError) || e.status !== 429 || attempt >= maxAttempts) throw e;
+      const raw = Number(e.headers["retry-after"] ?? e.body?.retry_after ?? 5);
+      const wait = Math.min(Number.isFinite(raw) && raw > 0 ? raw : 5, 60);
+      process.stderr.write(dim(`  \u23F8 \u8BF7\u6C42\u9891\u7387\u8D85\u9650,${wait}s \u540E\u91CD\u8BD5 (${attempt}/${maxAttempts})
+`));
+      await sleep(wait * 1e3);
     }
   }
-  throw lastErr;
 }
 async function suspendUntilMidnight(resetEpoch) {
   suspended = true;
@@ -4042,7 +4129,7 @@ async function runDirIngestest(client, opts, dir) {
         pending.push({ file: f, jobId: res.job_id });
       } catch (e) {
         failed++;
-        process.stderr.write(`  ${red("\u2717")} ${path4.basename(f.path)} \u63D0\u4EA4\u5931\u8D25 \u2014 ${friendlyMsg(e)}
+        process.stderr.write(`  ${red("\u2717")} ${path5.basename(f.path)} \u63D0\u4EA4\u5931\u8D25 \u2014 ${friendlyMsg(e)}
 `);
       }
     });
@@ -4056,7 +4143,7 @@ async function runDirIngestest(client, opts, dir) {
       if (Date.now() > pollDeadline) {
         for (const [, f] of inFlight) {
           failed++;
-          process.stderr.write(`  ${red("\u2717")} ${path4.basename(f.path)} \u8F6E\u8BE2\u8D85\u65F6
+          process.stderr.write(`  ${red("\u2717")} ${path5.basename(f.path)} \u8F6E\u8BE2\u8D85\u65F6
 `);
         }
         inFlight.clear();
@@ -4065,13 +4152,13 @@ async function runDirIngestest(client, opts, dir) {
       await Promise.all(
         [...inFlight.entries()].map(async ([jobId, f]) => {
           try {
-            const s = await retryTransient(() => client.get("/ingest/status", { job_id: jobId }));
+            const s = await retryWith429(() => client.get("/ingest/status", { job_id: jobId }));
             if (s.status !== "done" && s.status !== "failed") return;
             inFlight.delete(jobId);
             done++;
             if (s.status === "failed") {
               failed++;
-              process.stderr.write(`  ${red("\u2717")} ${path4.basename(f.path)} \u5904\u7406\u5931\u8D25 \u2014 ${s.error || "\u672A\u77E5\u9519\u8BEF"}
+              process.stderr.write(`  ${red("\u2717")} ${path5.basename(f.path)} \u5904\u7406\u5931\u8D25 \u2014 ${s.error || "\u672A\u77E5\u9519\u8BEF"}
 `);
               return;
             }
@@ -4080,7 +4167,7 @@ async function runDirIngestest(client, opts, dir) {
             saveManifest(manifest);
             if (s.extracted === false) {
               degraded++;
-              process.stderr.write(`  \u26A0 ${path4.basename(f.path)} \u964D\u7EA7 \u2014 \u539F\u6587\u5DF2\u5B58,\u5B9E\u4F53\u62BD\u53D6\u5F85\u8865\u8DD1
+              process.stderr.write(`  \u26A0 ${path5.basename(f.path)} \u964D\u7EA7 \u2014 \u539F\u6587\u5DF2\u5B58,\u5B9E\u4F53\u62BD\u53D6\u5F85\u8865\u8DD1
 `);
             } else if (prev) {
               updated++;
@@ -4136,7 +4223,7 @@ async function ingest(client, opts, args) {
   if (opts.file) {
     fileRaw = readFileText(opts.file);
     content = fileRaw;
-    fileAbs = path5.resolve(opts.file);
+    fileAbs = path6.resolve(opts.file);
   } else if (args.length && args[0] === "-") {
     content = await readStdinForced();
   } else if (args.length) {
@@ -4158,7 +4245,7 @@ async function ingest(client, opts, args) {
   const result = await ingestWithRetry(client, body, opTimeout(3e5));
   if (fileAbs && fileRaw !== null) {
     const man = loadManifest();
-    recordFile(man, fileAbs, fileRaw, opts.title || path5.basename(fileAbs));
+    recordFile(man, fileAbs, fileRaw, opts.title || path6.basename(fileAbs));
     saveManifest(man);
   }
   output(result, () => {
@@ -4183,7 +4270,7 @@ async function query(client, opts, args) {
   if (opts.tag?.length) body.tags = opts.tag;
   if (opts.model) body.model = opts.model;
   hint("\u23F3 \u67E5\u8BE2\u4E2D: LLM \u68C0\u7D22 + \u751F\u6210,\u53EF\u80FD 1-2 \u5206\u949F\u2026");
-  const result = await client.post("/query", body, { timeoutMs: opTimeout(18e4) });
+  const result = await retryWith429(() => client.post("/query", body, { timeoutMs: opTimeout(18e4) }));
   output(result, () => {
     console.log(result.answer || dim("(\u65E0\u56DE\u7B54)"));
     if (result.pages?.length) {
@@ -4198,12 +4285,12 @@ async function query(client, opts, args) {
 async function search(client, opts, args) {
   const keyword = args.join(" ").trim();
   if (!keyword) throw new Error('\u8BF7\u63D0\u4F9B\u5173\u952E\u8BCD: exomind search "\u5173\u952E\u8BCD"');
-  const result = await client.get("/search", {
+  const result = await retryWith429(() => client.get("/search", {
     q: keyword,
     limit: opts.limit ?? 10,
     rerank: opts.rerank ?? false,
     hybrid: opts.hybrid ?? false
-  });
+  }));
   const results = result.results || [];
   output(result, () => {
     if (!results.length) {
@@ -4594,26 +4681,26 @@ async function whoami(client) {
 }
 
 // src/commands/install.ts
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var import_node_child_process = require("child_process");
-var PKG_ROOT = path6.resolve(__dirname, "..");
-var CLAUDE_SKILL_SRC = path6.join(PKG_ROOT, "skill", "claude", "SKILL.md");
-var CODEX_SKILL_SRC = path6.join(PKG_ROOT, "skill", "codex", "SKILL.md");
+var PKG_ROOT = path7.resolve(__dirname, "..");
+var CLAUDE_SKILL_SRC = path7.join(PKG_ROOT, "skill", "claude", "SKILL.md");
+var CODEX_SKILL_SRC = path7.join(PKG_ROOT, "skill", "codex", "SKILL.md");
 function readJson2(file) {
   try {
-    return JSON.parse(fs6.readFileSync(file, "utf-8"));
+    return JSON.parse(fs7.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function backup(file) {
-  if (!fs6.existsSync(file)) return;
+  if (!fs7.existsSync(file)) return;
   const bak = `${file}.bak-${Date.now()}`;
   try {
-    fs6.copyFileSync(file, bak);
-    console.log(dim(`  (\u5DF2\u5907\u4EFD \u2192 ${path6.basename(bak)})`));
+    fs7.copyFileSync(file, bak);
+    console.log(dim(`  (\u5DF2\u5907\u4EFD \u2192 ${path7.basename(bak)})`));
   } catch {
     return;
   }
@@ -4621,12 +4708,12 @@ function backup(file) {
 }
 function pruneBackups(file, keep) {
   try {
-    const dir = path6.dirname(file);
-    const prefix = path6.basename(file) + ".bak-";
-    const olds = fs6.readdirSync(dir).filter((f) => f.startsWith(prefix)).map((f) => ({ f, mt: fs6.statSync(path6.join(dir, f)).mtimeMs })).sort((a, b) => b.mt - a.mt);
+    const dir = path7.dirname(file);
+    const prefix = path7.basename(file) + ".bak-";
+    const olds = fs7.readdirSync(dir).filter((f) => f.startsWith(prefix)).map((f) => ({ f, mt: fs7.statSync(path7.join(dir, f)).mtimeMs })).sort((a, b) => b.mt - a.mt);
     for (const o of olds.slice(keep)) {
       try {
-        fs6.unlinkSync(path6.join(dir, o.f));
+        fs7.unlinkSync(path7.join(dir, o.f));
       } catch {
       }
     }
@@ -4635,7 +4722,7 @@ function pruneBackups(file, keep) {
 }
 function resolveCodexHome(env = process.env, homeDir = os2.homedir()) {
   const configured = (env.CODEX_HOME ?? "").trim();
-  return configured ? path6.resolve(configured) : path6.join(homeDir, ".codex");
+  return configured ? path7.resolve(configured) : path7.join(homeDir, ".codex");
 }
 function looksLikeValidToml(text) {
   if (!text.trim()) return true;
@@ -4649,14 +4736,14 @@ function looksLikeValidToml(text) {
   return brackets === 0;
 }
 function configureCodexMcp(codexHome) {
-  const codexConfig = path6.join(codexHome, "config.toml");
+  const codexConfig = path7.join(codexHome, "config.toml");
   try {
-    fs6.mkdirSync(path6.dirname(codexConfig), { recursive: true });
+    fs7.mkdirSync(path7.dirname(codexConfig), { recursive: true });
   } catch {
   }
   let existing = "";
   try {
-    existing = fs6.readFileSync(codexConfig, "utf-8");
+    existing = fs7.readFileSync(codexConfig, "utf-8");
   } catch {
     existing = "";
   }
@@ -4677,24 +4764,24 @@ function configureCodexMcp(codexHome) {
 command = "exomind"
 args = ["mcp"]
 `;
-  fs6.writeFileSync(codexConfig, existing + snippet);
-  const after = fs6.readFileSync(codexConfig, "utf-8");
+  fs7.writeFileSync(codexConfig, existing + snippet);
+  const after = fs7.readFileSync(codexConfig, "utf-8");
   if (!/^\[mcp_servers\.exomind\]\s*$/m.test(after) || !looksLikeValidToml(after)) {
     return { ok: false, written: true, file: codexConfig, reason: "\u5199\u540E\u590D\u9A8C\u5931\u8D25(\u6BB5\u672A\u5199\u5165\u6216\u6587\u4EF6\u635F\u574F)" };
   }
   return { ok: true, written: true, file: codexConfig };
 }
 function installCodexSkill(codexHome, skillSrc = CODEX_SKILL_SRC) {
-  const destDir = path6.join(codexHome, "skills", "exomind");
-  const dest = path6.join(destDir, "SKILL.md");
-  if (!fs6.existsSync(skillSrc)) {
+  const destDir = path7.join(codexHome, "skills", "exomind");
+  const dest = path7.join(destDir, "SKILL.md");
+  if (!fs7.existsSync(skillSrc)) {
     return { ok: false, dest, reason: `skill \u6E90\u4E0D\u5B58\u5728: ${skillSrc}` };
   }
-  fs6.mkdirSync(destDir, { recursive: true });
+  fs7.mkdirSync(destDir, { recursive: true });
   backup(dest);
   const tmp = `${dest}.tmp-${Date.now()}`;
-  fs6.writeFileSync(tmp, fs6.readFileSync(skillSrc));
-  fs6.renameSync(tmp, dest);
+  fs7.writeFileSync(tmp, fs7.readFileSync(skillSrc));
+  fs7.renameSync(tmp, dest);
   return { ok: true, dest };
 }
 function purgeMcpExomind(file) {
@@ -4705,7 +4792,7 @@ function purgeMcpExomind(file) {
   delete grp.exomind;
   if (Object.keys(grp).length === 0) delete d.mcpServers;
   backup(file);
-  fs6.writeFileSync(file, JSON.stringify(d, null, 2) + "\n");
+  fs7.writeFileSync(file, JSON.stringify(d, null, 2) + "\n");
   return true;
 }
 function checkMcp(timeoutMs = 6e3) {
@@ -4757,17 +4844,17 @@ async function install(client, opts) {
   if (opts.host && !["claude", "codex", "opencode"].includes(opts.host)) {
     throw new Error(`\u672A\u77E5 --host: ${opts.host}(\u53EF\u9009: claude | codex | opencode)`);
   }
-  const claudeDir = path6.join(os2.homedir(), ".claude");
-  const skillDestDir = path6.join(claudeDir, "skills", "exomind");
+  const claudeDir = path7.join(os2.homedir(), ".claude");
+  const skillDestDir = path7.join(claudeDir, "skills", "exomind");
   const codexHome = resolveCodexHome();
   const want = (h) => !opts.host || opts.host === h;
   if (opts.skill !== false) {
     if (want("claude")) {
-      if (!fs6.existsSync(CLAUDE_SKILL_SRC)) {
+      if (!fs7.existsSync(CLAUDE_SKILL_SRC)) {
         throw new Error(`Claude skill \u6E90\u4E0D\u5B58\u5728: ${CLAUDE_SKILL_SRC}(npm \u5305\u53EF\u80FD\u635F\u574F,\u6216\u5F00\u53D1\u6A21\u5F0F\u4E0B\u672A\u6784\u5EFA)`);
       }
-      fs6.mkdirSync(skillDestDir, { recursive: true });
-      fs6.copyFileSync(CLAUDE_SKILL_SRC, path6.join(skillDestDir, "SKILL.md"));
+      fs7.mkdirSync(skillDestDir, { recursive: true });
+      fs7.copyFileSync(CLAUDE_SKILL_SRC, path7.join(skillDestDir, "SKILL.md"));
       console.log(ok("\u5DF2\u5B89\u88C5 Claude Code skill"));
       console.log(dim(`  \u2192 ${skillDestDir}/SKILL.md`));
     }
@@ -4782,8 +4869,8 @@ async function install(client, opts) {
     }
   }
   if (opts.hook !== false && want("claude")) {
-    const settingsFile = path6.join(claudeDir, "settings.json");
-    fs6.mkdirSync(claudeDir, { recursive: true });
+    const settingsFile = path7.join(claudeDir, "settings.json");
+    fs7.mkdirSync(claudeDir, { recursive: true });
     backup(settingsFile);
     const settings = readJson2(settingsFile) ?? {};
     const hooks = settings.hooks ?? {};
@@ -4796,31 +4883,31 @@ async function install(client, opts) {
     });
     hooks.UserPromptSubmit = kept;
     settings.hooks = hooks;
-    fs6.writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+    fs7.writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
     console.log(ok("\u5DF2\u914D\u7F6E UserPromptSubmit hook \u2192 exomind hook (Claude Code \u72EC\u6709)"));
     console.log(dim("  Codex \u5F53\u524D\u65E0\u5BF9\u5E94 prompt-submit hook,\u9760 skill \u89E6\u53D1(jdit/\u5B58\u6863/\u67E5\u8BE2)\u3002"));
   }
   if (opts.mcp !== false) {
     const configured = [];
     if (want("claude")) {
-      const ccJson = path6.join(os2.homedir(), ".claude.json");
+      const ccJson = path7.join(os2.homedir(), ".claude.json");
       backup(ccJson);
       const cc = readJson2(ccJson) ?? {};
       const ccMcp = cc.mcpServers ?? {};
       ccMcp.exomind = { command: "exomind", args: ["mcp"] };
       cc.mcpServers = ccMcp;
-      fs6.writeFileSync(ccJson, JSON.stringify(cc, null, 2) + "\n");
+      fs7.writeFileSync(ccJson, JSON.stringify(cc, null, 2) + "\n");
       configured.push("Claude Code (~/.claude.json)");
     }
     if (want("opencode")) {
-      const ocJson = path6.join(os2.homedir(), ".config", "opencode", "opencode.json");
-      fs6.mkdirSync(path6.dirname(ocJson), { recursive: true });
+      const ocJson = path7.join(os2.homedir(), ".config", "opencode", "opencode.json");
+      fs7.mkdirSync(path7.dirname(ocJson), { recursive: true });
       backup(ocJson);
       const oc = readJson2(ocJson) ?? {};
       const ocMcp = oc.mcp ?? {};
       ocMcp.exomind = { type: "local", command: ["exomind", "mcp"] };
       oc.mcp = ocMcp;
-      fs6.writeFileSync(ocJson, JSON.stringify(oc, null, 2) + "\n");
+      fs7.writeFileSync(ocJson, JSON.stringify(oc, null, 2) + "\n");
       configured.push("OpenCode (~/.config/opencode/opencode.json)");
     }
     if (want("codex")) {
@@ -4829,14 +4916,14 @@ async function install(client, opts) {
       else console.log(yellow(`\u2717 Codex MCP \u914D\u7F6E\u5931\u8D25: ${r.reason}`));
     }
     const purged = [];
-    if (want("claude") && purgeMcpExomind(path6.join(claudeDir, "settings.json"))) {
+    if (want("claude") && purgeMcpExomind(path7.join(claudeDir, "settings.json"))) {
       purged.push("~/.claude/settings.json");
     }
     let curDir = process.cwd();
-    for (let i = 0; i < 12 && curDir !== path6.dirname(curDir); i++) {
-      const f = path6.join(curDir, ".mcp.json");
-      if (fs6.existsSync(f) && purgeMcpExomind(f)) purged.push(f.replace(os2.homedir(), "~"));
-      curDir = path6.dirname(curDir);
+    for (let i = 0; i < 12 && curDir !== path7.dirname(curDir); i++) {
+      const f = path7.join(curDir, ".mcp.json");
+      if (fs7.existsSync(f) && purgeMcpExomind(f)) purged.push(f.replace(os2.homedir(), "~"));
+      curDir = path7.dirname(curDir);
     }
     if (purged.length) console.log(dim(`  \u2192 \u6E05\u7406\u6B8B\u7559 exomind MCP \u6761\u76EE(\u907F\u514D\u8986\u76D6 stdio): ${purged.join(", ")}`));
     if (configured.length) {
@@ -4845,12 +4932,12 @@ async function install(client, opts) {
       console.log(dim("  \u91CD\u542F\u5BF9\u5E94 Agent \u2192 \u62FF\u5230 mcp__exomind__* \u5DE5\u5177"));
     }
   }
-  const cfgFile = path6.join(os2.homedir(), ".exomind", "config.json");
+  const cfgFile = path7.join(os2.homedir(), ".exomind", "config.json");
   const cfg = readJson2(cfgFile);
   if (cfg && typeof cfg.base_url === "string" && cfg.base_url.includes("d.youhuale.cn")) {
     backup(cfgFile);
     cfg.base_url = DEFAULT_BASE_URL;
-    fs6.writeFileSync(cfgFile, JSON.stringify(cfg, null, 2) + "\n");
+    fs7.writeFileSync(cfgFile, JSON.stringify(cfg, null, 2) + "\n");
     console.log(ok(`\u5DF2\u8FC1\u79FB base_url: d.youhuale.cn \u2192 ${DEFAULT_BASE_URL}`));
     console.log(dim("  (stdio MCP \u5B50\u8FDB\u7A0B\u8BFB\u6B64\u914D\u7F6E,\u91CD\u542F Agent \u540E\u7528\u65B0\u57DF\u540D)"));
   }
@@ -4869,10 +4956,10 @@ async function install(client, opts) {
     }
   }
   const mcp = live.api_key ? await checkMcp() : { ok: false, detail: "\u672A\u914D\u7F6E API Key" };
-  const codexSkillOk = fs6.existsSync(path6.join(codexHome, "skills", "exomind", "SKILL.md"));
+  const codexSkillOk = fs7.existsSync(path7.join(codexHome, "skills", "exomind", "SKILL.md"));
   const codexMcfgOk = (() => {
     try {
-      return /^\[mcp_servers\.exomind\]\s*$/m.test(fs6.readFileSync(path6.join(codexHome, "config.toml"), "utf-8"));
+      return /^\[mcp_servers\.exomind\]\s*$/m.test(fs7.readFileSync(path7.join(codexHome, "config.toml"), "utf-8"));
     } catch {
       return false;
     }
@@ -4903,19 +4990,19 @@ async function install(client, opts) {
 }
 
 // src/commands/doctor.ts
-var fs7 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 function readText(p) {
   try {
-    return fs7.readFileSync(p, "utf-8");
+    return fs8.readFileSync(p, "utf-8");
   } catch {
     return "";
   }
 }
 function fileExists(p) {
   try {
-    return fs7.existsSync(p);
+    return fs8.existsSync(p);
   } catch {
     return false;
   }
@@ -4938,9 +5025,9 @@ function badge(s) {
 async function doctor(client) {
   const codexHome = resolveCodexHome();
   const checks = [];
-  const claudeSkill = path7.join(os3.homedir(), ".claude", "skills", "exomind", "SKILL.md");
-  const claudeSettings = path7.join(os3.homedir(), ".claude", "settings.json");
-  const claudeJson = path7.join(os3.homedir(), ".claude.json");
+  const claudeSkill = path8.join(os3.homedir(), ".claude", "skills", "exomind", "SKILL.md");
+  const claudeSettings = path8.join(os3.homedir(), ".claude", "settings.json");
+  const claudeJson = path8.join(os3.homedir(), ".claude.json");
   checks.push({
     host: "claude",
     skill: fileExists(claudeSkill) ? "ok" : "missing",
@@ -4948,8 +5035,8 @@ async function doctor(client) {
     mcpConfig: mcpServersExomind(claudeJson, "mcpServers") ? "ok" : "missing",
     paths: [claudeSkill, claudeSettings, claudeJson]
   });
-  const codexSkill = path7.join(codexHome, "skills", "exomind", "SKILL.md");
-  const codexConfig = path7.join(codexHome, "config.toml");
+  const codexSkill = path8.join(codexHome, "skills", "exomind", "SKILL.md");
+  const codexConfig = path8.join(codexHome, "config.toml");
   checks.push({
     host: "codex",
     skill: fileExists(codexSkill) ? "ok" : "missing",
@@ -4958,7 +5045,7 @@ async function doctor(client) {
     paths: [codexSkill, codexConfig],
     detail: "Codex \u65E0 prompt-submit hook,\u9760 skill \u89E6\u53D1(jdit/\u5B58\u6863/\u67E5\u8BE2)"
   });
-  const ocJson = path7.join(os3.homedir(), ".config", "opencode", "opencode.json");
+  const ocJson = path8.join(os3.homedir(), ".config", "opencode", "opencode.json");
   checks.push({
     host: "opencode",
     skill: "unsupported",
@@ -5036,6 +5123,7 @@ function run(fn) {
     const client = new ApiClient(cfg);
     try {
       await fn(client, command.opts(), command.args);
+      if (!root.json) await maybeNotifyUpdate(VERSION);
     } catch (e) {
       handleError(e);
     }