dsh-plugin-tool-management 0.10.0 → 0.12.0

package/lib/compat/patch-dialect.js

@@ -0,0 +1,173 @@
+// 官方补丁方言（`cordis.patch.yml`）的**只读复刻** —— 写入宿主配置前的最后一道校验。
+//
+// 为什么需要它：本插件 19 个调用面都在**文本级**改宿主的补丁文件（插块 / 删块 / 换行），
+// 而官方解析这份文件用的是 js-yaml + 自定义 `!!js` 标签（`dsh-app-boot/lib/index.js:17-31`），
+// 并且把「顶层必须是数组」「每项必须是映射」写成显式断言（同文件 `parsePatchList`，:1196-1200）。
+// 解析失败 = DSH **下次启动直接起不来**（`CHANGELOG.md` 里记过这次事故）。三条写入路径
+// （`profiles/<名>/cordis.patch.yml`、`~/.dsh/cordis.patch.yml`、bundle 的 `cordis.patch.yml`）
+// 走的是同一份方言（前者 `loadOverlayPatches`、后者 `loadOptionalPatches` → `parsePatchList`；
+// `userPatchesSchema === entryListSchema`，实测于 dsh-app-boot 0.1.5-rc.2）。
+//
+// 官方**没有**导出这份 schema（导出清单见同文件 :1575，无 `entryListSchema`），所以只能复刻。
+// 复刻**必然会过期**（官方加方言 / 换 js-yaml 大版本），因此判定策略是**非对称**的：
+//   · 改前能解析、改后被我们改成不能解析 → 是我们的改动弄坏了它 → 拒绝写入（原文件与备份不动）；
+//   · 改前本来就解析不过 → 说明复刻过期，不是我们的错 → 照写 + 上报，绝不拦；
+//   · 依赖（js-yaml）不在 → 跳过校验 + 上报。
+// 一律拒绝会把「校验器过期」变成「MCP 写路径整体停摆」（含重启恢复写，见 request-gate.ts
+// 里那处「恢复写失败会把服务器永久留在停用态」），那是拿能力换保守。
+//
+// `judgePatchText` / `decidePatchWrite` 是纯函数，契约测试直接钉上面几条分支；IO 只有
+// `checkPatchWrite` 一处，它同时把结论记进运行时上报通道（兼容页据此出一行）与回执队列。
+import { clearRuntimeNote, noteRuntime } from './runtime-notes.js';
+/** 官方 `.js` 标签名（逐字取自 dsh-app-boot/lib/index.js:17）。 */
+const JS_EXPR_TAG = 'tag:yaml.org,2002:js';
+/** 官方 `isJsExpr`（cordis-plugin-loader/lib/index.js:302-304）的等价物。 */
+const isJsExpr = (value) => value instanceof Object && '__jsExpr' in value;
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// 同一份 yaml 模块只 extend 一次（官方是在模块顶层 extend 一次的等价位）。
+const schemas = new WeakMap();
+function schemaOf(yaml) {
+    const cached = schemas.get(yaml);
+    if (cached !== undefined)
+        return cached;
+    // 与官方逐字等价的选项对象（dsh-app-boot/lib/index.js:17-23）：load 只用到 resolve /
+    // construct；predicate / represent 属于 dump 方向，复刻它们是让这份定义与官方对齐。
+    const exprType = new yaml.Type(JS_EXPR_TAG, {
+        kind: 'scalar',
+        resolve: (data) => typeof data === 'string',
+        construct: (data) => ({ __jsExpr: data }),
+        predicate: isJsExpr,
+        represent: (data) => data.__jsExpr,
+    });
+    const schema = yaml.JSON_SCHEMA.extend(exprType);
+    schemas.set(yaml, schema);
+    return schema;
+}
+/**
+ * 判一份补丁文本官方解析得动吗（纯函数：不碰 IO、不记状态）。
+ *
+ * @param yaml - 注入的 yaml 模块（测试可传真模块；运行时是惰性 import 来的那份）。
+ * @param content - 补丁文件全文。
+ * @returns 判定结果；`unparseable` 的 detail 带官方会抛的那句错，直接可展示。
+ */
+export function judgePatchText(yaml, content) {
+    let parsed;
+    try {
+        parsed = yaml.load(content, { schema: schemaOf(yaml) });
+    }
+    catch (error) {
+        return { status: 'unparseable', detail: messageOf(error) };
+    }
+    // 官方 parsePatchList 的两条显式断言：顶层数组（:1199）、每项是映射（:1200）。
+    // 空文件（含只有空白的文件）在这里是 undefined → 判「解析不过」—— 与官方一致：
+    // 文件**不存在**官方容忍（`ENOENT` → 没有这一层），文件**在但空**官方是抛错的。
+    if (!Array.isArray(parsed)) {
+        return { status: 'unparseable', detail: '顶层不是 YAML 数组（官方 parsePatchList 的显式断言）' };
+    }
+    const bad = parsed.findIndex((entry) => typeof entry !== 'object' || entry === null || Array.isArray(entry));
+    if (bad >= 0) {
+        return { status: 'unparseable', detail: `第 ${bad + 1} 项不是映射（官方 parsePatchList 的显式断言）` };
+    }
+    return { status: 'ok' };
+}
+/**
+ * 非对称策略本体（纯函数）。三个分支就是本模块存在的理由，契约测试逐个钉住。
+ *
+ * @param before - 改前内容的判定；`null` 表示**没有可用基线**（文件不存在或读不到内容）。
+ * @param after - 本次要写入内容的判定。
+ * @returns 是否放行 + 要不要上报 + 拒绝时的说明。
+ */
+export function decidePatchWrite(before, after) {
+    if (after.status === 'ok')
+        return { allow: true, report: null };
+    if (after.status === 'no-dep')
+        return { allow: true, report: { kind: 'no-dep', detail: after.detail } };
+    // 改后解析不过：只有「本来就没有基线」或「改前是好的」才拦 —— 这两种都是我们引入的坏内容。
+    if (before !== null && before.status === 'unparseable') {
+        return {
+            allow: true,
+            report: {
+                kind: 'replica-outdated',
+                detail: `改前内容本来就解析不过（${before.detail}），本次写入按「复刻过期」放行`,
+            },
+        };
+    }
+    return {
+        allow: false,
+        report: null,
+        error: `写入被拒绝：新内容不是合法的补丁列表（${after.detail}）。官方解析器会因此让 DSH 起不来，`
+            + '已保留原文件与备份。',
+    };
+}
+// ---------- 运行时依赖：惰性加载 + 结果缓存（`undefined` 未试过 / `null` 加载不到） ----------
+let dialect;
+let depError = '';
+async function loadDialect() {
+    if (dialect !== undefined)
+        return dialect;
+    try {
+        // 与宿主实装同一份 js-yaml（本机实测 4.3.2）。只在写补丁时加载：插件加载期不碰它，
+        // 装不上也绝不因此让插件挂掉。
+        dialect = (await import('js-yaml'));
+    }
+    catch (error) {
+        dialect = null;
+        depError = messageOf(error);
+    }
+    return dialect;
+}
+// ---------- 状态：兼容页那一行（走运行时上报通道）+ 写入回执的 warning（消费式） ----------
+/** 回执队列状态：`pendingWarnings` 只在「本次请求的写入没做成交验」时有货。 */
+const pendingWarnings = [];
+// 正常情况下每请求都会被取空；上限只是防止某个不取回的调用路径把它撑大。
+const WARN_QUEUE_MAX = 8;
+function record(report) {
+    if (report === null) {
+        clearRuntimeNote('patch-write-guard');
+        return;
+    }
+    noteRuntime({
+        id: 'patch-write-guard',
+        label: '补丁写入校验',
+        kind: 'write',
+        fallback: 'inform-only',
+        detail: (report.kind === 'no-dep' ? '校验依赖不可用' : '复刻可能已过期')
+            + `：${report.detail}（写入照常进行，仅少一道「把启动配置写坏」的拦截）`,
+    });
+    pendingWarnings.push(report.kind === 'no-dep'
+        ? '补丁写入未做解析校验（依赖不可用）：' + report.detail
+        : '补丁写入的解析校验放行（可能是复刻过期）：' + report.detail);
+    if (pendingWarnings.length > WARN_QUEUE_MAX)
+        pendingWarnings.splice(0, pendingWarnings.length - WARN_QUEUE_MAX);
+}
+/**
+ * 写入前的完整判定（唯一一处 IO/依赖入口）。
+ *
+ * 判完把结论记进 note / 回执队列：兼容页据此出「补丁校验不可用」一行，写入回执据此带 warning。
+ *
+ * @param previous - 改前全文（`''` 视为没有基线：文件不存在，或读不到内容）。
+ * @param next - 本次要写入的全文。
+ * @returns 判定；`allow=false` 时调用方必须中止写入。
+ */
+export async function checkPatchWrite(previous, next) {
+    const yaml = await loadDialect();
+    if (yaml === null) {
+        const decision = {
+            allow: true,
+            report: { kind: 'no-dep', detail: `无法加载 js-yaml：${depError}` },
+        };
+        record(decision.report);
+        return decision;
+    }
+    const before = previous === '' ? null : judgePatchText(yaml, previous);
+    const after = judgePatchText(yaml, next);
+    const decision = decidePatchWrite(before, after);
+    record(decision.report);
+    return decision;
+}
+/** 写入回执取用：取走并清空本次累积的 warning（每次请求取一次）。 */
+export function takePatchGuardWarnings() {
+    return pendingWarnings.splice(0, pendingWarnings.length);
+}

package/lib/compat/preset-reach.js

@@ -56,6 +56,7 @@
  * exactly what its author asked for; the plugin's job is to say so out loud and
  * point at the switch that overrides it.
  */
+import { MCP_CLIENT_MODULE } from '../host-names.js';
 /** Whether a preset declares "no extra text": persona `complete: true` or runtime context off. */
 export function isSuppressingPreset(facts) {
     return facts.personaComplete === true || facts.includeRuntimeContext === false;
@@ -74,16 +75,6 @@ export function injectionFactsOf(facts) {
 const PERSONA_MODULE = '@deepseek-ai/dsh-persona';
 const AGENT_INSTRUCTIONS_MODULE = '@deepseek-ai/dsh-agent-instructions';
 const TOOL_SKILL_MODULE = '@deepseek-ai/dsh-tool-skill';
-/**
- * An MCP client mounted INSIDE a composition. The shipped presets mount none,
- * so MCP tools normally come from the host plane (the `$DSH_HOME/cordis.patch.yml`
- * layer) and are callable under every preset; a user-authored preset that mounts
- * its own client only carries those tools under itself, and this scan is how the
- * page can tell the two apart. Tool reachability is not the column's answer,
- * though — the server list and the user's notes are a prompt section, which a
- * complete persona suppresses whichever client serves the tools.
- */
-const MCP_CLIENT_MODULE = '@deepseek-ai/dsh-mcp-client';
 const NAME_LINE = /^(\s*)name:\s*(['"]?)([^'"\s#]+)\2\s*(?:#.*)?$/;
 const ENTRY_LINE = /^(\s*)-\s/;
 const DISABLED_LINE = /^\s*disabled:\s*(.+?)\s*(?:#.*)?$/;

package/lib/compat/probe.js

@@ -4,7 +4,7 @@
  *
  * WHY THIS REPLACES THE TEXT-COMPARISON GATE
  * ------------------------------------------
- * The previous gate in `history/bridge.js` compared each host method against
+ * The previous gate in `sessions/bridge.ts` compared each host method against
  * this plugin's own copy of the official prototype with
  * `Function.prototype.toString()`. That only ever answered one question —
  * "is the host running the same release I was written against?" — and it
@@ -30,7 +30,7 @@
  * leave the rest working.
  */
 import { createRequire } from 'node:module';
-import { readFileSync, realpathSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 /** Packages whose physical module identity matters to this plugin. */
 export const IDENTITY_PACKAGES = [
@@ -139,22 +139,88 @@ function prototypeOf(instance) {
     const proto = Object.getPrototypeOf(instance);
     return proto !== null && typeof proto === 'object' ? proto : undefined;
 }
-/** Official prototypes this plugin's adapters mirror, when importable. */
-function referencePrototypes() {
-    const out = {};
+// The official package + class each capability owner's members live on. This is
+// the single answer to "which class defines this owner" — both the live
+// reference-prototype lookup below and the exported static table read it, so a
+// host drift is described in exactly one place.
+const WORKSPACE_CLASS = { pkg: '@deepseek-ai/dsh-workspace', target: 'WorkspaceRegistry' };
+const PROJECTION_CLASS = { pkg: '@deepseek-ai/dsh-session-projection-cache', target: 'SessionProjectionCache' };
+// `sessions.*` members are host-private members, but they are still declared on
+// an official class: `@deepseek-ai/dsh-session` is a peer this plugin declares,
+// and `SessionStore` is where `flush`/`liveEntryFor`/`detachEntered`/`enter`/
+// `announce` live. Without this entry the doctor could not see the two
+// capabilities the delete route depends on.
+const SESSIONS_CLASS = { pkg: '@deepseek-ai/dsh-session', target: 'SessionStore' };
+const OWNER_CLASSES = {
+    workspace: WORKSPACE_CLASS,
+    projectionCache: PROJECTION_CLASS,
+    sessions: SESSIONS_CLASS,
+};
+/** The named export's prototype, or undefined when the package is absent/trimmed. */
+function classPrototypeOf(ref) {
     try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const ws = createRequire(import.meta.url)('@deepseek-ai/dsh-workspace');
-        if (ws.WorkspaceRegistry?.prototype !== undefined)
-            out.workspace = ws.WorkspaceRegistry.prototype;
+        const mod = createRequire(import.meta.url)(ref.pkg);
+        const klass = mod[ref.target];
+        return klass?.prototype;
     }
-    catch { /* optional in tests and in trimmed deployments */ }
+    catch {
+        return undefined; // optional in tests and in trimmed deployments
+    }
+}
+/**
+ * 哨兵值：不可能命中任何真实会话/工作区（会话 id 由宿主生成，不含此串）。
+ * 行为探针真调宿主方法时一律传它 —— 最坏情形是宿主受控拒绝（not found），
+ * 而「哨兵输入都能产生意外效果」本身就是要探出来的「不该路由信任」。
+ */
+const PROBE_SENTINEL = '__dshm_probe_never_exists__';
+/**
+ * 用哨兵实参**真调**一个宿主方法（2026-09-19 分层探针第二层），验证「存在且可调用」：
+ * - 同步抛 `TypeError` → 实现坏了/签名漂移，返回失败详情（shape-mismatch）；
+ * - 受控同步拒绝（普通 `Error`，如 not found）或返回值（含 rejected Promise）→ 通过。
+ *
+ * 只判同步段：探针框架是同步的（`assessHost` 不能 await），异步结果分类留待
+ * 异步化改造（见审查 07 跟进项）。返回的 Promise 一律挂 `.catch` 吞掉，探针
+ * 不制造 unhandled rejection。调用必须以 `target` 为 receiver —— 私有方法全靠
+ * `this.*` 拿内部状态，脱离 receiver 调用会把好实现误判成 TypeError。
+ *
+ * 副作用口径（按官方源码逐个核过）：liveEntryFor/announce/flush 哨兵输入在
+ * 查表处受控抛错，零副作用；detachEntered 传普通对象在未知 id 处早退；
+ * deleteSession/archiveSession 等原生入口对未知 id 是读路径校验后受控拒绝。
+ * `enter` 不在此列（会往 store 里写哨兵条目），它只做存在性 + 文本比对。
+ */
+function callableWithSentinel(target, name, ...args) {
     try {
-        const pc = createRequire(import.meta.url)('@deepseek-ai/dsh-session-projection-cache');
-        if (pc.SessionProjectionCache?.prototype !== undefined)
-            out.cache = pc.SessionProjectionCache.prototype;
+        const method = target[name];
+        if (!isFn(method))
+            return `${name} 不是函数（methods 检查应已拦下，此处兜底）`;
+        const returned = method.call(target, ...args);
+        if (returned !== null && typeof returned === 'object' && isFn(returned.then)) {
+            const settled = returned;
+            if (isFn(settled.catch))
+                settled.catch(() => { });
+        }
+        return undefined;
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return `${name} 哨兵真调抛 TypeError：${String(error?.message ?? error)}`;
+        return undefined;
     }
-    catch { /* optional in tests */ }
+}
+/** Official prototypes this plugin's adapters mirror, when importable. */
+function referencePrototypes() {
+    const out = {};
+    const workspace = classPrototypeOf(WORKSPACE_CLASS);
+    if (workspace !== undefined)
+        out.workspace = workspace;
+    const cache = classPrototypeOf(PROJECTION_CLASS);
+    if (cache !== undefined)
+        out.cache = cache;
+    // sessions 的五个私有方法全声明在官方 SessionStore.prototype 上（本插件 peer 依赖
+    // 同包同版本），与 workspace/cache 同机制接入文本比对 —— 此前该域只有存在性检查。
+    const sessions = classPrototypeOf(SESSIONS_CLASS);
+    if (sessions !== undefined)
+        out.sessions = sessions;
     return out;
 }
 /**
@@ -170,7 +236,7 @@ const CAPABILITY_SPECS = [
         label: '读取工作区状态',
         kind: 'read',
         owner: 'workspace',
-        fallback: 'degrade-read',
+        fallback: 'refuse-operation',
         methods: ['requireState'],
         probe: (t) => {
             try {
@@ -194,7 +260,7 @@ const CAPABILITY_SPECS = [
         label: '读取工作区表',
         kind: 'read',
         owner: 'workspace',
-        fallback: 'degrade-read',
+        fallback: 'refuse-operation',
         methods: ['requireTable'],
         probe: (t) => {
             try {
@@ -213,7 +279,7 @@ const CAPABILITY_SPECS = [
         label: '工作区索引结构',
         kind: 'read',
         owner: 'workspace',
-        fallback: 'degrade-read',
+        fallback: 'refuse-operation',
         fields: [
             { name: 'headers', instanceOf: 'Map' },
             { name: 'sessionPaths', instanceOf: 'Map' },
@@ -226,7 +292,7 @@ const CAPABILITY_SPECS = [
         label: '读取会话头部',
         kind: 'read',
         owner: 'workspace',
-        fallback: 'degrade-read',
+        fallback: 'refuse-operation',
         methods: ['readSessionHeader'],
     },
     // ---- workspace registry: write side ------------------------------------
@@ -262,6 +328,9 @@ const CAPABILITY_SPECS = [
         fallback: 'native-entry',
         methods: ['archiveSession'],
         optional: true,
+        // 分层探针第二层（哨兵真调）：官方实现对未知 id 走读路径校验后受控拒绝
+        //（WorkspaceUnknownSessionError）；同步 TypeError 才是「不该路由信任」的信号。
+        probe: (t) => callableWithSentinel(t, 'archiveSession', PROBE_SENTINEL),
     },
     {
         id: 'workspace.unarchive-native',
@@ -271,6 +340,7 @@ const CAPABILITY_SPECS = [
         fallback: 'native-entry',
         methods: ['unarchiveSession'],
         optional: true,
+        probe: (t) => callableWithSentinel(t, 'unarchiveSession', PROBE_SENTINEL),
     },
     {
         id: 'workspace.batch-native',
@@ -280,6 +350,7 @@ const CAPABILITY_SPECS = [
         fallback: 'native-entry',
         methods: ['archiveWorkspaceSessions'],
         optional: true,
+        probe: (t) => callableWithSentinel(t, 'archiveWorkspaceSessions', [PROBE_SENTINEL]),
     },
     {
         id: 'workspace.delete-native',
@@ -292,6 +363,10 @@ const CAPABILITY_SPECS = [
         fallback: 'native-entry',
         methods: ['deleteSession'],
         optional: true,
+        // 删除路由的 native 判定此前只看方法存在（07 审查五档问题 2）：宿主升级把同名
+        // 方法换成别的签名，路由仍会走 native 裸调。哨兵真调把口径提到「可调用」，
+        // 文本比对收紧（见 inspectCapability 的 delete 类分支）负责「实现漂移」那一层。
+        probe: (t) => callableWithSentinel(t, 'deleteSession', PROBE_SENTINEL),
     },
     // ---- sessions runtime (private members, used only on the live branch) ---
     {
@@ -301,6 +376,11 @@ const CAPABILITY_SPECS = [
         owner: 'sessions',
         fallback: 'disable-destructive',
         methods: ['flush', 'liveEntryFor', 'detachEntered'],
+        // 零副作用真调（按官方源码核对）：liveEntryFor/flush 对哨兵在查表处受控抛错；
+        // detachEntered 传普通对象在未知 id 处早退（entry 形状 {id} 即可）。
+        probe: (t) => callableWithSentinel(t, 'liveEntryFor', PROBE_SENTINEL)
+            ?? callableWithSentinel(t, 'flush', PROBE_SENTINEL)
+            ?? callableWithSentinel(t, 'detachEntered', { id: PROBE_SENTINEL }),
     },
     {
         id: 'sessions.cold-announce',
@@ -309,6 +389,9 @@ const CAPABILITY_SPECS = [
         owner: 'sessions',
         fallback: 'disable-destructive',
         methods: ['enter', 'announce'],
+        // announce 哨兵真调：内部先 liveEntryFor 查表，哨兵输入在查表处受控抛错。
+        // **enter 不真调**（官方实现对任意输入都会往 store 写入条目），它只有存在性 + 文本比对。
+        probe: (t) => callableWithSentinel(t, 'announce', PROBE_SENTINEL),
     },
     // ---- projection cache ---------------------------------------------------
     {
@@ -319,12 +402,37 @@ const CAPABILITY_SPECS = [
         fallback: 'disable-destructive',
         methods: ['write', 'put', 'requireTable'],
     },
+    {
+        // B2：此前它只是 bridge 运行时那句拒绝里的**临时 id**（`acquireCacheGuard` 里现场拼的），
+        // 于是客户端压根不知道它 —— 宿主表不可删时，"路由说可用、点下去必拒"（V13）。提升为
+        // 能力表的正式条目后，路由判定与运行时前提同一份依据。
+        id: 'projection.table-delete',
+        label: '投影缓存行删除',
+        kind: 'delete',
+        owner: 'projectionCache',
+        fallback: 'disable-destructive',
+        // 探测内容就是运行时那句硬前提：`requireTable().delete` 在不在。
+        probe: (target) => {
+            if (typeof target?.requireTable !== 'function')
+                return '宿主投影缓存缺少 requireTable';
+            let table;
+            try {
+                table = target.requireTable();
+            }
+            catch (error) {
+                return `宿主投影缓存 requireTable() 抛错：${String(error)}`;
+            }
+            if (typeof table?.delete !== 'function')
+                return '宿主投影缓存存储不支持安全删除（table.delete 缺失）';
+            return undefined;
+        },
+    },
     {
         id: 'projection.delete-native',
         label: '投影缓存删除屏障',
         kind: 'delete',
         owner: 'projectionCache',
-        // Absent on rc.2: `history/bridge.js` installs a checked write barrier
+        // Absent on rc.2: `sessions/bridge.ts` installs a checked write barrier
         // instead, so absence is a routing fact, not a failure. Only a cache whose
         // write path cannot be wrapped at all is a real problem.
         fallback: 'native-entry',
@@ -365,13 +473,17 @@ export const OPERATION_ROUTES = {
         native: ['workspace.delete-native'],
         // NOTE: `projection.delete-native` is deliberately NOT a route requirement.
         // A host cache without its own delete barrier is expected on rc.2; the
-        // bridge wraps it (`workspace.js` / `history/bridge.js`) and reports a
+        // bridge wraps it (`workspace.js` / `sessions/bridge.ts`) and reports a
         // refusal itself when even that is impossible. Requiring the native barrier
         // here would disable deletion on exactly the host this plugin was verified
         // against.
         adapter: [
             'workspace.enqueue', 'workspace.set-state', 'workspace.index-header',
             'sessions.detach-live', 'sessions.cold-announce', 'projection.write',
+            // B2：运行时硬前提（`table.delete`）也算一条路由要求 —— 不算进来的话，宿主表不可删时
+            // 路由说可用、点下去必拒。batch 的 adapter 路由**有意**保持只有 enqueue/set-state：
+            // 它的逐条失败会在结果里按 sessionId 报出来，此处不放宽也不收紧。
+            'projection.table-delete',
         ],
     },
     list: { native: [], adapter: ['workspace.read-state', 'workspace.read-table', 'workspace.index-shape'] },
@@ -437,6 +549,21 @@ function inspectCapability(spec, target, reference) {
             return { ...base, state: 'shape-mismatch', detail: failure, missing: [], ...(textMatch === undefined ? {} : { textMatch }) };
         }
     }
+    // 删除类收紧（2026-09-19，07 审查五档问题 2）：textMatch === false 意味着宿主运行的
+    // 不是本插件适配并验证过的实现（参考副本与宿主同源时恒真 —— junction 同物理文件；
+    // 只有宿主升级/漂移才会 false）。读/写类维持「按能力使用」的宽口径，但删除不可逆：
+    // 漂移的 flush/detachEntered/announce/deleteSession 一律不盲调，路由降级 adapter 或
+    // 拒绝，恢复文案引导更新插件。bridge.js 曾因无害重构误报而移除过文本比对 —— 本次
+    // 只收紧 delete 类，且参考副本不可解析时 textMatch 为 undefined，不拦截（优雅回退）。
+    if (textMatch === false && spec.kind === 'delete') {
+        return {
+            ...base,
+            state: 'shape-mismatch',
+            detail: '成员齐备但实现文本与本插件适配的版本不同：删除类能力不盲调漂移实现',
+            missing: [],
+            textMatch,
+        };
+    }
     return {
         ...base,
         state: 'ok',
@@ -458,6 +585,31 @@ function inspectCapability(spec, target, reference) {
 export const SUBSTITUTED_CAPABILITIES = CAPABILITY_SPECS
     .filter((spec) => spec.optional === true)
     .map((spec) => spec.id);
+/**
+ * The capability table as a *static* view: for each spec, the official class
+ * whose prototype must carry the required members. This exists so a CLI without
+ * a running host (the doctor) can still answer "can this build archive / delete /
+ * list?".
+ *
+ * Derived from {@link CAPABILITY_SPECS} — the previous hand-written second table
+ * drifted silently: it carried 9 of the 15 ids and missed every `sessions.*` and
+ * native-slot capability the routing actually needs.
+ */
+export const CAPABILITY_STATIC = CAPABILITY_SPECS.map((spec) => {
+    const ref = OWNER_CLASSES[spec.owner];
+    const methods = spec.methods;
+    return {
+        id: spec.id,
+        label: spec.label,
+        kind: spec.kind,
+        optional: spec.optional === true,
+        // A `fields`-only spec (instance Maps) and a spec whose judgement lives in
+        // its `probe` have nothing a prototype can answer — they stay runtime-only.
+        check: ref !== undefined && methods !== undefined && methods.length > 0
+            ? { pkg: ref.pkg, target: ref.target, members: methods }
+            : null,
+    };
+});
 /**
  * Inspect the live host behind one plugin context.
  *
@@ -478,6 +630,9 @@ export function assessHost(ctx) {
         }
     };
     // Cordis exposes traceable proxies; compare and inspect the original objects.
+    // `Symbol.for('cordis.original')` 与 cordis 导出的 `symbols.original` 是**同一个符号**
+    // （该包内即 `original: Symbol.for("cordis.original")`）。这里不 import cordis，是为了让
+    // 兼容探测在宿主包加载失败时仍能工作 —— 本文件对宿主零硬依赖（见文件头的 createRequire）。
     const unwrap = (value) => {
         if (value === null || typeof value !== 'object')
             return value;
@@ -496,7 +651,7 @@ export function assessHost(ctx) {
     const targets = {
         workspace: { target: registry, reference: references.workspace },
         projectionCache: { target: cache, reference: references.cache },
-        sessions: { target: sessions, reference: undefined },
+        sessions: { target: sessions, reference: references.sessions },
         persistence: { target: unwrap(get('sessionPersistence')), reference: undefined },
     };
     const findings = CAPABILITY_SPECS.map((spec) => {
@@ -507,6 +662,7 @@ export function assessHost(ctx) {
     const modules = {};
     const sameAsHost = {};
     const blockers = [];
+    const unverified = [];
     const hostRoot = hostPackageRoot();
     for (const name of IDENTITY_PACKAGES) {
         const resolved = safeResolve(name);
@@ -518,6 +674,7 @@ export function assessHost(ctx) {
         }
         if (hostRoot === null) {
             sameAsHost[name] = null;
+            unverified.push(name);
             continue;
         }
         // Resolve the same name from the host installation's own anchor, then
@@ -534,6 +691,10 @@ export function assessHost(ctx) {
         sameAsHost[name] = same;
         if (same === false)
             blockers.push(`${name}：插件与宿主加载的是两份不同拷贝（运行 node scripts/host-deps.mjs --fix）`);
+        // 解析得到、却比不了：宿主锚点里找不到它。不能静默 —— 否则整块身份校验等于没做，
+        // 而页头仍报「全部可用」（pnpm 的 .pnpm 隔离目录就是这种情形，见 hostPackageRoot）。
+        if (same === null)
+            unverified.push(name);
     }
     // Degraded = something is genuinely unavailable. Optional slots are excluded:
     // their absence selects the adapter route and leaves the feature fully
@@ -552,6 +713,7 @@ export function assessHost(ctx) {
             modules,
             sameAsHost,
             blockers,
+            unverified,
         },
         findings,
         degraded,
@@ -566,22 +728,41 @@ export function assessHost(ctx) {
  * Anchoring on the resolved entry rather than on `require.resolve('@deepseek-ai/dsh')`
  * matters: the plugin never imports the `dsh` app package, so it need not be
  * resolvable from the plugin at all — only the shared libraries are.
+ *
+ * 注意 pnpm：这里在 `.pnpm/<name>@<ver>/node_modules/` 布局下会返回**该包的隔离目录**
+ * （那也是一个 `node_modules/@deepseek-ai`）。它本身不是问题 —— node 的解析会继续向上走到
+ * 顶层 `node_modules`，所以能解析出的包集合与顶层锚点相同（实测确认）。真正的风险在
+ * 调用方：从锚点解析不到的包会被判成 `same = null`，见 assessHost 里的 `unverified`。
  */
 function hostPackageRoot() {
+    // 与 doctor 的 `findHost` **同一套策略**（先看 `$DSH_HOME/profiles/node_modules/@deepseek-ai`，
+    // 再从插件自身位置逐级上溯，并确认那一层里真有 `dsh/package.json`）。此前运行时只按"插件
+    // 自己解析到的包"上溯，dev 布局下会把仓库里的副本当成宿主锚点、比出假的 `true` —— 于是
+    // 界面说 ok、doctor 说 SEPARATE COPY（V8）。两处口径分裂本身就是缺陷。
+    const home = process.env.DSH_HOME || join(process.env.USERPROFILE || process.env.HOME || '', '.dsh');
+    const candidates = [];
+    if (home !== '')
+        candidates.push(join(home, 'profiles', 'node_modules', '@deepseek-ai'));
     for (const anchor of IDENTITY_PACKAGES) {
         const resolved = realPathOf(safeResolve(anchor));
         if (resolved === null)
             continue;
         let dir = dirname(resolved);
-        for (let i = 0; i < 3; i += 1) {
-            if (dir.endsWith(join('node_modules', '@deepseek-ai')))
-                return dir;
+        for (let i = 0; i < 4; i += 1) {
+            if (dir.endsWith(join('node_modules', '@deepseek-ai'))) {
+                candidates.push(dir);
+                break;
+            }
             const parent = dirname(dir);
             if (parent === dir)
                 break;
             dir = parent;
         }
     }
+    for (const candidate of candidates) {
+        if (existsSync(join(candidate, 'dsh', 'package.json')))
+            return candidate;
+    }
     return null;
 }
 /** Human-readable summary line for logs and the settings page header. */

package/lib/compat/runtime-notes.js

@@ -0,0 +1,25 @@
+// 运行时降级上报通道 —— 「插件自己发现自己降级了」的统一出口。
+//
+// 为什么需要它：有一批降级**没有抛错可挂**：它们发生在装配期或探测期（第三方包装接管了本插件的
+// 运行时适配、注入域装配失败、启动期表达式或服务名解析出问题），失败当下的表现只是"某个功能
+// 少了一半"或者"静默失效"。此前这些点只落 console / logger，用户在界面上看不到，要等事故之后
+// 才倒查（审查报告 §3 记了多处）。这里给它们一个共用出口：`noteRuntime` 记一条，
+// `compat-status` 把全部条目并进 findings —— 兼容页因此成为"降级总账"。
+//
+// 与 `probe.ts` 的 CAPABILITY_SPECS 分工：那张表是**写死的宿主能力清单**（每次探测重算），
+// 这里是**运行时事件**（谁在什么时候发现了什么），两者在 compat-status 里合并展示。
+//
+// 键是 `id`：同一主题重复上报只覆盖不堆积（它表达的是"现在的状态"，不是日志）。
+const notes = new Map();
+/** 记一条（同 id 覆盖）。 */
+export function noteRuntime(note) {
+    notes.set(note.id, { ...note, at: Date.now() });
+}
+/** 该主题已恢复正常 → 收掉这一行。 */
+export function clearRuntimeNote(id) {
+    notes.delete(id);
+}
+/** 当前全部运行时降级（`compat-status` 取用）。 */
+export function runtimeNotes() {
+    return [...notes.values()];
+}