dsh-plugin-tool-management 0.20.3 → 0.21.1

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,119 @@ 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 it.",
         supersede: SUPERSEDE_NOTE,
     },
     memory: {
-        title: '当前记忆',
+        title: 'Current memories',
+        // 2026-10-18（审查 #7）：记忆段截断时，折叠行 `- ... ({rest} more not listed)` 给了计数
+        // 但没给出口——被截掉的条目连名字都没列出来，模型既调不了 `memory_manager_read`（不知道
+        // 传什么名字），也不知道该用 `memory_manager_list` 去发现。另外三个域的溢出行都点名了
+        // 自己的 list 工具，唯独记忆段没有。
+        //
+        // 修法选了「frame `how` 条件点名」而不是「把 listToolVisible 管道接到记忆服务」：记忆 SWR
+        // 缓存是指纹驱动的（缓存渲染结果，不是缓存数据按 agent 重渲染），重构成技能目录那种方式
+        // 要动 4–5 个文件。而 `how` 已经能看 `{ text }`——MCP 就是这么按正文内容决定发不发的。
+        // `text.includes('more not listed')` 只在折叠行出现时命中（rest > 0）；rest = 0（清单列全）
+        // 时折叠行不出现，how 不发——那些条目有名字，模型调 `memory_manager_read` 就行。
+        // 工具被关掉（兼容页 / 人设 toolsDeny）时不点名——与另外三域同一纪律。
+        how: ({ text, toolHidden }) => {
+            // 折叠行 `more not listed` 和截断标记 `(Truncated:` 两种信号都要覆盖：
+            //   - 折叠行 = 清单部分列了 + 剩余没列 → 没名的那些需要 list 工具发现
+            //   - 标记 = 连清单都没放进来 → 全部没名，更需要 list 工具
+            //   - 清单列全（`## Not injected` + 所有名字，rest = 0）→ 两种信号都没有 → 不发 how：
+            //     模型用 `memory_manager_read` 按名字读就行
+            if (!text.includes('more not listed') && !text.includes('(Truncated:'))
+                return undefined;
+            if (toolHidden('memory_manager_list'))
+                return undefined;
+            return 'Not all memories fit here — see the rest with `memory_manager_list`.';
+        },
         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,32 +160,51 @@ 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>` 一行文件头，没有一句话
+        // 说明**这些规则是要遵循的**。记忆域有授权语、场景域有定义，唯独效力最强的这一域空着 ——
+        // 而官方那条行给的是**降权**措辞（"可作参考"），我们当初刻意没抄，于是等于什么都没说。
+        // 现在补一句正面的：要遵循，且用户当场说的优先。
+        // 措辞用 "right now" 不用 "for this machine"（2026-10-18 审查）：场景预设接管时，正文是
+        // 场景绑定的那份 AGENTS.md，不是机器全局的 —— "for this machine" 在那个态下是假话。
+        // "right now" 同时覆盖全局 AGENTS.md 与场景预设两种来源，由正文首行 `Instructions from:`
+        // 给出具体出处。
+        how: 'These are the instructions in force right now; follow them unless the user says otherwise in this conversation.',
         supersede: SUPERSEDE_NOTE,
     },
 };
 /**
- * `how` 行里**点名过的工具**（六个域里只有 skills / subagents 两个会点名）。
+ * `how` 行里**点名过的工具**（skills / subagents / memory 三个域会点名）。
  *
  * 为什么要有这份名单：一条 `how` 行是否成立，取决于它点名的工具在**这个 agent 手里**还在不在。
- * 名单放在这里而不是调用方 —— 与上面那两条 `how` 相邻，改一处不会漏另一处。
+ * 名单放在这里而不是调用方 —— 与上面那几条 `how` 相邻，改一处不会漏另一处。
  *
  * "不在手里"有两条路，都要算：
  *   ① 兼容页「模型工具表」把它关掉（用户全局开关，名单在 index.ts 的 `hiddenTools` 里）；
  *   ② **人设的工具限制**把它砍掉（`decideToolFilter` → 官方 `tools.restrict`，只作用于那份
  *      人设启动的子代理）。②此前没人管：目录照注、`how` 行照样点名一个模型手里没有的工具，
  *      等于诱导它去调一个不存在的名字（2026-10-07 修）。
+ *
+ * `memory_manager_list` 2026-10-18 加入（审查 #7）：记忆段截断折叠行不点名查询工具时，
+ * 被截掉的条目无名、模型无法发现它们。`how` 在折叠行出现时点名它，与技能 / 子智能体 /
+ * MCP 三个域的溢出行同构。
  */
-export const HOW_NAMED_TOOLS = ['skill_manager_read', 'subagent_manager_run'];
+export const HOW_NAMED_TOOLS = ['skill_manager_read', 'subagent_manager_run', 'memory_manager_list'];
 /** 域声明里没登记的 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 +248,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`）。
 //   - **采纳遥测**：注入只解决"到没到"，不解决"用没用"。本模块按域统计
@@ -280,7 +281,7 @@ export function createContextInjector(deps) {
         // 的可见提示由兼容页那条「去填令牌」横幅承担。
         try {
             if (deps.tokenGateActive && deps.tokenGateActive()) {
-                log('令牌未验证：本轮对话被拒绝（在「工具 → 兼容」页填入访问令牌后恢复）');
+                log('令牌未验证：本轮对话被拒绝（在「工具管理 → 兼容」页填入访问令牌后恢复）');
                 return { kind: 'reject' };
             }
         }
@@ -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

@@ -398,14 +398,19 @@ export default {
             // 退出回放时也不该去动它们，否则会改写用户对副本的显式策略记录。
             currentSkills: async () => (await skillScan()).states,
             applySkills: async (target) => {
-                // 三道过滤，缺一不可：
+                // 四道过滤，缺一不可：
                 //  1. 被同名覆盖的副本直接跳过——它们本来就不生效，写策略只会污染用户的记录。
                 //  2. 结构不完整的技能也跳过——core 对它们一律拒绝启停（error.skill.notLoadable），
                 //     不跳过就会抛成"应用失败"，**整个场景进不去**（老档案里的残留键能踩到）。
-                //  3. **已经处于目标状态的技能不再写**。`applySkills` 写的是显式策略记录，而目标
+                //  3. **已经不存在的技能也跳过**（用户 2026-10-18 报「启动的场景里有被删除的内容，
+                //     就导致没办法退出」）：快照 / 档案里记的是"进场景那一刻还在"的键，场景期间那条
+                //     技能被删掉之后，退出时按快照回放必然报 `技能不存在`，于是整次退出被这一条打断、
+                //     mode 停在原地 —— 用户被困在场景里。没有可写的对象，跳过才是对的。
+                //  4. **已经处于目标状态的技能不再写**。`applySkills` 写的是显式策略记录，而目标
                 //     状态是生效状态，两者不等价：对已经生效为「停用」的技能再 disable 一次，
                 //     只是把「没有记录」固化成「显式停用」，场景模式进出一次就会改写 state.json。
                 const { states, shadowed, unloadable } = await skillScan();
+                const skipped = [];
                 for (const [key, on] of Object.entries(target)) {
                     const i = key.indexOf('/');
                     if (i <= 0)
@@ -417,13 +422,29 @@ export default {
                     // 继续往下走会抛成"应用失败"，**整个场景就进不去了**（老档案里的残留键能踩到）。
                     if (unloadable.has(key))
                         continue;
+                    // 这次扫描里根本没有这个键 = 技能已被删除（或所在目录已消失）：没有可写的对象。
+                    if (!(key in states)) {
+                        skipped.push(`${key}（已不存在）`);
+                        continue;
+                    }
                     if (states[key] === on)
                         continue;
                     const root = key.slice(0, i);
                     const name = key.slice(i + 1);
                     const r = await skillsService.ops[on ? 'skill-enable' : 'skill-disable']({ root, name });
-                    if (r && r.ok === false)
+                    if (r && r.ok === false) {
+                        // 结构性失败（这一条现在解不开）只记警告并跳过 —— 与 applySkillSourceSwitches
+                        // 同一条口径：拿它中断整个进入 / 退出只会把用户困在场景里，而这一行与本次改动无关。
+                        const code = String((r && r.code) || '');
+                        if (code === 'error.skill.notFound' || code === 'error.skill.notLoadable' || code === 'error.skill.noFrontmatter') {
+                            skipped.push(`${key}（${r.error}）`);
+                            continue;
+                        }
                         throw new Error(`技能 ${key} 应用失败: ${r.error}`);
+                    }
+                }
+                if (skipped.length) {
+                    ctx.logger?.warn?.(`scene: 跳过无法应用的技能 —— ${skipped.join('、')}`);
                 }
             },
             // ── 服务器级 / 来源级启停（P5）────────────────────────────────────────────
@@ -705,7 +726,7 @@ export default {
         // 三份界面设置侧车（inject / scene / slash）拆到 ./settings-sidecars.ts：读走 3 秒 TTL 缓存，
         // 写共用上面那条串行写锁。工厂只在这里调用一次，三份缓存仍是「每次 apply 一份」。
         // 传的是 apply 作用域里那几个函数声明的引用（提升已初始化），不是快照值。
-        const { readInjectSettings, injectSettingsSync, injectNoticeOptions, injectSettingsOp, readSceneSettings, sceneSettingsOp, readSlashSettings, slashSettingsOp, } = createSettingsSidecars({
+        const { readInjectSettings, injectSettingsSync, injectNoticeOptions, injectSettingsOp, readSceneSettings, sceneSettingsOp, readSlashSettings, slashSettingsOp, readSidebarSettings, sidebarSettingsOp, } = createSettingsSidecars({
             ensurePaths,
             readJsonFile,
             writeJsonFile,
@@ -727,7 +748,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 +770,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',
@@ -769,7 +790,7 @@ export default {
                     // 关掉或没配都是空串）而本次启动还没有人验过 ⇒ 这一步不放行，宿主把 turn 收成
                     // `blocked`。这是"没输入令牌就没法对话"的唯一真正落实 —— 客户端那条输入框锁定在
                     // 本宿主上无路可走（`ctx.conversation.blocks` 不存在，见 ContextInjectorDeps 注释）。
-                    // 只读 op 不受影响，所以「工具 → 兼容」页照常能打开、能填令牌 —— 解铃就在那里。
+                    // 只读 op 不受影响，所以「工具管理 → 兼容」页照常能打开、能填令牌 —— 解铃就在那里。
                     tokenGateActive: () => TOKEN !== '' && !acceptedThisBoot(),
                 });
                 contextInjectorLive = () => injector.live();
@@ -1395,6 +1416,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() {
@@ -1672,6 +1696,9 @@ export default {
             // 斜杠命令入口的开关（读 / 写）：客户端 boot 时读一次决定挂不挂 `/` 菜单里的「工具」段，
             // 兼容页那两颗开关写一次。同 `scene-settings`：按写门禁但不冻结（见 slash-settings.ts）。
             'slash-settings': (args) => slashSettingsOp(args),
+            // 侧栏入口的开关（读 / 写）：客户端 boot 时读一次决定注不注册侧栏那一行，兼容页那颗
+            // 按钮写一次。同 `slash-settings`：按写门禁但不冻结（见 sidebar-settings.ts）。
+            'sidebar-settings': (args) => sidebarSettingsOp(args),
             // state-doctor：跨域**悬空引用**体检（只读，实现与理由见 src/ops/state-doctor.ts）。
             // 这里只做"把权威集合取来"这一件事 —— 某一域读失败就传 null，体检会把它记进
             // `skipped` 而不是当成"该域没有悬空项"（读不到 ≠ 不存在，报成后者就是骗人）。

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