dsh-plugin-tool-management 0.10.0 → 0.11.0

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
@@ -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 ---------------------------------------------------
     {
@@ -324,7 +407,7 @@ const CAPABILITY_SPECS = [
         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,7 +448,7 @@ 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.
@@ -437,6 +520,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 +556,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 +601,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 +622,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 +633,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 +645,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 +662,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 +684,7 @@ export function assessHost(ctx) {
             modules,
             sameAsHost,
             blockers,
+            unverified,
         },
         findings,
         degraded,
@@ -566,6 +699,11 @@ 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() {
     for (const anchor of IDENTITY_PACKAGES) {

package/lib/context-inject.js

@@ -568,6 +568,17 @@ export function createContextInjector(deps) {
     if (!ctx || typeof ctx.on !== 'function')
         return { dispose: () => { }, live, noteToolUse };
     const stop = ctx.on('agent/pre-step', async (payload, next) => {
+        // 令牌门禁在**最前面**：没验过令牌时这一轮整个不放行，`next()` 都不必跑（后面那些注入
+        // 本来就是给模型看的，模型这一步根本不会被调用）。宿主据此把 turn 收成 `blocked`。
+        // 代价（宿主文档写明）：被认领的那条用户消息会被丢弃 —— 这是"拦住"的固有代价，界面侧
+        // 的可见提示由兼容页那条「去填令牌」横幅承担。
+        try {
+            if (deps.tokenGateActive && deps.tokenGateActive()) {
+                log('令牌未验证：本轮对话被拒绝（在「工具 → 兼容」页填入访问令牌后恢复）');
+                return { kind: 'reject' };
+            }
+        }
+        catch { /* 门禁判定失败不能反过来卡住对话：当作放行 */ }
         const decision = await next();
         try {
             if (!decision || decision.kind === 'reject')

package/lib/host-names.js

@@ -0,0 +1,12 @@
+/**
+ * 宿主身份常量：插件在文件里认的这几个名字只在这里写一次。
+ *
+ * 以前 `@deepseek-ai/dsh-mcp-client` 在 `index.ts` 里有 6 份副本（2 份写给补丁的 YAML、
+ * 2 份解析补丁时的比对、2 份运行时清单匹配），`preset-reach.ts` 里还有第 7 份 —— 官方改包名时
+ * 少改一处就是「开关点了没反应」或「列表凭空少一行」。档案目录名同理。
+ */
+export const MCP_CLIENT_MODULE = '@deepseek-ai/dsh-mcp-client';
+/** `ensurePaths()` 的档案探测顺序（先 web 后 headless）；都不在才退到「任意带 patch 的档案」。 */
+export const PROFILE_CANDIDATES = ['web', 'headless'];
+/** 探测不到任何档案时的兜底目录名（历史上的默认档案）。 */
+export const DEFAULT_PROFILE_NAME = 'web';

package/lib/http-fence.js

@@ -21,9 +21,12 @@ const headerValue = (req, name) => {
 /**
  * 判定请求是否应被拒（返回 null = 放行）。
  *
- * 优先用宿主栅栏；它不在场时（非 web 组合、服务未注册）退回等价的本地判定，
- * 而不是静默放行。栅栏自身抛错时同样退回本地判定 —— 宁可拒绝也不要因为宿主
- * 内部变动而变成开放路由。
+ * 优先用宿主栅栏；它不在场时（非 web 组合、服务未注册）退回**本地最小判定**，而不是静默放行。
+ * 栅栏自身抛错时同样退回本地判定 —— 但这句**不是**"宁可拒绝"：本地链不含 cookie 鉴权，
+ * 于是丢掉的恰好是宿主栅栏比本地判定多出来的那一层。无 Origin 的非浏览器请求只要带上
+ * `Host: localhost` 就能过（本机任意进程都做得到），而写 op 里包含 `mcpm-add`（宿主 stdio
+ * 传输会按 command/args spawn 它）与 `history-delete`（永久删除会话）。
+ * 准确的说法是：退回一个**不依赖宿主内部**的判定 —— 仍要求回环 Host，但没有会话凭证。
  *
  * @param req - Node 请求对象（只读 headers）。
  * @param connection - ctx.get('connection')，可缺失。
@@ -71,24 +74,41 @@ export function fenceRejection(req, connection) {
     }
     return null;
 }
+// 令牌相关的拒绝文案**只有这一句**，所有出口都引用它（用户裁定 2026-09-18：
+// 「这些关于密钥没填的提示词应该统一文案」；2026-09-19 再简化成一句话）。
+//
+// 2026-09-19 晚再去掉"去哪儿填、点什么"那两句（用户截图：提示条在好几个地方都折成两行）——
+// 提示条右侧本来就挂着「填写令牌」按钮，把按钮名念一遍等于同一件事在一行里说两遍，还占掉
+// 一整行的宽度。这一句只说"缺什么 / 错在哪"，动作交给那颗按钮；它跳到哪、填完什么状态，
+// 由兼容页的胶囊与三行自己说。**不要再往这句里加指引**：契约测试钉着它的长度。
+//
+// 为什么必须同源：同一个"没填令牌"会在四个地方冒出来（宿主写门禁、明文门禁的两条分支、
+// 界面的错误码词典），此前各写一套 —— 截图里同一件事出现了三种说法，用户无法判断它们
+// 是不是同一件事。界面靠**文本相等**识别这句话（见 client.js 的 isTokenGateText），
+// 所以改这句必须同时改界面词典里的那三个键。
+export const TOKEN_MSG = '缺少访问令牌，或令牌不对';
+/**
+ * 界面按 code 在最右侧挂「填写令牌」跳转按钮（这一族里的 code 都算）。
+ *
+ * 2026-09-19 之后 `secretOpRejection` **不再产生** NO_HOST（没配令牌就直接放行，见上），
+ * 但常量与界面词典里的 `error.secret.noToken` 都留着：宿主没重启时旧响应里还可能出现它，
+ * 而界面同时按 code 与**文本相等**两条路识别这一族（见 client.js 的 isTokenGateText）。
+ */
+export const TOKEN_CODE_NO_HOST = 'error.secret.noToken';
+export const TOKEN_CODE_BAD = 'error.token.required';
 /**
  * 判定敏感 op 是否应被拒（返回 null = 放行）。
  *
- * 两种情况分开报，因为处置方式不同：没配令牌要去宿主配置里加，配了但没带/带错
- * 只要在界面里填对即可（界面按 code 决定给不给输入框）。
+ * 没配令牌 ⇒ 放行（与写门禁同一激活条件，理由见上方段落）。有令牌 ⇒ 必须带对的。
+ *
+ * 两个 code 仍然分开报：界面用不到（话已经一样了），但日志与排查需要区分
+ * 「宿主根本没配令牌」与「这次带的令牌不对」—— 前者是配置问题，后者是输入问题。
  */
 export function secretOpRejection(state) {
-    if (!state.tokenConfigured) {
-        return {
-            code: 'error.secret.noToken',
-            error: '明文查看与导出已被禁用：宿主未配置访问令牌。请在本插件配置里加 token（或设环境变量 DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN）后重启 DSH，再在界面上填入同一个令牌。',
-        };
-    }
+    if (!state.tokenConfigured)
+        return null;
     if (!state.tokenAccepted) {
-        return {
-            code: 'error.secret.badToken',
-            error: '访问令牌缺失或不正确：请在界面里填入与宿主配置相同的令牌（随请求以 x-dsh-token 发送）。',
-        };
+        return { code: TOKEN_CODE_BAD, error: TOKEN_MSG };
     }
     return null;
 }

package/lib/hub.js

@@ -24,7 +24,13 @@
 //   ├─ mcp-disabled-tools.json | mcp-known-tools.json | mcp-notes.json | mcp-settings.json | mcp-export.json
 //   ├─ tool-management.log                               插件日志（滚动 .1）
 //   ├─ backups/cordis.patch.yml.bak-<时间戳>             改宿主 patch 前的备份
-//   └─ trash/{skills,subagents,prompts,scenes,memories}-trash/<id>/
+//   ├─ trash/{skills,subagents,prompts,scenes}-trash/<id>/  回收站（除记忆外的四类）
+//   └─ memories-trash/<id>/                              记忆回收站（**hub 根下独立目录**）
+//
+// 记忆回收站**不在 `trash/` 下**（本机实测 `trash/` 只有 4 个 `-trash` 目录）：它走
+// `memories/service.ts` 自己的路径（`join(stateDir, 'memories-trash', id)`，stateDir = hub 根），
+// 不经本模块的 `moveToTrash`。此前这行把它画进 `trash/{…}` 里，按它写备份/迁移脚本会既漏搬
+// 又误判（那是一类真实存在、条目数最多的用户数据）。
 //
 // 留在 `$DSH_HOME` 根下的两个文件**不是**插件的：`AGENTS.md`（宿主每轮读取的全局基线，
 // 插件只是按场景/预设写它）与 `cordis.patch.yml`（宿主加载插件的配置入口）。
@@ -365,14 +371,34 @@ export async function listTrashEntries(kind) {
 export async function readTrashEntry(kind, id) {
     return await readManifest(kind, id);
 }
+/**
+ * 条目里的一个负载名是不是"就在这个条目目录里"。
+ *
+ * 为什么 id 与场景名都有谓词、这里还得多一道：`manifest.json` 的 `files[]` 是**磁盘上的数据**，
+ * 它跟 id 不一样 —— id 只由本模块生成（`isValidTrashId` 严格白名单），而 files 可能来自
+ * 用户手改、别的进程、或一份被塞进来的恶意档案包。不校验就 `join(dir, dest)` 等于给了
+ * "任意相对路径读源 + 任意绝对目录建目标"的能力（`mkdir(dirname(to))` 会顺手把目录建出来）。
+ */
+export function isValidTrashPayloadName(dest) {
+    const text = String(dest ?? '');
+    if (!text || text.startsWith('.') || text.includes('\0'))
+        return false;
+    if (/[\\/]/.test(text))
+        return false;
+    if (text === 'manifest.json')
+        return false;
+    return true;
+}
 /**
  * 把条目里的一个负载搬回 `to`。**不覆盖**：调用方必须先确认 `to` 不存在。
- * @throws 条目或负载缺失时抛错（调用方翻成人话）。
+ * @throws 条目、负载名或负载缺失时抛错（调用方翻成人话）。
  */
 export async function moveOutOfTrash(kind, id, dest, to) {
     const dir = trashEntryPath(kind, id);
     if (dir === null)
         throw new Error(`回收站条目 id 非法：${id}`);
+    if (!isValidTrashPayloadName(dest))
+        throw new Error(`回收站负载名非法：${dest}`);
     const from = join(dir, dest);
     await mkdir(dirname(to), { recursive: true });
     try {

package/lib/imports/parsers.js

@@ -18,19 +18,22 @@ export function extractText(content) {
             if (typeof part === 'string')
                 out += part;
             else if (part && typeof part === 'object') {
-                if (typeof part.text === 'string')
-                    out += part.text;
-                else if (typeof part.content === 'string')
-                    out += part.content;
+                // JSON 块的实际形状由下方 typeof 运行时比较决定，这里按记录形状读取字段
+                const record = part;
+                if (typeof record.text === 'string')
+                    out += record.text;
+                else if (typeof record.content === 'string')
+                    out += record.content;
             }
         }
         return out;
     }
     if (content && typeof content === 'object') {
-        if (typeof content.text === 'string')
-            return content.text;
-        if (typeof content.content === 'string')
-            return content.content;
+        const record = content;
+        if (typeof record.text === 'string')
+            return record.text;
+        if (typeof record.content === 'string')
+            return record.content;
     }
     return '';
 }
@@ -58,6 +61,7 @@ export function detectFormat(fileName, content) {
     const first = String(content || '').split(/\r?\n/).map((s) => s.trim()).find((s) => s) || '';
     if (first.startsWith('{')) {
         try {
+            // JSON 值实际形状未知；若为对象，type/role 字段由下方运行时比较判定
             const obj = JSON.parse(first);
             if (obj && typeof obj === 'object' && (obj.type === 'user' || obj.type === 'assistant' || obj.role === 'user' || obj.role === 'assistant'))
                 return 'jsonl';
@@ -83,6 +87,7 @@ export function parseJsonlTranscript(text) {
         const line = raw.trim();
         if (!line)
             continue;
+        // JSONL 每行的实际形状未知；字段有效性由下方运行时比较判定
         let obj;
         try {
             obj = JSON.parse(line);
@@ -95,7 +100,7 @@ export function parseJsonlTranscript(text) {
         let role = null;
         let content;
         if (obj.type === 'user' || obj.type === 'assistant') {
-            const message = obj.message && typeof obj.message === 'object' && !Array.isArray(obj.message) ? obj.message : null;
+            const message = (obj.message && typeof obj.message === 'object' && !Array.isArray(obj.message) ? obj.message : null);
             role = message && (message.role === 'user' || message.role === 'assistant') ? message.role : (obj.type === 'user' ? 'user' : 'assistant');
             content = message ? message.content : undefined;
         }
@@ -112,6 +117,7 @@ export function parseJsonlTranscript(text) {
             lastText += '\n' + piece;
         }
         else {
+            // lastText 非空 ⇒ lastRole 已随 lastText 同步赋值（非 null），类型层无法表达该不变式
             if (lastText)
                 turns.push({ role: lastRole, text: lastText });
             lastRole = role;