dsh-plugin-tool-management 0.20.2 → 0.21.0

package/lib/context-inject-frame.js

@@ -8,11 +8,23 @@
  * 为什么不能并进 `cue`（那能省下整整一行 ≈16 tok/段）：用户 2026-09-18 定过"权威声明单独
  * 成句" —— 它和动作句是两种东西（一句说"什么时候用它"，一句说"以哪份为准"），合并后容易
  * 被一眼带过。所以这里的收益只有约 6 tok/轮，**主要收益是消除四种措辞**，不是省字节。
+ *
+ * 2026-10-18（用户裁定）：**模型侧模板一律英文** —— 框架标题、取代声明、`how` 行、清空 /
+ * 截断 / 未列出这些提示。**用户自己写的内容一律原样注入**（场景名与说明、记忆正文、MCP
+ * 备注、技能与人设的描述、`AGENTS.md` 正文、路径），一个字符都不动。理由：官方两条注入行
+ * （`Instructions from:` 与 skill catalog）本来就是英文，混着中文只让模型多付一次对齐成本。
+ *
+ * 同日晚些时候二次收紧（用户：「让 agent 更能注意到信息，信息高效，也不要冗余」）：这一代
+ * 每个句子都按「少一个词不改行为就删」过了一遍 —— 权威声明去掉自我指涉与场合限定
+ * （`This replaces … in this session` → `Supersedes … of the same kind`），六个 `how` 行
+ * 去掉「This preset has no …」这类铺垫、改成先说要做什么。**没有新增任何一行**：2026-09-23
+ * 那条原则（注入只讲当前情况、不写解释与动作句）仍然生效，加字只会稀释指令。
  */
-export const SUPERSEDE_NOTE = '本份取代本次会话中更早注入的同类内容。';
+export const SUPERSEDE_NOTE = 'Supersedes earlier injected content of the same kind.';
 export const DOMAIN_FRAME = {
     scene: {
-        // 场景段只有标题 + 正文 + 权威声明（**没有 cue 是六个域的共同决定**，理由见 `DomainFrame`）。
+        // 场景段此前只有标题 + 正文 + 权威声明（没有 cue 是六个域的共同决定，理由见 `DomainFrame`）；
+        // 2026-10-18 起多了一句 `how`（定义 + 后果），为什么加、加的是哪一句，见本段末尾。
         //
         // 这一段的演进值得记下来，因为每一次都是被实际注入推着改的：
         //   ① 最早它把「场景说明」当**约定**授权（"一律照办，覆盖你的默认做法"）—— 而它的实例
@@ -24,33 +36,96 @@ export const DOMAIN_FRAME = {
         //      知道没用的信息，反推更是浪费 token」。于是三句全删。
         //
         // 现在这一段只回答一个问题：**当前处在哪个场景、它是什么**（`**「代码」—— 写代码**`）。
-        // 它还比别的段少一层：因果句也删了 —— 它解释的是"另外四段是怎么产生的"（机制），
-        // 不是当前情况本身，而且"清单里没有 ≠ 本机没有"这层反推被用户明确判为浪费。
-        title: '当前场景',
+        //
+        // 2026-10-18（用户看到实际注入后问「agent 怎么知道这个场景是做什么的」）：把②那次删掉的
+        // 定义**加回来，但只加一句**，且换掉当时失败的那个写法。
+        //   - 当时失败的是"场景是用户给这台机器配的工作模式"——**只说是什么，不说它带来了什么**，
+        //     模型读完仍无动作可做。这里补上后果：记忆 / 提示词 / 工具 / 人设都已经按它筛过。
+        //   - 与①的区别（那条授权语不能回来）：这里不授权"照办"，只说"你拿到的这些东西为什么长这样"。
+        //     用户自己写的说明仍然只是注解，不是约定。
+        //   - 为什么这句能过"不写机制"那条原则：它解释的不是宿主怎么算的，而是**模型眼前这份上下文
+        //     为什么缺了几样**（`## Scene: 编程` 分组、看不到别的场景的记忆、工具比别处少）。
+        //     这是它做判断时要用的事实，不是反推。
+        //   - 代价 ≈24 tok/轮，只在这一域。
+        title: 'Current scene',
+        how: "A scene is the user's working mode: the memories, prompt, tools and personas you are given are already filtered to this one.",
         supersede: SUPERSEDE_NOTE,
     },
     memory: {
-        title: '当前记忆',
+        title: 'Current memories',
         supersede: SUPERSEDE_NOTE,
     },
     mcp: {
-        title: '当前 MCP 服务器',
+        title: 'Current MCP servers',
         // how 只剩"怎么用备注"这半句：前半个分句「工具名是 `mcp__<服务器>__<工具>`」删掉了
         // —— 模型自己的工具表里就是这个命名（`mcp__context7__xxx`），告诉它格式是零信息量。
-        how: '带「用户提示：」的行是用户写给这台服务器的决策提示，选服务器之前先看一眼。',
+        //
+        // 2026-10-18 补两句（用户同一轮裁定：三个点了工具的域都要有触发条件）：
+        //   ① **什么时候想起这张表** —— 模型看不到 server 的连线状态，缺工具时它只会两种反应：
+        //      说"没有这个工具"，或反复重试。这一域存在的意义就是给它第三种（表里有、只是没连上）。
+        //   ② `not connected now` 那一档的读法 —— 不写清"此刻没有注册任何工具"，这一行会被读成
+        //      "可用但状态存疑"，于是它照旧去调一个必然失败的工具名。
+        //
+        // 同轮二次修正（用户：「mcp 如果用户没写备注不是白写了吗」）：两句**都改成按需发**。
+        // 上一版是常量串，于是"一台上线服务器、没有备注"这种最常见的情形里，整段 = 三行说明
+        // 解释一个不存在的东西 + 一行 `- **github**` —— 说明比内容长，且每轮都付。
+        // 现在：备注句只在真有备注时发，离线句只在真有 `not connected now` 档时发，两者都没有
+        // 就**不发行**（`undefined`）。正文只有名字时，标题加名字本身已经把话说完了。
+        how: ({ text }) => {
+            const parts = [];
+            if (text.includes('user hint: ')) {
+                parts.push("`user hint:` marks the user's own note on that server — read it before choosing one.");
+            }
+            const offline = text.includes('(not connected now)');
+            const muted = text.includes('(no tools enabled here)');
+            // 两个状态标记合起来讲一次：各写一句会把"别当成缺失"重复两遍（2026-10-18 审查收口）。
+            if (offline && muted) {
+                parts.push('Status markers: `not connected now` = no tools registered right now; `no tools enabled here` = up, but every tool is switched off. Neither means the server is missing.');
+            }
+            else if (offline) {
+                parts.push('A server marked `not connected now` registers no tools right now: check this list before telling the user a server is missing or a tool does not exist.');
+            }
+            else if (muted) {
+                parts.push('A server marked `no tools enabled here` is up, but every one of its tools is switched off — do not report it as missing.');
+            }
+            return parts.length > 0 ? parts.join(' ') : undefined;
+        },
         supersede: SUPERSEDE_NOTE,
     },
     skills: {
-        title: '当前技能目录',
+        title: 'Current skills',
         // 两句都只在预设没挂官方 `skill` 工具时出现，差别只在点名不点名那个取正文的工具
         // （工具被用户在兼容页关掉时不点名 —— 点名一个模型手里没有的工具只会让它去猜名字）。
-        how: (toolHidden) => toolHidden('skill_manager_read')
-            ? '本预设没有官方 `skill` 工具：目录只有摘要，读完再照做。'
-            : '本预设没有官方 `skill` 工具：要正文用 `skill_manager_read`（按名字直接给正文与路径）；目录只有摘要，读完再照做。',
-        supersede: `${SUPERSEDE_NOTE.slice(0, -1)}；只列当前可调用的技能。`,
+        //
+        // 2026-10-18 补「什么时候动手」这半句（用户对比官方 skill catalog 后提出模板太单薄）：
+        // 上一版只有"读完再用"（**已经决定用之后**的纪律），没有"任务对得上就去读"（**怎么想起它**）。
+        // 官方那条行两者都有（`if … the task clearly matches … call the skill tool … before taking
+        // task actions`），而这一域恰恰只在官方那条行**缺席**时才注入 —— 也就是模型手上既没有
+        // `skill` 工具、也没人告诉过它技能的调用时机，缺的正是这一句。同理补上"描述不是指令"
+        // （官方对应句 `do not infer or follow a skill's instructions until it has been loaded`），
+        // 免得它拿 500 字摘要当正文照做。
+        // 不点名工具那一支改说"没有装载入口"：上一版在那里仍写着"read a skill's body before
+        // following it"，等于让模型去读一份它根本读不到的东西。
+        //
+        // 首句定义（用户 2026-10-18 第二轮裁定"加"）：官方那条行以 `A skill is a reusable set of
+        // task-specific instructions.` 开头 —— 这句不是背景介绍，是后面两半句的**前提**：不懂"skill
+        // 是按需加载的任务指令集"时，"任务对得上就读正文"读不出任何动作，只会被理解成"一个名字 +
+        // 一句简介"。所以这里破例把定义放在动作句之前（正常纪律是先说要做什么，见 `SUPERSEDE_NOTE`
+        // 那段注释）；措辞照抄官方，模型对它有现成先验。**只在官方载体缺席时发**（本域的唯一条件），
+        // 官方在时整段不注入，不存在两份定义。
+        how: ({ toolHidden }) => toolHidden('skill_manager_read')
+            ? 'A skill is a reusable set of task-specific instructions. No official `skill` tool and no skill reader here: names and summaries only, and no way to load a body — treat them as a capability list, not as instructions.'
+            : 'A skill is a reusable set of task-specific instructions. No official `skill` tool here: when a task clearly matches one or the user names one, read its body with `skill_manager_read` before acting. Summaries only — never treat a description as instructions.',
+        // 英文下不能再靠 `slice(0, -1)` 拼句（那会把句末句点削掉，接出
+        // `…in this session Only skills…`）：整句照发，续句自带首字母大写。
+        // 边界陈述 2026-10-18 拆出来并改口：原来写 `Only currently callable skills are listed.`，
+        // 而取正文的工具被关掉时**一条都调不到**，那句话在那个分支里是假的。改成 `enabled`
+        // —— 两支都成立（它们确实都是"启用中"的），也不再依赖工具在不在手里。
+        supersede: SUPERSEDE_NOTE,
+        boundary: 'Only enabled skills are listed.',
     },
     subagents: {
-        title: '当前子智能体',
+        title: 'Current subagents',
         // 分界规则（2026-09-17 方案 C，本机实测 session-ee722e23 逼出来的）：官方那两个
         // 委派工具（`subagent` / `subagent_fork`）不带人设，而此前没有任何一句话说明何时该
         // 用谁 —— 模型在"审查刚读过的 README"时选了 `subagent_fork`（fork 能继承已读内容、
@@ -62,13 +137,24 @@ export const DOMAIN_FRAME = {
         // Modes 段与 `inherit` 参数说明里**各有一份**，三份都在每轮上下文里 = 同一件事付三次
         // token。留这两份（它们就在"要传这个参数"的那一刻），这里只留 how 行独有的那半句 ——
         // 与官方两个委派工具的分界规则。
-        how: (toolHidden) => toolHidden('subagent_manager_run')
-            ? '本会话没有带人设的委派工具；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。'
-            : '贴合人设的任务一律用 `subagent_manager_run`；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。',
+        // 2026-10-18 补触发条件（同上）：此前只说了"带人设的活走哪条通道"（选哪条），
+        // 没说"什么算带人设的活"（要不要委派）。**例子刻意不写**——`subagent_manager_run` 的描述里
+        // 已经有 "a review, an investigation, a piece of writing 且细节不必占自己的上下文"，两句写在同一份
+        // 上下文里就是同一件事付两次。
+        // 不点名那一支补"只能参考、调不到"：上一版只说官方那两个不带人设，而"目录里有人设 ≠
+        // 能委派"这层没人说 —— 模型会拿官方工具硬塞一个人设名进去。
+        how: ({ toolHidden }) => toolHidden('subagent_manager_run')
+            ? 'No persona-carrying delegation tool here; official `subagent` / `subagent_fork` carry no persona — use them only when none fits or for background work. The personas listed here are reference only, not callable.'
+            : 'Persona work goes through `subagent_manager_run` — when a task matches one of these personas, delegate it there. Official `subagent` / `subagent_fork` carry no persona; use them only when none fits or for background work.',
         supersede: SUPERSEDE_NOTE,
     },
     prompt: {
-        title: '当前提示词',
+        title: 'Current prompt',
+        // 2026-10-18（审查 E）：这一域此前只有 `Instructions from: <path>` 一行文件头，没有一句话
+        // 说明**这些规则是要遵循的**。记忆域有授权语、场景域有定义，唯独效力最强的这一域空着 ——
+        // 而官方那条行给的是**降权**措辞（"可作参考"），我们当初刻意没抄，于是等于什么都没说。
+        // 现在补一句正面的：要遵循，且用户当场说的优先。
+        how: 'These are the instructions in force for this machine; follow them unless the user says otherwise in this conversation.',
         supersede: SUPERSEDE_NOTE,
     },
 };
@@ -87,7 +173,7 @@ export const DOMAIN_FRAME = {
 export const HOW_NAMED_TOOLS = ['skill_manager_read', 'subagent_manager_run'];
 /** 域声明里没登记的 key（理论上到不了这里）：给一个不出错的通用框架。 */
 export const fallbackFrame = (label) => ({
-    title: `当前的${label}`,
+    title: `Current ${label}`,
     supersede: SUPERSEDE_NOTE,
 });
 export const domainFrame = (key, label) => DOMAIN_FRAME[key] ?? fallbackFrame(label);
@@ -131,34 +217,56 @@ export function escapeFrameBody(body) {
  *     同时把**正文也包进标记里**（此前只有引导语在标记内、正文裸奔）—— 官方两条注入行都是
  *     整条包住的，正文里的用户自由文本更需要这层来源标记。
  */
-export function renderDomainText(section, toolHidden = () => false) {
+export function renderDomainText(section, toolHidden = () => false, replacing = true) {
     const frame = domainFrame(section.key, section.label);
     // 层级（2026-09-23 用户看到实际注入后指出「记忆内的场景怎么都是 ## 标题」）：**`#` 一级给板块**
     // （场景 / 记忆 / MCP / 技能 / 子智能体 / 提示词），域正文里的 `##` 才是它的下一层
-    // （记忆段的 `## 场景：X`、超预算时的 `## 未注入的参考信息`）。此前标题也是 `##`，两者平级，
+    // （记忆段的 `## Scene: X`、超预算时的 `## Not injected (…)`）。此前标题也是 `##`，两者平级，
     // 模型读不出主次 —— 而"哪些内容归在哪个板块/场景下"正是它做判断时要用的结构。
     //
     // 开标签后**必须空一行**：markdown 里 `#` 紧跟在一行文字后面只是**段落续行**，不会被渲染成
     // 标题 —— 用户截图里 `## 本机当前的场景` 就是这么被吞掉的（和 `<system-reminder>` 挤成一段）。
     // 收尾同理：正文末尾先归一成单个空行，免得 `</system-reminder>` 粘在最后一行上。
-    // 结构：标题 → 补充说明（有才发）→ 权威声明 → 正文。没有 cue 那一行（见 `DomainFrame` 的注释）。
+    // 结构：标题 → 补充说明（有才发）→ 权威声明（只在替换时）→ 边界陈述（有才发）→ 正文。
+    // 没有 cue 那一行（见 `DomainFrame` 的注释）。
+    const info = { toolHidden, text: section.text, replacing };
     const lines = [FRAME_OPEN, '', `# ${frame.title}`];
-    const how = typeof frame.how === 'function' ? frame.how(toolHidden) : frame.how;
+    const how = typeof frame.how === 'function' ? frame.how(info) : frame.how;
     if (how !== undefined)
         lines.push(how);
-    lines.push(frame.supersede, '', escapeFrameBody(section.text).replace(/\n+$/, ''), '', FRAME_CLOSE);
+    // 权威声明只在**替换**时发（2026-10-18 审查 D）：本会话的第一份没有旧内容可取代，那句话
+    // 只是占一行。边界陈述反过来 —— 它不依赖"有没有旧的"，第一份就要发。
+    if (replacing)
+        lines.push(frame.supersede);
+    if (frame.boundary !== undefined)
+        lines.push(frame.boundary);
+    lines.push('', escapeFrameBody(section.text).replace(/\n+$/, ''), '', FRAME_CLOSE);
     return lines.join('\n');
 }
 /** 「已清空」通知正文：某个域曾经注入过、现在没有内容时发一条（纯函数，测试用）。 */
-export function clearedDomainText(key, label) {
+export function clearedDomainText(key, label, reason) {
     const frame = domainFrame(key, label);
+    // 通知的措辞按**原因**分叉（2026-10-18 审查）。原来只有一句「同一类内容不再有效」，
+    // 而"这一域为什么消失"有四种，其中一种下那句话是**假话**：
+    //   - `official`：官方载体接管了（技能目录由 `dsh-tool-skill` 送、提示词由
+    //     `dsh-agent-instructions` 送）。此时同类内容**仍然有效、而且更强**，只是换了个发送方。
+    //     说"不再有效"会让模型把官方那一份也当成作废 —— 标准预设里这正是最常见的一次切换。
+    //   - `empty`：真的没有内容了（全部删掉 / 场景切走）。原来的话在这里是对的。
+    //   - `off` / `child`：是**故意不送**（用户关掉这一域，或该域不适用于子会话），内容本身
+    //     可能还在，所以只能说"不再展示"，不能说"不存在"。
+    //   - `error` 走不到这里：那条路径刻意不发「已清空」（见调用方注释）。
+    const body = reason === 'official'
+        ? '**Replaced** — the official channel now sends this content; earlier injected content of the same kind is stale.'
+        : reason === 'off' || reason === 'child'
+            ? '**Cleared** — this reminder is not sent here; earlier injected content of the same kind no longer applies.'
+            : '**Cleared** — earlier injected content of the same kind no longer applies.';
     // 形状与 `renderDomainText` 一致（开标签后空行、板块 `#`、收尾空行）—— 这两条都是同一个
     // 通道发出去的消息，层级与留白不该有两套。
     return [
         FRAME_OPEN,
         '',
         `# ${frame.title}`,
-        '**已清空** —— 本次会话中此前注入的同类内容不再有效。',
+        body,
         '',
         FRAME_CLOSE,
     ].join('\n');

package/lib/context-inject.js

@@ -40,7 +40,8 @@
 //     判定放在域声明的 `applicableTo` 上，通道只负责问一句 —— "哪个域对哪类会话不成立"
 //     是域的语义，不是通道的机制。
 //     ⚠️ 2026-09-17 方案 A 纠正：这**不是**"子会话不能委派"。官方 `dsh-tool-subagent`
-//     默认 `maxDepth: 3`，provider 只在传了该值时才校验 —— 子代理本来就能继续嵌套
+//     默认 `maxDepth: 1`（0.2.1 实测核对：`dsh-subagent/lib/index.js` 的 Config 默认值），
+//     provider 只在传了该值时才校验 —— 子代理本来就能继续嵌套
 //     （用户实测确认）。这个抑制只是让常驻目录不进入子会话、减少噪声；委派能力由官方
 //     决定，本插件不干预（我们也不再传 `maxDepth`）。
 //   - **采纳遥测**：注入只解决"到没到"，不解决"用没用"。本模块按域统计
@@ -376,12 +377,14 @@ export function createContextInjector(deps) {
             const toolHidden = hiddenNow === null ? () => false : (name) => hiddenNow.has(name);
             for (const section of sections) {
                 published.add(section.key);
-                const text = renderDomainText(section, toolHidden);
-                const current = visible.get(section.key);
-                if (current !== undefined && current.text === text)
-                    continue;
                 // `current !== undefined` = 该域在可见表面上已有一条更早的己方消息 → 这次是**替换**，
                 // 界面上的动作标签据此从「已载入」变成「已更新」（见 domainMessage 的 baseline/changes）。
+                // 这个判据同时决定框架里那句 `Supersedes …` 发不发（2026-10-18：第一份没有旧内容可取代）。
+                const current = visible.get(section.key);
+                const replacing = current !== undefined;
+                const text = renderDomainText(section, toolHidden, replacing);
+                if (replacing && current.text === text)
+                    continue;
                 let files;
                 try {
                     files = domainOf.get(section.key)?.files?.();
@@ -389,7 +392,7 @@ export function createContextInjector(deps) {
                 catch {
                     files = undefined;
                 }
-                additions.push(domainMessage(section, text, files, current !== undefined));
+                additions.push(domainMessage(section, text, files, replacing));
                 appended.push(section.key);
                 injectedKeys.add(section.key);
             }
@@ -409,7 +412,7 @@ export function createContextInjector(deps) {
                 const label = labelOf.get(key) ?? key;
                 if (previous.form === 'notice')
                     continue;
-                additions.push(clearedMessage(key, label));
+                additions.push(clearedMessage(key, label, lastReasons[key]));
                 appended.push(key);
                 clearedKeys.add(key);
             }
@@ -524,9 +527,9 @@ function domainMessage(section, text, files, replacing) {
         source,
     });
 }
-function clearedMessage(key, label) {
+function clearedMessage(key, label, reason) {
     return createUserMessage({
-        content: [{ type: 'text', text: clearedDomainText(key, label) }],
+        content: [{ type: 'text', text: clearedDomainText(key, label, reason) }],
         source: { kind: INJECT_KIND_OF[key], form: 'notice', summary: `${label}已清空` },
     });
 }

package/lib/http-api.js

@@ -46,9 +46,10 @@ export function installHttpApi(deps) {
             req.on('error', reject);
         });
         // 宿主 BrowserAuth 栅栏。宿主的鉴权**只包在它自己注册的路由上**——dsh-host-webserver
-        // 没有全局中间件，既定约定是每个注册方自己调 connection.requestRejection(req)：
+        // 没有全局中间件，既定约定是每个注册方自己调 connection.admit(req)：
         // 它先做 Host/Origin 栅栏（Host 必须是回环或 deployment 派生的 LAN IP 字面量，
-        // 这是 DNS rebinding 唯一伪造不了的头），再叠加 browser-session cookie 鉴权。
+        // 这是 DNS rebinding 唯一伪造不了的头），再叠加 browser-session cookie 鉴权，
+        // 并交回这次请求所代表的 Peer（本路由是 exact 路由，只服务 owner Peer）。
         // 本插件此前只查公开常量 x-dsh-plugin 与自比对（Origin.host === Host）的 "同源"，
         // 两者都挡不住 rebind 后的网页或本机任意进程 —— 等于没鉴权。现在优先走宿主栅栏。
         const connection = (() => {

package/lib/http-fence.js

@@ -3,7 +3,8 @@
 // 为什么需要它：宿主的 BrowserAuth 栅栏**只包在宿主自己注册的路由上**
 // （dsh-client-connection 的 register()/upgrade、dsh-api-gateway、
 // dsh-host-open-in-app），dsh-host-webserver 本身没有全局中间件。宿主生态的
-// 既定约定是每个注册方自己调 `connection.requestRejection(req)`，它做两件事：
+// 既定约定是每个注册方自己调 `connection.admit(req)`（0.2.1 起的完整版，
+// `requestRejection(req)` 是它只取状态码的那层包装），它做两件事：
 //
 //   1. Host/Origin 栅栏 —— Host 必须是回环地址、deployment 派生的 LAN IP 字面量
 //      或声明的 trustedHosts。Host 是 DNS rebinding 唯一伪造不了的头：攻击者
@@ -11,6 +12,9 @@
 //      （origin.host === host）会同时成立，于是被误判为同源。
 //   2. browser-session cookie 鉴权（HttpOnly + SameSite=Strict，Path=/）。
 //
+// `admit()` 还交回这次请求所代表的 **Peer**，而本插件的 exact 路由按官方契约只服务
+// owner Peer（非 owner 一律 403），所以 principal 也要验 —— 只取状态码会漏掉这一层。
+//
 // 只查公开常量 `x-dsh-plugin` 与自比对 Origin 等于没鉴权：本机任意进程都能调写 op，
 // 而写 op 里包含 `mcpm-add`（command/args 无白名单，宿主 stdio 传输会 spawn 它
 // → 任意命令执行）与 `history-delete`（永久删除会话）。
@@ -33,6 +37,27 @@ const headerValue = (req, name) => {
  */
 export function fenceRejection(req, connection) {
     try {
+        // 优先 `admit()`（0.2.1 起存在）：它做 Host/Origin 栅栏 + 浏览器 session 鉴权，
+        // 并把"这次请求代表谁"作为 Peer 交出来。`requestRejection()` 只给状态码 —— 状态码
+        // 足以回答"拦不拦"，却不足以回答"这个调用方被授权到什么程度"，而本插件的路由是
+        // **exact 路由**（`kind: 'exact'`，官方契约：只有 owner Peer 才该拿到响应）。
+        // 没有 principal 信息时只能当作非 owner 处理 —— 这正是下面 403 那一支的理由。
+        const admission = connection?.admit?.(req);
+        if (admission !== undefined) {
+            if ('rejection' in admission) {
+                const status = admission.rejection;
+                return {
+                    status,
+                    error: status === 401
+                        ? '未通过宿主的浏览器鉴权：请在 DSH Web GUI 内操作，或为本插件配置访问令牌（config.token / DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN）'
+                        : 'Host/Origin 栅栏拒绝：该请求不是发往本机地址的同源请求',
+                };
+            }
+            if (admission.peer?.principal?.kind !== 'owner') {
+                return { status: 403, error: '拒绝：调用方不是本机所有者身份' };
+            }
+            return null;
+        }
         const rejection = connection?.requestRejection?.(req);
         if (typeof rejection === 'number') {
             return {

package/lib/index.js

@@ -727,7 +727,7 @@ export default {
                     // 三个目录是 catalog，提示词是 instructions（与官方 AGENTS.md 那条行同一形态）。
                     //
                     // 深度判据（`applicableTo`）**逐域写在域声明上**，三个域各一条，语义都**不是**"能不能
-                    // 委派"。委派可行性由官方决定：`dsh-tool-subagent` 默认 `maxDepth: 3`，provider 只在
+                    // 委派"。委派可行性由官方决定：`dsh-subagent` 默认 `maxDepth: 1`（0.2.1 实测核对），provider 只在
                     // 传了该值时才校验，所以子代理本来就能继续嵌套（用户实测确认）。此前判据叫"还有没有
                     // 委派预算"、语义是"还能不能委派"，那是错的 —— 详见 service.ts 里 `catalogDepth` 的注释。
                     //   · 场景与记忆：**恒为"只在顶层"**。这两段说的是**父会话的处境**（此刻在哪个场景、
@@ -749,7 +749,7 @@ export default {
                         { key: 'scene', name: 'tool-management:scene', label: '场景', form: 'snapshot', text: () => memoriesService.sceneCatalogText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
                         // 记忆（**内容**）：各场景下的条目。与场景段同源、同一条 `applicableTo`。
                         { key: 'memory', name: 'tool-management:memory', label: '记忆', form: 'snapshot', text: () => memoriesService.memoryText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
-                        { key: 'mcp', name: 'tool-management:mcp-state', label: 'MCP 服务器', form: 'catalog', text: () => mcp.stateCatalog.text() },
+                        { key: 'mcp', name: 'tool-management:mcp-state', label: 'MCP 服务器', form: 'catalog', text: (agent) => mcp.stateCatalog.text(agent) },
                         { key: 'skills', name: 'tool-management:skill-catalog', label: '技能目录', form: 'catalog', text: (agent) => skillCatalog.text(agent) },
                         {
                             key: 'subagents',
@@ -1395,6 +1395,9 @@ export default {
             pluginHiddenTools: () => [...toolTableHidden()],
             // 有官方等价物时逐 agent 让位（见上面 CARRIER_DUPLICATES 的注释）。
             carrierHiddenTools: carrierHiddenToolsFor,
+            // 状态段尾句那句「用 `mcp_manager_list` 查」的前提：与技能 / 子智能体两个目录同一份判据
+            // （2026-10-18 审查 B）。
+            listToolVisible: (agent) => toolVisibleFor('mcp_manager_list', agent),
         });
         // ---------- ops ----------
         async function pluginVersion() {

package/lib/mcp/manager.js

@@ -113,7 +113,12 @@ export function createMcpManager(deps) {
     const { readJsonFile, writeJsonFile, ensurePaths, withWriteLock, message, tools, pluginInventory, settings, readPatch, writePatch, memoriesService, wait, } = deps;
     // MCP 状态段（注入通道的数据源）由本域自己建：它要的 rows 就是本域的 mcpmRowsWithNotes(false)，
     // 让 index.ts 建再传进来会形成 index ↔ manager 的循环引用。
-    const mcpStateCatalog = createMcpStateCatalog({ rows: () => mcpmRowsWithNotes(false) });
+    // `listToolVisible` 是唯一从外面进来的：它要看**这个 agent** 手里有没有 `mcp_manager_list`
+    // （兼容页开关 + 人设 toolsDeny），判据在 index.ts 的 `toolVisibleFor`，不在这里复制一份。
+    const mcpStateCatalog = createMcpStateCatalog({
+        rows: () => mcpmRowsWithNotes(false),
+        ...(deps.listToolVisible === undefined ? {} : { listToolVisible: deps.listToolVisible }),
+    });
     // ---------- duplicate loader-id guard ----------
     // Two rows with the same loader id make the plugin composition fail to
     // boot (upstream hit exactly this after renaming an entry), so duplicates

package/lib/mcp/state-section.js

@@ -9,26 +9,30 @@
 // 这类信息在任何工具 schema 里都拿不到：工具只暴露 `mcp__<server>__<tool>` 的名字与
 // 参数，永远不会说「A 挂了改用 B」。所以「列出 server」只是载体。
 //
-// 范围（2026-09-15 用户裁定；2026-09-17 按实测修正"可用"的判据）：
-//   - 分两档，判据全部可验证：
+// 范围（2026-09-15 用户裁定；2026-09-17 按实测修正"可用"的判据；2026-10-18 加第三档）：
+//   - 分三档，判据全部可验证：
 //       ① **可用**：配置上已启用 **且** 当前真实注册了未被停用的工具
 //          （`liveEnabledToolCount > 0`；场景档案收窄与手动逐工具开关都会写停用表，这里如实扣减）。
-//       ② **曾经连上、现在不可用**：已启用、当前一个工具都没注册，但「已知工具」缓存非空。
+//       ② **连着但工具全被停用**：当前注册了工具、但停用表把它们全扣光（`liveToolCount > 0`
+//          而 `liveEnabledToolCount === 0`）。2026-10-18 起列出来：它是"模型手上一条 MCP 工具
+//          都没有，可 server 确实在跑"的唯一线索，而此前不列的理由（"留着只会谎报数量"）
+//          随工具数一起作废了。
+//       ③ **曾经连上、现在不可用**：已启用、当前一个工具都没注册，但「已知工具」缓存非空。
 //          这是**状态变化**，要报 —— 模型据此给"检查网络/命令/凭据"的建议，而不是把
 //          "配了但连不上"读成"本机没配"（后者会让它建议用户去装一个）。同时，用户写在那台
 //          server 上的备注（placeholder 就是「A 不可用时改用 B 兜底」）恰恰只在此时才有用，
 //          不列就永远送不到。
-//     不列的三类：**没开**（用户明确要求）、**工具全被停用**（模型调不到，留着只会谎报数量）、
-//     **从未连上过**（缓存也空 —— 一直没成功过，不该反复打扰；这条抄的是 Claude Code 的通知
-//     策略：一直没连上的不提示，昨天还好今天挂的才提示）。
-//   - 只列 **server 名 + 状态（仅②档）+ 备注**；**具体工具名绝不注入** ——
+//     不列的两类：**没开**（用户明确要求）、**从未连上过**（缓存也空 —— 一直没成功过，不该反复
+//     打扰；这条抄的是 Claude Code 的通知策略：一直没连上的不提示，昨天还好今天挂的才提示）。
+//   - 只列 **server 名 + 状态（②③档）+ 备注**；**具体工具名绝不注入** ——
 //     已启用 server 的工具本来就在模型自己的工具 schema 里（`mcp__<server>__<tool>`），
 //     段里再列一遍是重复；模型按前缀就能对上号。
 //   - **工具数不列**（2026-09-23）：模型不能凭"这台有 N 个工具"做任何事（能调哪些在它自己的
 //     schema 里），而 17 B/台 × 每轮的开销是白付的。
-//   - 无备注 → 只有名字（①档）或名字 + 状态（②档）。
-//   - 不写「已启用」字样：能进段的都是可用的，标状态是废话；②档则必须标，否则就是谎报。
-//   - 两档都空 → 返回 `''`（renderPrompt 删空段，零 token 成本）。
+//   - 无备注 → 只有名字（①档）或名字 + 状态（②③档）。
+//   - 不写「已启用」字样：能进段的都是已启用的，标状态是废话；②③档则必须标，否则就是谎报。
+//   - **三档都空才返回 `''`**（无 server 可讲时零 token 成本）。注意 2026-10-18 的
+//     「无备注就不发」已被同日的用户裁定推翻，理由见 `renderMcpStateSection` 的注释。
 //
 // 一条**测不出来**的边界（写在这里免得后来者以为它是 bug）：宿主没有暴露"MCP 已连接"这个信号
 // （插件清单只有 entryId / moduleName / enabled / fiberPhase），所以本模块只能读"工具有没有注册"。
@@ -49,11 +53,11 @@ export const DEFAULT_MCP_NOTE_MAX_LENGTH = 300;
  * 备注的固定前缀（模型侧口径，用户裁定 2026-09-16：字段与段统一叫 user-hint / 用户提示）。
  *
  * 原为「备注：」，取「降低被读成指令的概率」——备注是自由文本，注入后**由插件背书**地到达模型。
- * 改叫「用户提示：」是有意为之：它本来就该被读成**用户的决策提示**（「A 挂了改用 B」），
+ * 改叫 `user hint:` 是有意为之：它本来就该被读成**用户的决策提示**（「A 挂了改用 B」），
  * 而不是系统策略。威胁模型不变（内容由用户自己写、仅本机可写，属**自伤**而非被攻击），
  * 但前缀如实标明来源，模型据此权衡即可。
  */
-export const MCP_NOTE_PREFIX = '用户提示：';
+export const MCP_NOTE_PREFIX = 'user hint: ';
 /**
  * 备注压成单行（换行 → 空格）并截断。
  *
@@ -70,12 +74,17 @@ export function normalizeMcpNote(value, maxLength) {
 /**
  * 渲染 MCP 状态段（纯函数，便于单独推理）。
  *
- * 分两档：**可用**（当前真注册了可用工具）与**曾经连上、现在不可用**（当前没注册，
- * 但「已知工具」缓存证明它曾经成功过）。判据与不列的三类见文件头。
+ * **整段的取舍**（2026-10-18 用户裁定「无备注不发这样不好」，推翻了同日的 A 方案）：
+ * 只要有一台该说的 server 就发，不因为"没有备注"而整段省略。理由：
+ *   - 这一域是**唯一**说明"这台机器上配了哪些 server、各自什么状态"的地方，而模型手里的工具表
+ *     只说得出"我现在能调什么"。少了它，"配过但没连上 / 连着但工具被关掉"与"根本没配过"
+ *     在模型看来完全等价 —— 那正是本模块存在的理由（见文件头）。
+ *   - 代价已经不是问题：`how` 行按需发、权威声明只在替换时发之后，只有名字的那种段在上下文里
+ *     只剩标题 + 一两行，且内容不变就不重发。
  *
- * 返回 `''` 表示不注入 —— 没有可用 server 的用户零 token 成本。
+ * @param listToolVisible `mcp_manager_list` 在这个 agent 手里吗（尾句那个出口的前提）
  */
-export function renderMcpStateSection(rows, opts = {}) {
+export function renderMcpStateSection(rows, opts = {}, listToolVisible = true) {
     const maxEntries = opts.maxEntries ?? DEFAULT_MCP_MAX_ENTRIES;
     const noteMaxLength = opts.noteMaxLength ?? DEFAULT_MCP_NOTE_MAX_LENGTH;
     // 当前真实可用的工具数（停用表扣减后）。**优先读 live 那个数** —— 旧调用方只给
@@ -91,12 +100,20 @@ export function renderMcpStateSection(rows, opts = {}) {
     const liveOf = (r) => (Number.isFinite(Number(r.liveToolCount)) ? Number(r.liveToolCount) : liveEnabledOf(r));
     // 曾经连上过的证据。缺省 0 = 从未连上过（旧调用方给不出这个信号，按"不列"处理 —— 少说不错）。
     const knownOf = (r) => Number(r.knownToolCount) || 0;
+    // 三档，判据全部可验证：
+    //   ① `usable`   —— 已启用，当前真注册了未被停用的工具（模型现在就能调）。
+    //   ② `muted`    —— 已启用、也真的连着（注册过工具），但**工具全被停用**：场景档案收窄或
+    //                   手动逐工具开关的结果。2026-10-18 起列出来并标注（此前不列）：它是
+    //                   "模型手上一条工具都没有，但 server 确实在跑"的**唯一**线索，而旧理由
+    //                   （"留着只会谎报数量"）随着工具数一起消失了 —— 现在只给名字与状态。
+    //   ③ `offline`  —— 已启用、当前一个工具都没注册，但「已知工具」缓存非空（曾经连上过）。
     const usable = rows.filter((r) => !r.disabled && liveEnabledOf(r) > 0);
+    const muted = rows.filter((r) => !r.disabled && liveOf(r) > 0 && liveEnabledOf(r) === 0);
     const offline = rows.filter((r) => !r.disabled && liveOf(r) === 0 && knownOf(r) > 0);
-    if (!usable.length && !offline.length)
+    if (!usable.length && !muted.length && !offline.length)
         return '';
     // 按展示名排序：即使补丁文件里的行序变化，段文本也保持逐字节稳定（前缀缓存契约）。
-    // 两档各自排序，可用的一律排在前面（它才是模型当下能用的东西）。
+    // 三档各自排序，可用的一律排在前面（它才是模型当下能用的东西）。
     const byName = (a, b) => {
         const x = String(a.serverName ?? '');
         const y = String(b.serverName ?? '');
@@ -104,48 +121,65 @@ export function renderMcpStateSection(rows, opts = {}) {
     };
     const cap = Math.max(0, maxEntries);
     const shownUsable = [...usable].sort(byName).slice(0, cap);
+    const shownMuted = [...muted].sort(byName).slice(0, cap);
     const shownOffline = [...offline].sort(byName).slice(0, cap);
-    const lineOf = (r, count, isOffline) => {
-        const name = String(r.serverName ?? r.id);
-        // ②档必须把状态写出来：不写就等于谎报"可用"。
+    const lineOf = (row, status) => {
+        const name = String(row.serverName ?? row.id);
+        // 非"可用"的两档必须把状态写出来：不写就等于谎报"可用"。
         //
         // 2026-09-23：两档的**工具数都去掉了**（用户看到实际注入后要求精简）。数字对模型没有
         // 动作价值 —— 它不能凭"这台有 8 个工具"列举出工具名（真正能调的都在它自己的工具
         // schema 里，按 `mcp__<server>__` 前缀就能对上号），而每轮都要付 17 B/台。
         // 顺带消掉一处隐患：②档原来写「上次连上时 N 个工具」，那个数字是**历史事实**，措辞上
         // 必须和现状区分开；数字没了，这个歧义也就不存在了。
-        const head = isOffline ? '- **' + name + '**（当前未连上）' : '- **' + name + '**';
-        const note = normalizeMcpNote(r.notes, noteMaxLength);
+        const head = status === 'offline'
+            ? '- **' + name + '** (not connected now)'
+            : status === 'muted'
+                ? '- **' + name + '** (no tools enabled here)'
+                : '- **' + name + '**';
+        const note = normalizeMcpNote(row.notes, noteMaxLength);
         return note ? head + ' — ' + MCP_NOTE_PREFIX + note : head;
     };
     const lines = [
-        ...shownUsable.map((r) => lineOf(r, liveEnabledOf(r), false)),
-        ...shownOffline.map((r) => lineOf(r, knownOf(r), true)),
+        ...shownUsable.map((row) => lineOf(row, 'ok')),
+        ...shownMuted.map((row) => lineOf(row, 'muted')),
+        ...shownOffline.map((row) => lineOf(row, 'offline')),
     ];
-    // 只有清单：标题（`# 当前 MCP 服务器`）由注入通道的框架承担
+    // 只有清单：标题（`# Current MCP servers`）由注入通道的框架承担
     // （2026-09-18 起，见 context-inject.ts 的 DOMAIN_FRAME）—— 同一件事只有一个出处，
     // 框架已经写了标题，正文再写一遍就是每步多付一行 token。
     const out = [...lines];
-    const hidden = (usable.length + offline.length) - (shownUsable.length + shownOffline.length);
-    if (hidden > 0)
-        out.push('', `（另有 ${hidden} 台未列出。）`);
+    const hidden = (usable.length + muted.length + offline.length)
+        - (shownUsable.length + shownMuted.length + shownOffline.length);
+    // 超上限时给出口（2026-10-18 审查 B）：技能与子智能体两个目录早就这么写了，这是唯一漏掉
+    // 的一处。工具被关掉（兼容页 / 人设 toolsDeny）时不点名 —— 点名一个模型手里没有的工具，
+    // 只会让它去猜名字；数量照报，那是实话。
+    if (hidden > 0) {
+        out.push('', listToolVisible
+            ? `(${hidden} more not listed — see them with \`mcp_manager_list\`.)`
+            : `(${hidden} more not listed.)`);
+    }
     return out.join('\n');
 }
 /** 创建 SWR 的 MCP 状态目录。计算失败时保留上一次的值，不把段清空。 */
 export function createMcpStateCatalog(deps, opts = {}) {
     const ttlMs = opts.ttlMs ?? 3000;
     const now = opts.now ?? (() => Date.now());
-    let value = '';
+    // 缓存的是**行数据**而不是渲染结果（与技能 / 子智能体两个目录同一手法）：清单只依赖磁盘，
+    // 而尾句要不要点名查询工具取决于**这个 agent 手里有没有它**。渲染是纯字符串操作，代价可忽略。
+    let data = null;
     let loadedAt = Number.NEGATIVE_INFINITY;
     let inflight = null;
+    let rendered = null;
     const recompute = async () => {
         try {
             const result = await deps.rows();
             if (result && result.ok !== false) {
-                value = renderMcpStateSection(result.rows ?? [], opts);
+                data = result.rows ?? [];
+                rendered = null;
             }
         }
-        catch { /* 保留上一次的值；首次失败则维持 '' */ }
+        catch { /* 保留上一次的值；首次失败则维持 null */ }
         loadedAt = now();
     };
     const revalidate = () => {
@@ -155,10 +189,17 @@ export function createMcpStateCatalog(deps, opts = {}) {
         return inflight;
     };
     return {
-        text: () => {
+        text: (agent) => {
             if (now() - loadedAt > ttlMs)
                 void revalidate();
-            return value;
+            if (data === null)
+                return '';
+            const visible = deps.listToolVisible ? deps.listToolVisible(agent) : true;
+            if (rendered && rendered.visible === visible)
+                return rendered.text;
+            const out = renderMcpStateSection(data, opts, visible);
+            rendered = { visible, text: out };
+            return out;
         },
         refresh: () => {
             loadedAt = Number.NEGATIVE_INFINITY;