dsh-plugin-tool-management 0.15.0 → 0.16.5

package/lib/compat/probe.js

@@ -32,6 +32,7 @@
 import { createRequire } from 'node:module';
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 /** Packages whose physical module identity matters to this plugin. */
 export const IDENTITY_PACKAGES = [
     '@deepseek-ai/cordis',
@@ -42,29 +43,55 @@ export const IDENTITY_PACKAGES = [
     '@deepseek-ai/dsh-spill-local',
 ];
 /**
- * peer range 的下界与已验证版本。官方全程走 prerelease 渠道（x.y.z-rc.N），semver 的
+ * 本插件是不是从**源码检出**跑起来的（仓库里那份，`scripts/host-deps.mjs` 就躺在旁边）。
+ *
+ * 用来决定「两份拷贝」那条阻塞项给什么修复指引：`scripts/` 不在 `package.json` 的
+ * `files` 里（发布形态本就不该带开发者脚本），所以 npm 装出来的用户照那条指引去跑
+ * 只会拿到 `MODULE_NOT_FOUND` —— 这是 issue #1 的次要问题之一。指引必须按实际形态给。
+ */
+const SOURCE_INSTALL = existsSync(join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'scripts', 'host-deps.mjs'));
+/** 供界面决定修复指引：`true` = 源码检出（`scripts/` 就在旁边），`false` = npm 安装形态。 */
+export function isSourceInstall() {
+    return SOURCE_INSTALL;
+}
+/**
+ * peer range 与已验证版本。官方全程走 prerelease 渠道（x.y.z-rc.N），semver 的
  * 预发布规则（prerelease 版本只匹配同 [major,minor,patch] 元组的比较器）意味着**每一代
  * rc 都要显式列进范围**：`>=0.1.5-rc.2` 匹配不了 `0.1.7-rc.2`（实测），所以范围是逐代
  * 枚举的并集。上界依旧不设：宿主跨代升级由运行时能力探测兜底（见下）。
+ *
+ * 0.2.0-rc.2（桌面版首发）已实测通过：`assessHost` 18/18 全通过，宿主版本读得出来，
+ * 归档宿主的身份判定见 `hostPackageRoot` / `isAsarPath`。所以它同时进范围与「已验证」。
  */
-export const EXPECTED_PEER_RANGE = '^0.1.5-rc.2 || ^0.1.7-rc.2';
+export const EXPECTED_PEER_RANGE = '^0.1.5-rc.2 || ^0.1.7-rc.2 || ^0.2.0-rc.2';
 /** The release this plugin's adapters were last verified against. */
-export const VERIFIED_HOST_VERSION = '0.1.7-rc.2';
+export const VERIFIED_HOST_VERSION = '0.2.0-rc.2';
 /**
- * peer range 的下界 —— 界面展示用。
+ * peer range 的下界。
  *
  * 刻意不带 semver 上界：官方持续发版，硬上界会在宿主跨 minor 升级时直接挡住
  * 插件安装（pnpm peer 校验失败）。上界改为由**运行时能力探测**兜底 ——
  * 宿主版本高于已验证范围时，`assessHost` 会逐项探测并把缺失能力降级/禁用，
- * 而不是在安装期拒绝整包。展示时只应把「最低要求版本」当事实。
+ * 而不是在安装期拒绝整包。
  * 从 EXPECTED_PEER_RANGE 派生，避免两处手写漂移。
+ *
+ * 2026-09-29 起**不再出现在界面上**（用户裁定：删掉「最低要求 ≥ …」那一行 —— 它是安装期
+ * 门槛，摆在"当前宿主"卡片下面会被读成对当前宿主的断言）。保留此导出是因为它进了
+ * `compat-status` 的载荷，doctor 与外部脚本可能仍在读。
  */
 export const EXPECTED_MIN_HOST_VERSION = EXPECTED_PEER_RANGE.match(/(\d+\.\d+\.\d+(?:-rc\.\d+)?)/)?.[1] ?? VERIFIED_HOST_VERSION;
 const isFn = (value) => typeof value === 'function';
-/** Resolve a package the way this plugin resolves it, without throwing. */
+/**
+ * Resolve a package the way this plugin resolves it, without throwing.
+ *
+ * `import.meta.resolve` 给的是**URL**：目录里带空格的路径（桌面版装在
+ * `D:\DeepSeek Harness\...`）会以 `%20` 形式回来，直接当路径用会得到一个
+ * 永远打不开的名字 —— 版本号读不出来（显示 `unknown`）、asar 路径也匹配不上。
+ * 用 `fileURLToPath` 老实解码（它同时处理盘符与百分号转义）。
+ */
 function safeResolve(specifier) {
     try {
-        return import.meta.resolve(specifier).replace(/^file:\/\/\//, '').replace(/\//g, process.platform === 'win32' ? '\\' : '/');
+        return fileURLToPath(import.meta.resolve(specifier));
     }
     catch {
         try {
@@ -75,21 +102,41 @@ function safeResolve(specifier) {
         }
     }
 }
+/**
+ * Whether a path lives inside an electron `app.asar` archive.
+ *
+ * 桌面版把整个 DSH 装进 `resources/app.asar`：宿主的 `@deepseek-ai/*` 物理上就在
+ * 归档里，插件（装在 `$DSH_HOME/profiles/<name>/node_modules`）在外面的磁盘上。
+ * 归档里的模块**不可能**与外面的目录是同一个物理文件，`@deepseek-ai/*` 又是
+ * peer（官方包由宿主提供），所以「不同路径」是这种打包方式的必然结果，不是安装
+ * 故障。判据取 `.asar` 这个路径段（`join` 出来的分隔符在 Windows 上是 `\`）。
+ */
+function isAsarPath(value) {
+    if (value === null)
+        return false;
+    return /[\\/][^\\/]+\.asar[\\/]/i.test(value);
+}
 /**
  * Resolve a path through every junction/symlink to its physical file.
  * Node loads modules by real path, so two different-looking paths that
  * realpath to one file ARE the same module — which is exactly the property
  * this plugin depends on, and the reason `@deepseek-ai/*` is junctioned into
  * the host installation instead of being copied.
+ *
+ * 取不到真实形态时**不再拿输入去比**（issue #1 要求）：那会把「路径不可解析」
+ * 伪装成「两份不同拷贝」，给出一个编出来的结论。改由调用方把原因报成说明。
  */
-function realPathOf(value) {
+function realPathWithReason(value) {
     if (value === null)
-        return null;
+        return { reason: '路径为空' };
     try {
-        return realpathSync.native !== undefined ? realpathSync.native(value) : realpathSync(value);
+        return { path: realpathSync.native !== undefined ? realpathSync.native(value) : realpathSync(value) };
     }
-    catch {
-        return value;
+    catch (error) {
+        const detail = error;
+        const code = typeof detail.code === 'string' ? detail.code : '';
+        const message = typeof detail.message === 'string' ? detail.message : String(error);
+        return { reason: code === '' ? message : `${code} ${message}` };
     }
 }
 /** Read a package version from a resolvable manifest. */
@@ -114,6 +161,46 @@ function versionOf(specifier) {
     }
     return undefined;
 }
+/**
+ * Version of the package a resolved entry path belongs to: walk up until a
+ * `package.json` whose `name` matches the package directory we came from.
+ *
+ * 与 `versionOf` 的分工：那个从**说明符**出发（要能解析），这个从**已经拿到的路径**
+ * 出发。归档宿主那种「路径不同但版本相同」的判断只能用后者 —— 前者在 `.asar` 里
+ * 读得动，但两边路径不同时它无法回答「这两个文件各属于哪个版本」。
+ */
+function versionOfPackageAt(entry) {
+    const expected = packageNameOfPath(entry);
+    let dir = dirname(entry);
+    for (let i = 0; i < 5; i += 1) {
+        try {
+            const parsed = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+            if (typeof parsed.version === 'string' && (expected === null || parsed.name === expected))
+                return parsed.version;
+        }
+        catch { /* keep walking up */ }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** `.../node_modules/@scope/name/lib/index.js` -> `@scope/name` (null when the path has no such segment). */
+function packageNameOfPath(entry) {
+    const parts = entry.split(/[\\/]/);
+    const at = parts.lastIndexOf('node_modules');
+    if (at === -1 || at + 1 >= parts.length)
+        return null;
+    const first = parts[at + 1];
+    if (first === undefined)
+        return null;
+    if (first.startsWith('@')) {
+        const second = parts[at + 2];
+        return second === undefined ? null : `${first}/${second}`;
+    }
+    return first;
+}
 /**
  * Compare a live member with this plugin's copy of the implementation.
  * `undefined` means "not comparable" — the member is absent on the live object
@@ -761,7 +848,17 @@ export function assessHost(ctx) {
     const sameAsHost = {};
     const blockers = [];
     const unverified = [];
+    const notes = [];
     const hostRoot = hostPackageRoot();
+    const hostIsAsar = isAsarPath(hostRoot);
+    // 桌面版（宿主在 app.asar 里）两组「版本」的容器：插件自己解析到的、宿主锚点解析到的。
+    const asarHostPackages = [];
+    // realpath 失败（路径取不到真实形态）：两侧各算一次就够，与是哪个包无关。
+    const realpathFailures = [];
+    let hostRealpathNote = null;
+    let pluginRealpathNote = null;
+    let asarHostVersion = null;
+    let asarPluginVersion = null;
     for (const name of IDENTITY_PACKAGES) {
         const resolved = safeResolve(name);
         modules[name] = resolved;
@@ -777,23 +874,83 @@ export function assessHost(ctx) {
         }
         // Resolve the same name from the host installation's own anchor, then
         // compare PHYSICAL files: a junction is the same module, not a copy.
+        //
+        // 逐包解析、逐包取真实形态。realpath 的**机制**确实整轮不变，但上一版曾把
+        // 这句话错写成连**解析结果**一起复用：第一个包（cordis）的宿主侧入口路径被当成
+        // 其余五个包的宿主侧路径，于是五条全部比成「与 cordis 不同」→ 假「两份不同拷贝」
+        // （官方桌面版 0.2.0-rc.2 实测，2026-09-30；解析本就便宜，节点自身还有缓存）。
         let hostResolved = null;
+        let hostRealpath = null;
         try {
-            const hostRequire = createRequire(join(dirname(hostRoot), 'package.json'));
-            hostResolved = hostRequire.resolve(name);
+            hostResolved = createRequire(join(dirname(hostRoot), 'package.json')).resolve(name);
+            hostRealpath = realPathWithReason(hostResolved);
         }
         catch {
             hostResolved = null;
         }
-        const same = hostResolved === null ? null : realPathOf(hostResolved) === realPathOf(resolved);
+        // 真实形态取不到 → 这一格是「比不了」，不是「两份拷贝」。理由如实上报，
+        // 绝不把路径问题说成模块问题（issue #1 的次要问题之二）。
+        if (hostRealpath !== null && 'reason' in hostRealpath) {
+            sameAsHost[name] = null;
+            hostRealpathNote = hostRealpathNote ?? hostRealpath.reason;
+            realpathFailures.push({ name, side: 'host', path: hostResolved ?? '(未解析到)', reason: hostRealpath.reason });
+            continue;
+        }
+        const pluginRealpath = realPathWithReason(resolved);
+        if ('reason' in pluginRealpath) {
+            sameAsHost[name] = null;
+            pluginRealpathNote = pluginRealpathNote ?? pluginRealpath.reason;
+            realpathFailures.push({ name, side: 'plugin', path: resolved, reason: pluginRealpath.reason });
+            continue;
+        }
+        const same = hostResolved === null ? null : hostRealpath.path === pluginRealpath.path;
+        // 归档宿主：路径必然不同（归档 vs 磁盘），能比的是版本。相同 → 这一格是
+        // 「比不了（同版本、打包方式不同）」，记进说明并从 unverified 里摘出来（那句
+        // 「宿主的解析锚点里找不到它」对它不成立 —— 锚点找得到，在归档里）；不同 →
+        // 真正的版本错配，`same` 保持 false 照旧进 blockers（那是要修的）。
+        if (same === false && hostIsAsar && !isAsarPath(resolved) && hostResolved !== null) {
+            const hostVersion = versionOfPackageAt(hostResolved);
+            const pluginVersion = versionOfPackageAt(resolved);
+            if (hostVersion !== null && hostVersion === pluginVersion) {
+                asarHostPackages.push({ name, hostPath: hostResolved, pluginPath: resolved });
+                asarHostVersion = asarHostVersion ?? hostVersion;
+                asarPluginVersion = asarPluginVersion ?? pluginVersion;
+                sameAsHost[name] = null;
+                continue;
+            }
+        }
         sameAsHost[name] = same;
-        if (same === false)
-            blockers.push(`${name}：插件与宿主加载的是两份不同拷贝（运行 node scripts/host-deps.mjs --fix）`);
+        if (same === false) {
+            // 指引按**实际形态**给：`scripts/host-deps.mjs` 只存在于源码检出里
+            // （`files` 不含 `scripts/`，npm 安装形态下没有这个文件），
+            // 发布形态照那条指引去跑必然 `MODULE_NOT_FOUND` —— issue #1 的次要问题之一。
+            blockers.push(SOURCE_INSTALL
+                ? `${name}：插件与宿主加载的是两份不同拷贝（在插件源码目录运行 node scripts/host-deps.mjs --fix）`
+                : `${name}：插件与宿主加载的是两份不同拷贝（升级或重装本插件后仍然如此再报）`);
+        }
         // 解析得到、却比不了：宿主锚点里找不到它。不能静默 —— 否则整块身份校验等于没做，
         // 而页头仍报「全部可用」（pnpm 的 .pnpm 隔离目录就是这种情形，见 hostPackageRoot）。
         if (same === null)
             unverified.push(name);
     }
+    if (realpathFailures.length > 0) {
+        notes.push({
+            kind: 'realpath',
+            failures: realpathFailures,
+            ...(hostRealpathNote === null ? {} : { hostReason: hostRealpathNote }),
+            ...(pluginRealpathNote === null ? {} : { pluginReason: pluginRealpathNote }),
+        });
+    }
+    if (asarHostPackages.length > 0 && hostRoot !== null) {
+        notes.push({
+            kind: 'asar-host',
+            asarName: hostRoot.split(/[\\/]/).find((segment) => /\.asar$/i.test(segment)) ?? 'app.asar',
+            hostRoot,
+            hostVersion: asarHostVersion,
+            pluginVersion: asarPluginVersion,
+            packages: asarHostPackages,
+        });
+    }
     // Degraded = something is genuinely unavailable. Optional slots are excluded:
     // their absence selects the adapter route and leaves the feature fully
     // working, so listing them here would tell the user a working feature is
@@ -812,6 +969,7 @@ export function assessHost(ctx) {
             sameAsHost,
             blockers,
             unverified,
+            notes,
         },
         findings,
         degraded,
@@ -841,10 +999,19 @@ function hostPackageRoot() {
     const candidates = [];
     if (home !== '')
         candidates.push(join(home, 'profiles', 'node_modules', '@deepseek-ai'));
+    // 桌面版：整个 DSH 装进 `resources/app.asar`，宿主的 `@deepseek-ai/*` 就在归档里。
+    // 这一候选必须排在 npx 缓存**之前** —— 否则装过 web 版的机器上会先命中 npx 缓存里
+    // 那个 0.1.7，于是拿「另一个安装」当锚点比出 6 条假的「两份不同拷贝」（实测事故）。
+    const asarHost = asarHostPackageRoot();
+    if (asarHost !== null)
+        candidates.push(asarHost);
     for (const anchor of IDENTITY_PACKAGES) {
-        const resolved = realPathOf(safeResolve(anchor));
-        if (resolved === null)
+        // 锚点候选只认**真实形态**：取不到就跳过（这里没有可比的对象，如实跳过即可，
+        // 与身份比对不同 —— 那边取不到必须报出来，见 assessHost 的 realpath 说明）。
+        const real = realPathWithReason(safeResolve(anchor));
+        if ('reason' in real)
             continue;
+        const resolved = real.path;
         let dir = dirname(resolved);
         for (let i = 0; i < 4; i += 1) {
             if (dir.endsWith(join('node_modules', '@deepseek-ai'))) {
@@ -868,6 +1035,27 @@ function hostPackageRoot() {
     }
     return null;
 }
+/**
+ * 正在运行的桌面版 DSH 的 `@deepseek-ai` 目录（在 `resources/app.asar` 里），没有则 null。
+ *
+ * 判据是 `process.resourcesPath`（electron 才有）指向的归档里确实躺着 `dsh` —— 不靠
+ * 包名或环境变量猜，因此在 `dsh web`（node 跑）下一律返回 null。归档内路径由 electron
+ * 自己的 fs 修补解析，归档外的普通 node 读不到，所以这一步失败是静默的正常路径。
+ */
+function asarHostPackageRoot() {
+    const resources = process.resourcesPath;
+    if (typeof resources !== 'string' || resources === '')
+        return null;
+    const dir = join(resources, 'app.asar', 'dsh', 'node_modules', '@deepseek-ai');
+    try {
+        if (!existsSync(join(dir, 'dsh', 'package.json')))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return dir;
+}
 /**
  * npx 缓存里的宿主 `@deepseek-ai` 目录，按目录 mtime 新到旧排。npm 缓存位置依次看
  * `npm_config_cache`、`~/.npmrc` 的 `cache=`、`%LOCALAPPDATA%\npm-cache` —— probe 全程同步，

package/lib/mcp/manager.js

@@ -1493,12 +1493,118 @@ export function createMcpManager(deps) {
         if (!id || (level !== 'global' && level !== 'project'))
             return { ok: false, error: '缺少 id 或 level' };
         const abs = level === 'global' ? p.globalPatch : p.projectPatch;
-        return withWriteLock(async () => {
+        const removedScenes = [];
+        const skippedLockedScenes = [];
+        await withWriteLock(async () => {
+            // serverName 在锁内取：场景档案（mcp / mcpNotes）与两张工具侧车表都按它键，
+            // 补丁条目 id 是另一套；锁外读会和并发写竞态。
+            const known = (await collectAll()).rows.find((r) => r.id === id);
+            const serverName = known ? known.serverName : '';
             let c = await readPatch(abs);
             c = removeEntryAll(c, id);
             await writePatch(abs, c);
-            return { ok: true };
+            // ── 同步清引用（best-effort，口径与 mcpm-edit 的改名同步一致）─────────────
+            // 只删补丁行的话，引用它的档案/侧车全是死键：场景页会显示一台不存在的服务器，
+            // 进/退场景还会去切换一个空条目；界面上则短暂残留宿主 loader 的 include:* 行。
+            if (serverName) {
+                try {
+                    const slice = await memoriesService.readArchiveSlice();
+                    let mode = slice.mode;
+                    // 运行时快照的 mcp 同样按 serverName 键：进场景时引擎按它关停/恢复，
+                    // 死键会在退场景回写时被无害地跳过 —— 但删了就该摘，与改名的 F-025 同口径。
+                    const snapMcp = mode && mode.snapshot && mode.snapshot.mcp;
+                    if (snapMcp && Object.prototype.hasOwnProperty.call(snapMcp, serverName)) {
+                        const rest = Object.assign({}, snapMcp);
+                        delete rest[serverName];
+                        mode = Object.assign({}, mode, { snapshot: Object.assign({}, mode.snapshot, { mcp: rest }) });
+                    }
+                    // 场景档案：被**锁定**的场景档案是用户显式冻结的，跳过并如实上报，
+                    // 不绕开门禁偷偷写；解锁后重新保存一次档案即可清掉死键。
+                    let locks = {};
+                    try {
+                        if (typeof memoriesService.sceneLocks === 'function')
+                            locks = (await memoriesService.sceneLocks()) || {};
+                    }
+                    catch { /* 锁态读不到时按未锁处理，与修复前的行为一致 */ }
+                    const archives = {};
+                    let archivesTouched = false;
+                    for (const [name, archive] of Object.entries(slice.archives || {})) {
+                        const a = archive || {};
+                        const hasMcp = !!(a.mcp && Object.prototype.hasOwnProperty.call(a.mcp, serverName));
+                        const hasNote = !!(a.mcpNotes && Object.prototype.hasOwnProperty.call(a.mcpNotes, serverName));
+                        if (!hasMcp && !hasNote) {
+                            archives[name] = archive;
+                            continue;
+                        }
+                        if (locks[name] === true) {
+                            skippedLockedScenes.push(name);
+                            archives[name] = archive;
+                            continue;
+                        }
+                        const copy = Object.assign({}, a);
+                        if (hasMcp) {
+                            const rest = Object.assign({}, a.mcp);
+                            delete rest[serverName];
+                            copy.mcp = rest;
+                        }
+                        if (hasNote) {
+                            const rest = Object.assign({}, a.mcpNotes);
+                            delete rest[serverName];
+                            // mcpNotes 全空 → null：与档案保存（"全空 = 未定义"）同一口径。
+                            copy.mcpNotes = Object.keys(rest).length ? rest : null;
+                        }
+                        archives[name] = copy;
+                        archivesTouched = true;
+                        removedScenes.push(name);
+                    }
+                    if (archivesTouched || mode !== slice.mode) {
+                        const patch = {};
+                        if (archivesTouched)
+                            patch.archives = archives;
+                        if (mode !== slice.mode)
+                            patch.mode = mode;
+                        await memoriesService.patchIndex(patch);
+                    }
+                }
+                catch { /* 清理失败不拦删除本身；死键无行为影响，与修复前一致 */ }
+                try {
+                    // 停用表与「已知工具」也按 serverName 键：整台没了，键留着只会喂出错的口径
+                    // （补集里多出一台永远凑不上的服务器的旧工具名）。
+                    const toolMap = Object.assign({}, await readDisabledTools(true));
+                    if (Object.prototype.hasOwnProperty.call(toolMap, serverName)) {
+                        delete toolMap[serverName];
+                        await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), toolMap);
+                        disabledToolsCache = { at: Date.now(), value: toolMap };
+                        await applyToolRestrictions();
+                    }
+                    const knownMap = Object.assign({}, await readKnownMcpTools(true));
+                    if (Object.prototype.hasOwnProperty.call(knownMap, serverName)) {
+                        delete knownMap[serverName];
+                        await writeKnownMcpTools(knownMap);
+                    }
+                }
+                catch { /* non-fatal */ }
+                try {
+                    // 备注按 loader id 键：条目删了备注就该走（writeNoteUnderLock 约定在写锁内调用）。
+                    await writeNoteUnderLock(id, '');
+                }
+                catch { /* non-fatal */ }
+            }
         });
+        // 等 loader 把条目摘掉。等待放在**写锁外**（同 mcpm-restart：锁内等待会卡住其他写）。
+        // 宿主清单偶尔停在上一帧，等不到**不算失败** —— 补丁条目确实已经删了，宿主侧收敛有
+        // 自己的节奏；但要说出来，否则用户对着残留的 include:* 行只会以为插件没删干净。
+        const warnings = [];
+        if (pluginInventory) {
+            const gone = await waitFor(async () => (await liveEntry(id)) === null, LOADER_STATE_WAIT_MS, LOADER_STATE_POLL_MS);
+            if (!gone)
+                warnings.push(`宿主 loader 清单未在 ${LOADER_STATE_WAIT_MS / 1000} 秒内摘除该条目，列表可能短暂残留它的行（宿主收敛后自动消失）`);
+        }
+        if (removedScenes.length)
+            warnings.push(`已同步摘掉 ${removedScenes.length} 个场景档案里对它的引用（${removedScenes.join('、')}）`);
+        if (skippedLockedScenes.length)
+            warnings.push(`场景 ${skippedLockedScenes.join('、')} 已锁定，档案里对它的引用保留未动（解锁后重新保存档案即可清掉）`);
+        return warnings.length ? { ok: true, warning: warnings.join('；') } : { ok: true };
     }
     /**
      * 收敛补丁文件里的启停覆盖块（用户显式点「整理补丁」才走这里）。
@@ -1549,9 +1655,11 @@ export function createMcpManager(deps) {
             return { ok: true, removed: total, ids: removed, files };
         });
     }
-    // ---------- 配置体检（0.15.0 B1）--------------------------------------------------
-    // 只读、零副作用：不拉起子进程、不连网、一个字节都不写盘。唯一的对外调用是 `where` /
-    // `which` 查询 PATH —— 它查的是「这个命令名能不能找到」，绝不执行配置里的命令本身。
+    // ---------- 配置体检（0.15.0 B1；0.16.5 起 streamable-http 含端点探测）--------------
+    // 对补丁文件**只读**：不写盘、不拉起子进程。对外调用两处 ——
+    //   · `where` / `which` 查 PATH：只查「这个命令名能不能找到」，绝不执行配置里的命令本身；
+    //   · streamable-http 行对配置地址发一次 GET 连通性探测（带配置的鉴权头、5 秒超时、
+    //     不读响应体 —— 与宿主连接该服务走的是同一地址同一头部，只是更轻）。
     //
     // 为什么单独读补丁而不复用 `mcpmList()`：那个函数顺带回写「已知工具」缓存、还要问一次
     // schema 注册表。体检的承诺是「点了什么都不变」，所以这里只走 readPatch + parseRows。
@@ -1577,6 +1685,53 @@ export function createMcpManager(deps) {
             });
         });
     }
+    /** streamable-http 连通性探测的超时：再长，「全部检查」就会被一台挂掉的服务拖住。 */
+    const INSPECT_PROBE_TIMEOUT_MS = 5000;
+    /** 探测失败的原因短语（进词典模板的 {reason}）：认得出常见错误码就说人话，认不出给原文截断。 */
+    function describeProbeFailure(e) {
+        const err = e;
+        if (err && (err.name === 'TimeoutError' || err.name === 'AbortError')) {
+            return '探测超时（' + Math.round(INSPECT_PROBE_TIMEOUT_MS / 1000) + ' 秒无响应）';
+        }
+        const code = err && err.cause && err.cause.code;
+        if (code === 'ENOTFOUND' || code === 'EAI_AGAIN')
+            return '域名解析失败（' + code + '）';
+        if (code === 'ECONNREFUSED')
+            return '连接被拒绝（' + code + '）';
+        if (code === 'ETIMEDOUT')
+            return '连接超时（' + code + '）';
+        if (code === 'ECONNRESET')
+            return '连接被重置（' + code + '）';
+        if (typeof code === 'string' && /CERT|SSL|TLS/.test(code))
+            return 'TLS 证书校验失败（' + code + '）';
+        const text = String((err && err.cause && err.cause.message) || (err && err.message) || e || '');
+        return text.length > 80 ? text.slice(0, 77) + '…' : text;
+    }
+    /**
+     * streamable-http 的连通性探测：对配置地址 GET 一次，**任何** HTTP 响应（含 404/405）
+     * 都算「可达」—— 探测只回答"这个地址现在连不连得上"，不校验它是不是 MCP 服务。
+     * 不读响应体：streamable-http 对 GET 常回一条 SSE 长连接，拿到状态行就取消。
+     */
+    async function probeHttpEndpoint(url, headers) {
+        const extra = {};
+        if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
+            for (const [k, v] of Object.entries(headers)) {
+                if (typeof v === 'string' && v)
+                    extra[k] = v;
+            }
+        }
+        try {
+            const res = await fetch(url, { method: 'GET', headers: extra, redirect: 'follow', signal: AbortSignal.timeout(INSPECT_PROBE_TIMEOUT_MS) });
+            try {
+                await res.body?.cancel();
+            }
+            catch { /* 取消失败不影响「可达」结论 */ }
+            return { reachable: true };
+        }
+        catch (e) {
+            return { reachable: false, reason: describeProbeFailure(e) };
+        }
+    }
     /** 一行配置 → 检查项。`level: 'warn'` 才点黄；`info` 是「查不了 / 不算问题」那类说明。 */
     async function inspectChecks(row, duplicateIds) {
         const checks = [];
@@ -1621,6 +1776,13 @@ export function createMcpManager(deps) {
                 checks.push({ id: 'noUrl', level: 'warn' });
             else if (!/^https?:\/\//.test(url))
                 checks.push({ id: 'badUrl', level: 'warn', params: { url } });
+            else {
+                // 格式对了再做一次真实探测（0.16.5）：此前的体检止步于格式校验，一条编造的
+                // 地址也能拿绿点 —— 绿点承诺的「没发现问题」其实只覆盖了一半（2026-09-29 实测）。
+                const probe = await probeHttpEndpoint(url, row.headers);
+                if (!probe.reachable)
+                    checks.push({ id: 'httpUnreachable', level: 'warn', params: { url, reason: probe.reason } });
+            }
             const badHeaders = badKv(row.headers);
             if (badHeaders.length)
                 checks.push({ id: 'kvNotString', level: 'warn', params: { where: 'headers', keys: badHeaders.join('、') } });
@@ -1664,15 +1826,16 @@ export function createMcpManager(deps) {
         }
         const onlyId = args && String(args.id || '') ? String(args.id) : '';
         const onlyLevel = args && String(args.level || '') ? String(args.level) : '';
-        const results = [];
-        for (const r of rows) {
-            if (onlyId && String(r.id) !== onlyId)
-                continue;
-            if (onlyLevel && String(r.level) !== onlyLevel)
-                continue;
-            const checks = await inspectChecks(r, (idsByName[String(r.serverName || '')] || new Set()).size);
-            results.push({ id: r.id, serverName: r.serverName, level: r.level, transport: r.transport || null, checks });
-        }
+        // 逐行检查并行跑：体检含 streamable-http 的端点探测（每次至多 5 秒超时），串行会让
+        // 「全部检查」在多台同时连不上时按行数翻倍地慢。Promise.all 保序，与旧实现一致。
+        const targets = rows.filter((r) => (!onlyId || String(r.id) === onlyId) && (!onlyLevel || String(r.level) === onlyLevel));
+        const results = await Promise.all(targets.map(async (r) => ({
+            id: r.id,
+            serverName: r.serverName,
+            level: r.level,
+            transport: r.transport || null,
+            checks: await inspectChecks(r, (idsByName[String(r.serverName || '')] || new Set()).size),
+        })));
         return { ok: true, results, errors };
     }
     async function mcpmExport() {

package/lib/memories/service.js

@@ -696,6 +696,15 @@ export function createMemoriesService(ctx, deps) {
         refresh,
         patchIndex,
         readArchiveSlice,
+        sceneLocks: async () => {
+            const index = await readIndex(stateDir);
+            const out = {};
+            for (const [name, rec] of Object.entries(index.scenes || {})) {
+                if (rec && rec.locked === true)
+                    out[name] = true;
+            }
+            return out;
+        },
     };
     return service;
 }

package/lib/ops/compat.js

@@ -6,7 +6,7 @@
 //
 // 边界纪律：本文件只负责「op 的实现」，不负责 ops 表之外的接线（MCP 写后刷新、场景锁定
 // 守卫仍作用在组装后的整张表上，见 index.ts）。
-import { EXPECTED_MIN_HOST_VERSION, EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, routeFor, summarize, } from '../compat/probe.js';
+import { EXPECTED_MIN_HOST_VERSION, EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, isSourceInstall, routeFor, summarize, } from '../compat/probe.js';
 import { INJECT_DOMAIN_KEYS } from '../context-inject.js';
 import { assessPresetReach } from '../compat/preset-reach.js';
 import { runtimeNotes } from '../compat/runtime-notes.js';
@@ -64,6 +64,13 @@ export function buildCompatOps(deps) {
                     host: { version: assessment.identity.version, modules: assessment.identity.modules },
                     sameAsHost: assessment.identity.sameAsHost,
                     unverified: assessment.identity.unverified,
+                    // 身份校验的说明：不是阻塞项，界面据此解释那一排「无法比较」，而不是留给
+                    // 用户一句「两份拷贝，去 --fix」。两种来源 —— 宿主在 app.asar 里（桌面版）、
+                    // 路径取不到真实形态（realpath 失败，issue #1）。
+                    notes: assessment.identity.notes,
+                    // 修复指引按实际形态给：`scripts/` 不在 `files` 里，npm 安装形态下没有
+                    // `scripts/doctor.mjs` 与 `scripts/host-deps.mjs`，指了也跑不了。
+                    sourceInstall: isSourceInstall(),
                     findings,
                     degraded,
                     blockers: assessment.identity.blockers,
@@ -258,13 +265,22 @@ export function buildCompatOps(deps) {
                 // 身份 / 版本：与 compat-status 同一份数据。
                 const identity = assessment?.identity;
                 const identityIssue = identity !== undefined && (identity.blockers.length > 0 || Object.values(identity.sameAsHost).some((same) => same === false));
+                // 归档宿主（桌面版）：不是阻塞项，但"模块与宿主同源"这句话对它不成立（同版本、
+                // 不同文件），所以总览那一行要换句话讲，而不是继续报一句善意的假话。
+                const asarHost = identity?.notes.find((note) => note.kind === 'asar-host');
                 push({
                     key: 'host-identity', label: '宿主身份与模块', tab: 'compat',
                     state: assessment === undefined ? 'unknown' : identityIssue ? 'degraded' : 'ok',
                     detail: assessment === undefined ? '能力探测不可用（归档服务未挂载）'
                         : identityIssue ? '存在阻塞项：' + (identity?.blockers ?? []).join('；')
-                            : `模块与宿主同源（宿主 DSH ${identity?.version ?? '?'}）`,
-                    ...(assessment === undefined ? {} : { version: identity?.version ?? '?', blockers: identity?.blockers ?? [] }),
+                            : asarHost !== undefined
+                                ? `官方包与宿主同版本，但宿主跑在 ${asarHost.asarName} 里（插件在归档外）`
+                                : `模块与宿主同源（宿主 DSH ${identity?.version ?? '?'}）`,
+                    ...(assessment === undefined ? {} : {
+                        version: identity?.version ?? '?',
+                        blockers: identity?.blockers ?? [],
+                        ...(asarHost === undefined ? {} : { asarHost: true, asarName: asarHost.asarName }),
+                    }),
                 });
                 // 无独立装配点的域：没有上报就是正常（如实说明依据是"没有降级上报"）。
                 for (const [key, label, tab] of [['memory', '记忆', 'memory'], ['prompts', '提示词', 'prompts'], ['subagents', '子智能体', 'subagents'], ['scenes', '场景档案', 'scenes']]) {