dsh-plugin-tool-management 0.13.0 → 0.14.0

package/lib/mcp/state-section.js

@@ -21,13 +21,12 @@
 //     不列的三类：**没开**（用户明确要求）、**工具全被停用**（模型调不到，留着只会谎报数量）、
 //     **从未连上过**（缓存也空 —— 一直没成功过，不该反复打扰；这条抄的是 Claude Code 的通知
 //     策略：一直没连上的不提示，昨天还好今天挂的才提示）。
-//   - 只列 **server 名 + 工具数 + 备注**；**具体工具名绝不注入** ——
+//   - 只列 **server 名 + 状态（仅②档）+ 备注**；**具体工具名绝不注入** ——
 //     已启用 server 的工具本来就在模型自己的工具 schema 里（`mcp__<server>__<tool>`），
 //     段里再列一遍是重复；模型按前缀就能对上号。
-//   - 工具数只算**当前可用**的：被停用的那一部分不显示（它就是模型 schema 里没有的），
-//     数字必须与模型能调到的工具对得上。②档没有当前数字，所以写的是「上次连上时 N 个工具」——
-//     那是历史事实，不是现状，措辞上必须区分开。
-//   - 无备注 → 只有名字 + 工具数（正是「不写就只知道名字」）。
+//   - **工具数不列**（2026-09-23）：模型不能凭"这台有 N 个工具"做任何事（能调哪些在它自己的
+//     schema 里），而 17 B/台 × 每轮的开销是白付的。
+//   - 无备注 → 只有名字（①档）或名字 + 状态（②档）。
 //   - 不写「已启用」字样：能进段的都是可用的，标状态是废话；②档则必须标，否则就是谎报。
 //   - 两档都空 → 返回 `''`（renderPrompt 删空段，零 token 成本）。
 //
@@ -108,11 +107,14 @@ export function renderMcpStateSection(rows, opts = {}) {
     const shownOffline = [...offline].sort(byName).slice(0, cap);
     const lineOf = (r, count, isOffline) => {
         const name = String(r.serverName ?? r.id);
-        // ②档必须把状态写出来：不写就等于谎报"可用"。「上次连上时」四个字不能省 ——
-        // 那个数字是历史事实，写成"（N 个工具）"会被读成现状。
-        const head = isOffline
-            ? '- **' + name + '**（当前未连上；上次连上时 ' + count + ' 个工具）'
-            : '- **' + name + '**（' + count + ' 个工具）';
+        // ②档必须把状态写出来：不写就等于谎报"可用"。
+        //
+        // 2026-09-23：两档的**工具数都去掉了**（用户看到实际注入后要求精简）。数字对模型没有
+        // 动作价值 —— 它不能凭"这台有 8 个工具"列举出工具名（真正能调的都在它自己的工具
+        // schema 里，按 `mcp__<server>__` 前缀就能对上号），而每轮都要付 17 B/台。
+        // 顺带消掉一处隐患：②档原来写「上次连上时 N 个工具」，那个数字是**历史事实**，措辞上
+        // 必须和现状区分开；数字没了，这个歧义也就不存在了。
+        const head = isOffline ? '- **' + name + '**（当前未连上）' : '- **' + name + '**';
         const note = normalizeMcpNote(r.notes, noteMaxLength);
         return note ? head + ' — ' + MCP_NOTE_PREFIX + note : head;
     };
@@ -120,7 +122,7 @@ export function renderMcpStateSection(rows, opts = {}) {
         ...shownUsable.map((r) => lineOf(r, liveEnabledOf(r), false)),
         ...shownOffline.map((r) => lineOf(r, knownOf(r), true)),
     ];
-    // 只有清单：标题（`## 本机 MCP 服务器的当前状态`）与"该拿它做什么"由注入通道的框架承担
+    // 只有清单：标题（`# 本机 MCP 服务器的当前状态`）由注入通道的框架承担
     // （2026-09-18 起，见 context-inject.ts 的 DOMAIN_FRAME）—— 同一件事只有一个出处，
     // 框架已经写了标题，正文再写一遍就是每步多付一行 token。
     const out = [...lines];

package/lib/memories/constants.js

@@ -17,7 +17,16 @@ export const MAX_RULE_BYTES = 1 << 18; // 正文上限 256 KiB
 export const DEFAULT_ORDER = 1000; // 默认投影 order（索引无记录时）
 export const DEFAULT_GROUP_ORDER = 1000; // 新场景默认 order
 export const SNAPSHOT_TTL_MS = 1000; // 读路径短 TTL 缓存，吸收 UI 密集轮询
-export const DEFAULT_MAX_BYTES = 1 << 17; // 场景记忆段预算上限（字节，=128 KiB）
+export const DEFAULT_MAX_BYTES = 1 << 17; // 记忆段预算上限（字节，=128 KiB）
+/**
+ * 场景段（`scene-manager-catalog`）的预算上限（字节，= 4 KiB）。
+ *
+ * 比记忆段小两个数量级是**有意的**：场景段只列"启用的**非保留**场景 + 场景说明"，而场景是
+ * **单选**的 —— 除保留场景（`global` / `_shared`，恒常生效、不列）外至多一个启用，正常不到
+ * 1 KiB；一个具体场景都没启用时整段不注入（默认状态不占上下文）。给它一个大预算等于给一份
+ * 永远用不到的保险；真有场景描述被写爆的那天，截断标记会说清（`renderSceneCatalog`）。
+ */
+export const SCENE_CATALOG_MAX_BYTES = 1 << 12;
 // ── 保留场景名 ─────────────────────────────────────────────────────────────
 /** 保留场景名：界面显示「全局」，恒定存在、不可删除，其记忆注入任何对话。 */
 export const GLOBAL_SCENE = 'global';
@@ -44,12 +53,18 @@ export const ATTACHMENT_LIST_MAX = 10;
  *   - **不点名任何工具**：模型从工具 schema 就知道 `memory_manager_list` 存在，点名反而
  *     像在提示它去调；用户裁定「没启用的信息就是不想在当前用」，所以工具指引整句删除。
  *     真正防探测的是**完整性声明**（「以下就是全部信息」），那半句必须留。
+ *     ⚠️ **那半句已在 2026-09-23 第四次裁定里被删**（见下）—— 所以本段现在**没有**任何
+ *     防探测手段，这是有意识付掉的代价，不是漏改。
  *   - **完整性声明按截断状态自适应**：真有条目因预算没注入时，段尾会有未注入清单，
  *     此时不能再声称「全部」，否则和清单自相矛盾 —— 也正因为那时确实有东西没给到，
  *     模型去查工具是**合理**的，不该再拦。
+ *     ⚠️ 声明删掉后这套自适应**失去意义**（两版会完全相同），已合并成一个常量，
+ *     `renderBody` 的 `dropped` 分叉一并移除。
  *
- * 用词：不用「常驻」「注入」这类内部行话（模型没有先验）；用户裁定用「信息」而不是
- * 「记忆」——「记忆」在系统提示词里指代不明，而这段的实质就是用户写的参考信息。
+ * 用词：不用「常驻」「注入」这类内部行话（模型没有先验）。
+ * ⚠️ 「用『信息』而不是『记忆』」那条**已被 2026-09-23 第四次裁定推翻**（见下）：用户
+ * 给定的定稿文案里就是「记忆」，而板块标题本来就是「本机当前的记忆」—— 两者同名反而更好，
+ * 当时那条理由（「记忆」在系统提示词里指代不明）在板块标题定名之后也不成立了。
  *
  * 2026-09-17 重写（用户：「当前模式会不重视这些提示词」）。上一版的三个毛病都在**授权**
  * 上，而不在措辞好不好看上：
@@ -70,17 +85,66 @@ export const ATTACHMENT_LIST_MAX = 10;
  * "If a recalled memory conflicts with current information, trust what you observe now"
  * —— 书里（ch11:25）说记忆是 "working notes, not gospel"。上一版把两类塞进一句授权，
  * 对**场景说明**（用户写的约定）是对的，对**记忆条目**（可能是几个月前记下的事实）是错的。
- * 好在这两类在渲染时就分处不同位置：场景说明在 `sceneHeader` 的 `**场景说明：…**` 里，
- * 记忆条目在 `memoryBlock` 里 —— 所以一句话就能分级，不必改数据结构。
+ *
+ * 2026-09-23：两类内容**拆成两个注入段**（用户裁定）：`scene-manager-catalog`（场景段）
+ * 讲"当前启用的是哪个场景、它是什么"，`memory-manager-catalog`（记忆段）用 `SCENE_MEMORY_NOTE`
+ * 给**记录**的授权。拆段的收益：用户能单独关掉记忆段（省字节）而保留场景说明，且两段各自
+ * 完整自洽。代价是场景名在两段各出现一次（**说明只在场景段**，见 `renderSceneCatalog` 的注释）。
+ *
+ * 2026-09-23 第二次裁定（用户看到**实际注入**之后）：**场景段不再带授权语**。上一版把它写成
+ * "「场景说明」是用户为本机写的约定，一律照办，覆盖你的默认做法"，而这一格的实例是「写代码」
+ * 「前端相关」这种**标签** —— 让模型"照办一个标签"正是它读不懂那一段的原因。正文只给
+ * "当前启用的是哪个"（`sceneLine`）。
+ *
+ * 同日晚些时候的第三次裁定把这段又削了一层：替掉授权语的那句"场景是什么"线索（`场景是用户
+ * 给这台机器配的工作模式…`）**也删了**，连同六个域的动作句一起（理由见 `DomainFrame`）。
+ * 所以这一段最终**没有任何引导语** —— 只有 `sceneLine` 一行。
  *
  * 冲突阶梯（第 4 条）来自 Codex `base_instructions/default.md:22-27` 与 Claude Code 的
  * `caller override > agent definition > parent model > default`：把"谁高于谁"写明，
  * 模型才不会在「用户当场说的 ≠ 本机记录」时悬空。写明它还有一个反直觉的好处 ——
  * 它让授权更可信：这说明本条不是要让记忆压过用户，只是要压过模型的默认假设。
+ *
+ * 2026-09-23 第三次裁定（用户看到实际注入后：「这段话很多没用信息，浪费 token 和上下文」）：
+ * **压缩措辞，五个功能一个不动** —— ① 这是什么（本机记录）、② 可能已过期、③ 与实际情况冲突
+ * 时以实际情况为准、④ 与用户当场说的冲突时以用户为准、⑤ 无关不必提 + 完整性声明（防探测，
+ * 见上，那半句是整句里唯一不能删的）。77 → 48 字符（219 → 144 字节），而它**每个场景块各来
+ * 一次**，所以省的是 N 倍。删掉的只有修饰与重复：「以下是用户为本机写的记录」→「本机记录」
+ * （板块标题 `# 本机当前的记忆` 已经把"这是本机的记忆"说过了），两句"冲突时以…为准"
+ * 合成一句。
+ *
+ * 2026-09-23 第四次裁定（用户直接给定稿文案，逐字）：
+ * 「以下是当前场景对应的记忆；冲突时以实际情况和用户目前的对话为准；无关勿提。」
+ * 相对第三版有三处变化，都不是措辞偏好：
+ *   ① 「本机记录」→「以下是**当前场景对应的**记忆」：说清这是**哪个范围**的记忆。记忆本来
+ *      就按场景组织，而这一段列出的条目确实全来自"当前启用的场景 + 两个保留桶" —— 比
+ *      "本机记录"准确，也解释了为什么下面的条目按 `## 场景：X` 分组。
+ *   ② 「用户当场说的」→「用户**目前的对话**」：同一个意思，后者更贴注入发生的场合。
+ *   ③ **删掉「可能已过期」，以及完整性声明「以下就是全部信息」**。
+ *      - 「可能已过期」：用户判断它与紧接的「冲突时以实际情况为准」重复 —— 后半句已经把
+ *        "记录可能不准"这层说全了。接受。
+ *      - 「以下就是全部信息」：一度删掉（当时记下的后果是"本段不再声称自己完整，模型在
+ *        清单里找不到某件事时可能去调 `memory_manager_list` 找更多"），**同一天又加回来了**
+ *        —— 见下面的第五次裁定。
+ * 因为不再有完整性声明，第三版"按截断状态选长短两版"的自适应失去意义（两版会完全相同），
+ * 所以**两个常量合并成一个**。
+ *
+ * 2026-09-23 第五次裁定（用户看到改后的实际注入，两处）：
+ *   ① **完整性声明加回来**，措辞改成收尾的 `；以下就是全部信息：`（句号 → 分号 + 冒号）。
+ *      它引向下文，比原来独立成句的「以下就是全部信息。」更像一句引导语 —— 而它承担的
+ *      **防探测**功能原样保留（那正是 2026-09-17 那条"必须留"的裁定要的）。
+ *      所以 `SCENE_MEMORY_NOTE_PARTIAL` 与 `dropped` 分叉**没有恢复**：这一版是"全量"口吻
+ *      的收尾语，真截断时确实会与未注入清单矛盾 —— 但那是预算被配到极小时的极端情形
+ *      （默认 128 KiB，正常永远碰不到），先不为此重加一层结构。
+ *   ② **`global` 的分组标题从 `## 场景：全局` 改成 `## 常驻信息`**（见 `sceneHeading`）：
+ *      全局是恒常生效的保留桶，不是"一个场景"，写成场景会让模型以为它是当前场景的另一种
+ *      取值。
+ */
+/**
+ * 记忆段（`memory-manager-catalog`）的授权语：条目是**记录**（权威等级低于"用户当场说的"）。
+ * 放在**板块层**（第一个场景块之前），整段只出现一次 —— 见 `renderBody` 尾部。
  */
-export const SCENE_MEMORY_NOTE = '**用户为本机写的参考信息：「场景说明」是用户的约定，一律照办，覆盖你的默认做法；其余条目是记录，可能已过期 —— 与当前实际情况冲突时以你看到的为准，与用户当场说的冲突时以用户为准。无关时不必提及。以下就是全部信息。**';
-/** 有未注入条目时的版本：去掉完整性声明（见上）。 */
-export const SCENE_MEMORY_NOTE_PARTIAL = '**用户为本机写的参考信息：「场景说明」是用户的约定，一律照办，覆盖你的默认做法；其余条目是记录，可能已过期 —— 与当前实际情况冲突时以你看到的为准，与用户当场说的冲突时以用户为准。无关时不必提及。**';
+export const SCENE_MEMORY_NOTE = '**以下是当前场景对应的记忆；冲突时以实际情况和用户目前的对话为准；无关勿提；以下就是全部信息：**';
 // ── bundle 与索引 ──────────────────────────────────────────────────────────
 // bundle 附件限制（body 走 HTTP JSON + base64，故比技能上传收紧一档）。
 export const MAX_ATTACH_ENTRY_BYTES = 8 << 20; // 单个附件 8 MiB

package/lib/memories/index-io.js

@@ -254,7 +254,7 @@ export async function readIndex(stateDir) {
  *
  * ⚠️ 返回的可能是**缓存实例**，调用方只许读；写索引一律走异步 `readIndex`（它每次重新解析，
  * 拿到新对象）。当前两个调用方（`sceneMemory` / `resolveScenePreset`）及其下游
- * （`signatureOfIndex` / `resolveActiveScenes` / `sceneHeader` / `compareSceneBuckets` /
+ * （`signatureOfIndex` / `resolveActiveScenes` / `sceneLine` / `compareSceneBuckets` /
  * `sceneOrderOf`）都已确认只读 —— 新增调用方请保持这条。
  */
 export const indexSyncCache = new Map();

package/lib/memories/projection.js

@@ -101,7 +101,7 @@ export function signatureOfIndex(index) {
     });
     const groups = Object.keys(index.groups).sort().map((g) => `${g}\u0000${index.groups[g]?.order ?? DEFAULT_GROUP_ORDER}`);
     // 场景顺序决定段内场景的先后 → 必须进指纹，否则改顺序后段文本不会重算。
-    // label 与 description 同理（sceneHeader 的「场景说明」一行直接渲染 description）——
+    // label 与 description 同理（`sceneLine` 把 label 与 description 都渲染进正文）——
     // 手改索引文件（带外变更）时只有指纹变化才会触发重算。
     const scenes = Object.keys(index.scenes || {}).sort().map((s) => {
         const e = index.scenes[s];
@@ -126,34 +126,42 @@ export function sceneLabel(scene, index) {
     const label = index?.scenes?.[scene]?.label;
     return label && label !== '' ? label : scene;
 }
-/** 单个场景的标题：**场景在最顶层**（`##`，与「子智能体」「MCP 服务器」等段同级）。 */
-export const sceneHeading = (scene) => `## 场景：${sceneLabel(scene)}`;
 /**
- * 没填描述时的默认「场景说明」（用户裁定 2026-09-16：全局桶一直没有描述，读起来像缺了一块，
- * 统一成"每个场景块都有场景说明"）。
+ * 记忆段里的场景**分组**标题。
  *
- * 默认句同时承担"这个场景是什么"的答疑（此前只有光秃秃的 `## 场景：X`，模型读不懂 —— 用户实测）：
- * 两个恒常桶说明生效范围，用户场景说明它是当前启用的那份配置。
+ * `global` 是恒常生效的保留桶，不是"一个场景" —— 叫它 `## 场景：全局` 会让模型以为"全局"
+ * 是当前场景的另一种取值（用户 2026-09-23：「全局不需要写成场景」）。所以它单独成一种标题：
+ * `## 常驻信息`。其余场景仍是 `## 场景：X`。
+ *
+ * `_shared`（历史保留名）保持 `## 场景：_shared` 不动 —— 它只在旧数据里出现，且没有
+ * "全局"这种"它不是场景"的语义歧义（它确实曾是一个共享场景）。
  */
-export const defaultSceneDescription = (scene) => (scene === GLOBAL_SCENE ? '全局记忆，任何对话都生效'
-    : scene === SHARED_GROUP ? '共享记忆，任何对话都生效'
-        : '用户配置的上下文，当前启用');
+export const sceneHeading = (scene) => scene === GLOBAL_SCENE ? '## 常驻信息' : `## 场景：${sceneLabel(scene)}`;
 /**
- * 单个场景的段头：场景标题 + **恒有**的 `场景说明：<描述>`。
+ * 场景段（`scene-manager-catalog`）里的一行：`**「<场景名>」—— 用户描述：<场景说明>**`。
+ *
+ * 2026-09-23 用户裁定，替换了原来的两行式（`## 场景：X` + `**场景说明：X**`）。三条理由都是
+ * 用户看到**实际注入**之后提的：
+ *   - **场景名只出现一次**。上一版里它出现三次（框架线索"现在处在哪个场景"、引导语里的
+ *     「代码」、标题里的 `## 场景：代码`），而说明行只是把同一件事换个标签再说一遍。
+ *   - **场景说明是「标签」，不是「约定」**。它答的是"这个场景是干什么的"，用户的实例就是
+ *     「写代码」「前端相关」。上一版把它写成"一律照办、覆盖你的默认做法"，等于要求模型
+ *     "照办一个标签" —— 那正是它读不懂这一段的根源。授权语已删，说明只作注解跟在名字后面。
+ *   - **没填说明就不带后缀**。上一版会补 `defaultSceneDescription` 的默认句，而
+ *     "用户配置的上下文，当前启用"贴在名字后面，读起来像一句真的说明。
+ *
+ * `用户描述：` 这个前缀是同日追加的（用户：「防止模型误解这是场景名或者其它」）：破折号后面
+ * 那截的形态本来有歧义 —— `**「代码」—— 写代码**` 读起来像"名字 —— 别名"，而它其实是
+ * **用户写的一句说明**。加四个字把来源点明，模型就不会把它当成场景的另一个名字或某种标识符。
+ * 前缀只在真有描述时出现（没填描述时整截不出现，不存在"用户描述："后面空着）。
  *
- * 场景描述（界面「描述（可选）」，≤60 字符）**此前从未注入过** —— 它正是「这个场景是
- * 干什么的」的答案，属于模型做判断需要的上下文，而不是只给人看的元数据；界面上的文案
- * 也从没把它标成「只给使用者看」（对比 AGENTS.md 预设的描述，那里是明确标注的）。
- * 描述为空时给 `defaultSceneDescription` 的默认句（用户裁定：全局桶没描述时读起来像
- * 缺了一块，统一成每个场景块都有说明）。
+ * 为什么不再用 `##` 标题：这一段只讲"当前启用的是哪个 + 它是什么"，一行说完就够。
+ * 场景**分组**标题仍在记忆段里用（`sceneHeading`），两段各自承担自己的职责。
  */
-export function sceneHeader(scene, index) {
-    const head = sceneHeading(scene);
+export const sceneLine = (scene, index) => {
     const described = String(index?.scenes?.[scene]?.description ?? '').replaceAll(/\s+/g, ' ').trim();
-    const description = described === '' ? defaultSceneDescription(scene) : described;
-    // 加粗（用户裁定 2026-09-16）：与引导语同款强调，别让"场景说明"读起来像可忽略的普通正文。
-    return `${head}\n\n**场景说明：${description}**\n\n`;
-}
+    return `**「${sceneLabel(scene)}」${described === '' ? '' : `—— 用户描述：${described}`}**\n\n`;
+};
 /** 场景渲染顺序：全局 `global` 最先（它的记忆对任何对话都成立，先讲总则），
  *  其次 `_shared`（历史保留名），其余按（索引 scenes.order, 场景名）。 */
 export function compareSceneBuckets(a, b, index) {
@@ -222,6 +230,13 @@ export function attachmentSummarySync(bundleDir, name) {
 /**
  * 附件行（只有 bundle 记忆才有）：**给目录与文件名，不给内容**。
  * 附件可能是图片、二进制、大 md —— 全文注入又贵又会把段预算吃光；给路径，模型需要时自己读。
+ *
+ * 2026-09-23 精简（用户看到实际注入后要求）：去掉「未注入正文」这半句解释与「共 N 个」里的
+ * 计数词 —— 目录 + 文件名已经把"内容不在这里、要读就照路径去读"说清楚了，而这两处纯修饰
+ * 每轮都在付钱（实测两行 289 B ≈73 tok/轮，占记忆段的 23%）。总数只在**列不全**时才需要
+ * （否则数一下文件名就知道有几个）。
+ *
+ * **路径必须绝对**：模型拿到它要去 `Read`，相对路径等于没给。所以前缀省不掉。
  */
 export function attachmentLine(file) {
     if (file.kind !== 'bundle')
@@ -231,21 +246,41 @@ export function attachmentLine(file) {
         return '';
     const shown = names.slice(0, ATTACHMENT_LIST_MAX);
     const more = names.length - shown.length;
-    return `附件目录：${file.bundleDir}（未注入正文，共 ${names.length} 个：${shown.join('、')}${more > 0 ? `，另 ${more} 个` : ''}）`;
+    return `附件：${file.bundleDir}（${shown.join('、')}${more > 0 ? ` 等 ${names.length} 个` : ''}）`;
 }
 // ── 单条记忆的渲染 ─────────────────────────────────────────────────────────
-/** 多行正文整体缩进 2 格（列在条目内容列上），空行保持空行、不加尾随空白。 */
-export const indentBody = (text) => text
-    .split('\n')
-    .map((line) => (line === '' ? line : '  ' + line))
-    .join('\n');
+/**
+ * 多行正文的渲染形态：**围栏代码块**，整体缩进 2 格挂在条目下（2026-09-23 用户裁定）。
+ *
+ * 为什么不是"缩进 2 格就完事"（这是上一版的实现，被实测推翻）：markdown 里缩进 ≤3 格的 `#`
+ * **仍然算标题**，所以正文里一句手写的 `# 代码/需求` 会渲染成 H1，**盖过容器自己的
+ * `## 场景：X`** —— 用户看到的就是这个：内容看起来"逃出了条目"，与场景标题平级甚至更高。
+ * 缩到 4 格能压住标题（块级标记都要求 ≤3 格缩进），但正文里的列表/引用只是被"压平"，
+ * 视觉上仍与条目正文同级，达不到"明显从属"。
+ *
+ * 围栏块一次解决两件事（用户 2026-09-23 明确要这两条）：
+ *   - **不能逃出**：块内一切都是字面量，正文的 `#` / `>` / `---` / ``` 再也无法参与外围结构；
+ *   - **明显从属**：`<pre>` 的缩进在渲染视图里可见、复制出来也不丢，正文明确挂在条目下。
+ *
+ * 代价如实记：块内的行内 markdown（`**粗体**`、链接）按字面显示、不再被渲染。记忆正文的定位
+ * 是"记录"（可能过期、以实际情况为准），按字面呈现比让它参与排版更贴合这个定位。
+ *
+ * 围栏用**反引号**且长度取"正文里最长反引号串 + 1"（最少 3 个）：正文自带 ``` 时不会把块
+ * 提前闭合（闭合需要**至少**与开栏等长的反引号串）。
+ */
+export const bodyBlock = (text) => {
+    const longest = (text.match(/`+/g) ?? []).reduce((n, run) => Math.max(n, run.length), 0);
+    const fence = '`'.repeat(Math.max(3, longest + 1));
+    const lines = text.split('\n').map((line) => (line === '' ? line : '  ' + line));
+    return ['  ' + fence, ...lines, '  ' + fence].join('\n');
+};
 /** 括号注解用的显式描述：派生描述与正文重复、不进段（只存在于界面投影）；换行压成单行，避免把「一行一条」的列表项撑断。 */
 export const explicitDescriptionOf = (f) => (f.descriptionDerived || !f.description ? '' : String(f.description).replaceAll(/\s+/g, ' ').trim());
 /**
  * 单条信息的渲染形态 —— **能一行就一行，但恒为列表项**。
  *
  *   单行且不长的正文 → `- **名称**（描述） — 正文`（与 MCP / 子智能体两个段的列表同形；无显式描述时括号不出现）
- *   多行或过长的正文 → `- **名称**（描述）` + 空行 + 缩进 2 格的正文（挂在条目下）
+ *   多行或过长的正文 → `- **名称**（描述）` + 空行 + **围栏代码块里的正文**（挂在条目下；理由见 `bodyBlock`）
  *
  * 名称恒为标题：它就是这条记忆的身份（工具 id `<场景>/<名称>`、bundle 目录/文件名都以它为准），
  * 用户说「记忆里的 X」、模型再调 `memory_manager_*` 时都对得上号；显式描述是括号注解，不抢标题。
@@ -257,7 +292,8 @@ export const explicitDescriptionOf = (f) => (f.descriptionDerived || !f.descript
  *
  * 为什么要分两种：用户常有十几条「一句话事实」（「提交格式：PDF」），每条都占标题 + 空行 +
  * 正文三行，整段会散成一长串标题；压成一行后十条信息就是十行。多行正文是**用户写的完整
- * Markdown**（可能自带标题、代码块、嵌套列表），整体缩进 2 格挂到条目下，结构原样保留。
+ * Markdown**（可能自带标题、代码块、嵌套列表），放进围栏块挂到条目下 —— 上一版让它以普通
+ * 段落参与外围排版，结果正文里的 `#` 会盖过 `## 场景：X`（见 `bodyBlock` 的说明）。
  *
  * 返回值带 `inline`：调用方据此决定下一条记忆前要不要空行（单行条目连续排列，其余空行分隔）。
  */
@@ -269,7 +305,7 @@ export function memoryBlock(file) {
     const inline = text === '' || (!text.includes('\n') && text.length <= INLINE_BODY_MAX);
     const head = text === ''
         ? `- ${title}`
-        : (inline ? `- ${title} — ${text}` : `- ${title}\n\n${indentBody(text)}`);
+        : (inline ? `- ${title} — ${text}` : `- ${title}\n\n${bodyBlock(text)}`);
     const attach = attachmentLine(file);
     if (attach === '')
         return { text: `${head}\n`, inline };

package/lib/memories/service.js

@@ -44,7 +44,7 @@ import { parseSkillDoc, resolveDshHome } from '../skills/core.js';
 import { newTrashId } from '../hub.js';
 // 预算 / 保留场景名 / 段渲染常量（2026-09-19 抽到 ./constants.ts：投影函数与本服务共用，
 // 留在这里会让 projection.ts 反向 import 本文件，形成运行时循环依赖）。
-import { bundleDocName, DEFAULT_MAX_BYTES, GLOBAL_SCENE, LEGACY_BUNDLE_DOC, SHARED_GROUP, SNAPSHOT_TTL_MS, isValidGroupPath, isValidGroupSegment, MEMORIES_TRASH_DIR, fail, } from './constants.js';
+import { bundleDocName, DEFAULT_MAX_BYTES, GLOBAL_SCENE, LEGACY_BUNDLE_DOC, SCENE_CATALOG_MAX_BYTES, SHARED_GROUP, SNAPSHOT_TTL_MS, isValidGroupPath, isValidGroupSegment, MEMORIES_TRASH_DIR, fail, } from './constants.js';
 // 对外契约保持在原路径：本文件此前直接 export 这两个，index.ts 等已按此 import。
 export { GLOBAL_SCENE, GLOBAL_SCENE_LABEL } from './constants.js';
 export { isValidGroupSegment, isValidGroupPath, MEMORIES_INDEX_FILE, MEMORIES_TRASH_DIR } from './constants.js';
@@ -54,7 +54,7 @@ export { parseModeState } from './index-io.js';
 import { enabledSceneOf, normalizeActive, resolveActiveScenes, sceneLabel, sceneOf, sceneOrderOf, } from './projection.js';
 // 索引 IO 组与发现/快照组（2026-09-19 抽出）。
 import { writeFileAtomically, isIndexQuarantined, readIndex, readIndexSync, writeIndex } from './index-io.js';
-import { deriveFromDoc, projectRule, relocateLegacyLayout, buildSnapshot, probeSceneFilesSync, renderSceneMemory } from './snapshot.js';
+import { deriveFromDoc, projectRule, relocateLegacyLayout, buildSnapshot, probeSceneFilesSync, renderSceneCatalog, renderSceneMemory } from './snapshot.js';
 // ── 目录常量与失败约定 ─────────────────────────────────────────────────────
 // 其余跨文件共用的常量与无依赖小工具（message / isValidGroupSegment / isValidGroupPath /
 // MEMORIES_INDEX_FILE）已下沉到 ./constants.ts，避免 index-io / snapshot 反向引本文件。
@@ -161,6 +161,7 @@ export function createMemoriesService(ctx, deps) {
     // 指纹一变（切场景 / 改文件 / 外部编辑器改文件 / 改 enabled）才重读正文并重排。
     // 见文件顶部「两相扫描」注释里为什么不选 fs.watch 方案。
     let sceneCache = null;
+    let sceneCatalogCache = null;
     function sceneMemory() {
         const index = readIndexSync(stateDir);
         const probe = probeSceneFilesSync(memoriesRoot, index, isIndexQuarantined(stateDir));
@@ -540,6 +541,19 @@ export function createMemoriesService(ctx, deps) {
     //     **不判"与文件重复"** —— 预设挂了官方 agent-instructions 时那份正文已经由文件送达
     //     （注入侧会跳过整个域），没挂时（极简）才需要注入兜底；判定在注入器的 `selectInjections` 里。
     const memoryText = () => sceneMemory().text;
+    // 场景段。与记忆段是**两次探测**：`probeSceneFilesSync` 没有内部缓存（signature 本身就是
+    // 扫描的结果，缓存不了），代价是有界的一次目录树 stat（**不读正文**），换来两段各自渲染、
+    // 各自去重 —— 只改场景描述时不会连带重发整段记忆正文。
+    const sceneCatalog = () => {
+        const index = readIndexSync(stateDir);
+        const probe = probeSceneFilesSync(memoriesRoot, index, isIndexQuarantined(stateDir));
+        if (sceneCatalogCache && sceneCatalogCache.signature === probe.signature)
+            return sceneCatalogCache.value;
+        const value = renderSceneCatalog(probe, index, SCENE_CATALOG_MAX_BYTES);
+        sceneCatalogCache = { signature: probe.signature, value };
+        return value;
+    };
+    const sceneCatalogText = () => sceneCatalog().text;
     /**
      * `~/.dsh/AGENTS.md` 正文的上限，与官方那一行的 `maxBytes` 同量级（64 KiB）：超大文件按字节
      * 截断并留一行标记，免得一份手写的巨型基线把上下文撑爆。
@@ -676,6 +690,7 @@ export function createMemoriesService(ctx, deps) {
         ops,
         writeOps,
         memoryText,
+        sceneCatalogText,
         promptText,
         promptFiles,
         refresh,

package/lib/memories/snapshot.js

@@ -11,8 +11,8 @@ import { readdirSync, statSync } from 'node:fs';
 import { cp, lstat, mkdir, readFile, readdir, realpath, rename, rm } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { parseSkillDoc, resolveDshHome, unquote } from '../skills/core.js';
-import { MAX_SOURCE_DEPTH, MAX_DIRECTORIES, MAX_ENTRIES, MAX_DESCRIPTION_LENGTH, DEFAULT_ORDER, DEFAULT_GROUP_ORDER, GLOBAL_SCENE, TRUNCATION_MARKER, DROPPED_HEADING, SCENE_MEMORY_NOTE, SCENE_MEMORY_NOTE_PARTIAL, LEGACY_BUNDLE_DOC, bundleDocName, SEGMENT_RULE_HINT, byteLen, message, isValidGroupSegment } from './constants.js';
-import { ensureSceneRecords, resolveActiveScenes, signatureOfIndex, sceneLabel, sceneHeader, compareSceneBuckets, memoryBlock } from './projection.js';
+import { MAX_SOURCE_DEPTH, MAX_DIRECTORIES, MAX_ENTRIES, MAX_DESCRIPTION_LENGTH, DEFAULT_ORDER, DEFAULT_GROUP_ORDER, GLOBAL_SCENE, TRUNCATION_MARKER, DROPPED_HEADING, SCENE_MEMORY_NOTE, LEGACY_BUNDLE_DOC, bundleDocName, SEGMENT_RULE_HINT, SHARED_GROUP, byteLen, message, isValidGroupSegment } from './constants.js';
+import { ensureSceneRecords, resolveActiveScenes, signatureOfIndex, sceneLabel, sceneHeading, sceneLine, compareSceneBuckets, memoryBlock } from './projection.js';
 import { isIndexQuarantined, readIndex, writeIndex, pathExists, readFileIfExistsSync } from './index-io.js';
 export const identity = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
 // ── 文件工具 ───────────────────────────────────────────────────────────────
@@ -542,7 +542,11 @@ export function renderSceneMemory(probe, index, maxBytes) {
     let seq = 0;
     for (const scene of [...buckets.keys()].sort((a, b) => compareSceneBuckets(a, b, index))) {
         const sceneFiles = (buckets.get(scene) || []).slice().sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
-        const header = sceneHeader(scene, index);
+        // 场景块只留标题：**场景说明归场景段**（`renderSceneCatalog`），否则同一句话会在
+        // 上下文里出现两遍。记忆段要的是"这些条目属于哪个场景"这个分组标签。
+        // `sceneHeading` 只给标题、不自带结尾空行（场景段的 `sceneLine` 才自带），这里补上 ——
+        // 否则标题会与紧跟的引导语/条目贴成一行（`## 场景：全局**以下是…**`）。
+        const header = sceneHeading(scene) + '\n\n';
         for (const file of sceneFiles) {
             const { text: block, inline } = memoryBlock(file);
             candidates.push({
@@ -560,12 +564,15 @@ export function renderSceneMemory(probe, index, maxBytes) {
     }
     /**
      * 选中块 → 段正文（同一场景的 `## 场景：x` 只在首次出现时发出）。
-     * `dropped` 决定引导语用哪一版：真有条目没注入时不再声称「以下就是全部信息」。
+     *
+     * 授权语**只有一版**：2026-09-23 第四次裁定删掉了完整性声明（「以下就是全部信息」），
+     * 于是"按截断状态选长短两版"的自适应失去意义（两版会完全相同），`dropped` 参数一并移除。
+     * 详见 `SCENE_MEMORY_NOTE` 的注释 —— 代价是这一段不再有防探测手段。
      */
-    const renderBody = (selected, dropped) => {
+    const renderBody = (selected) => {
         if (selected.length === 0)
             return '';
-        const note = dropped ? SCENE_MEMORY_NOTE_PARTIAL : SCENE_MEMORY_NOTE;
+        const note = SCENE_MEMORY_NOTE;
         const chunks = [];
         let current = null;
         let buf = '';
@@ -578,10 +585,7 @@ export function renderSceneMemory(probe, index, maxBytes) {
                 if (buf !== '')
                     chunks.push(buf);
                 current = c.scene;
-                // 引导语跟着**场景块**走（场景说明之后、条目之前）：它管的就是下面这些条目，
-                // 放最顶层会飘在场景之外（用户实测反馈「怎么跑到最顶层了」）。场景数有上限
-                // （`global`/`_shared` 恒常启用 + 至多一个启用场景），最多出现 3 次，代价可接受。
-                buf = `${c.header}${note}\n\n`;
+                buf = c.header;
                 prevInline = false;
             }
             const inline = c.inline;
@@ -592,7 +596,17 @@ export function renderSceneMemory(probe, index, maxBytes) {
         }
         if (buf !== '')
             chunks.push(buf);
-        return chunks.join('\n');
+        // 引导语只出现**一次**，放在板块层（第一个场景块之前）。
+        //
+        // 为什么挪上来（用户 2026-09-23 看到实际注入后要求）：此前它跟着**每个场景块**各来一遍
+        // —— 2 个场景就是 272 B ≈68 tok/轮，占记忆段整段的 22%；而且它夹在 `## 场景：X` 与条目
+        // 之间，把"分组"和"内容"隔开了。它管的本来就是整段（授权语讲的是这一整段条目的效力，
+        // 不是某个场景的），放在最前面才对得上。
+        //
+        // 2026-09-23 更早那条「放最顶层会飘在场景之外（用户实测）」的约束**已不成立**：那次是
+        // 板块标题还是 `##`、与场景分组平级，放顶层确实分不清它管谁；现在板块升成 `#` 一级、
+        // 场景分组是 `##` 二级，放在两者之间就是明确的"板块级说明"。
+        return `${note}\n\n${chunks.join('\n')}`;
     };
     const sceneLabelOf = (scene) => sceneLabel(scene);
     /** 未注入清单 + 截断标记，在 `space` 字节内尽量列全（放不下的折叠为一行计数）。 */
@@ -626,11 +640,11 @@ export function renderSceneMemory(probe, index, maxBytes) {
     const missed = [];
     const takenScenes = new Set();
     // 场景标题与引导语也是开销，按「每个首次出现的场景」计进预算 —— 否则它们会挤掉
-    // 本该放得下的记忆（引导语的字节见 SCENE_NOTE_BYTES）。
-    let used = 0;
-    const noteBytes = sceneNoteBytes();
+    // 本该放得下的记忆（引导语的字节见 SCENE_NOTE_BYTES）。引导语现在**整段只算一次**
+    // （放在板块层，见 renderBody），所以直接进初始用量，不再按场景累加。
+    let used = sceneNoteBytes();
     for (const c of candidates) {
-        const headerCost = takenScenes.has(c.scene) ? 0 : byteLen(c.header) + noteBytes;
+        const headerCost = takenScenes.has(c.scene) ? 0 : byteLen(c.header);
         if (used + headerCost + c.item.bytes + markerReserve > maxBytes) {
             missed.push(c);
             continue;
@@ -641,12 +655,12 @@ export function renderSceneMemory(probe, index, maxBytes) {
     }
     missed.sort((a, b) => a.seq - b.seq);
     // ── ② 尾注自身也占字节：放不下就把已入选的块从后往前退回，直到回到预算内 ──
-    let body = renderBody(selected, probe.truncated || missed.length > 0);
+    let body = renderBody(selected);
     let tail = renderTail(missed, maxBytes - byteLen(body), probe.truncated || missed.length > 0);
     while (byteLen(body) + byteLen(tail) > maxBytes && selected.length > 0) {
         missed.push(selected.pop());
         missed.sort((a, b) => a.seq - b.seq);
-        body = renderBody(selected, true);
+        body = renderBody(selected);
         tail = renderTail(missed, maxBytes - byteLen(body), true);
     }
     let text = `${body}${tail}`.replace(/^\n+/, '');
@@ -669,14 +683,91 @@ export function renderSceneMemory(probe, index, maxBytes) {
     };
 }
 /**
- * 段首固定块。以 `\n` 结尾，与场景块 join 后自然空一行。
- * 预算按**较长**的那版算（见 renderSceneMemory），保守一点只会浪费几个字节。
+ * 引导语所占的字节（含它后面的一个空行）。**整段只算一次** —— 它放在板块层（见 renderBody），
+ * 不再跟着场景块重复。
+ *
+ * 注意：模块级不能直接算 —— `byteLen` 是后面才声明的 const，模块初始化期取它会 TDZ 报错。
  */
 /**
- * 引导语所占的字节（含它后面的一个空行）。跟着场景块走，所以按**每个场景**计入段头开销；
- * 用较长的那版（带完整性声明）算，保守一点只会浪费几个字节。
+ * 场景段（`scene-manager-catalog`）：列出**当前启用**的场景，一行一个
+ * （`**「场景名」—— 场景说明**`，见 `sceneLine`）。
  *
- * 注意：模块级不能直接算 —— `byteLen` 是后面才声明的 const，模块初始化期取它会 TDZ 报错。
+ * 为什么从记忆段里拆出来（2026-09-23 用户裁定）：场景说明是"这个场景是干什么的"，记忆条目是
+ * **记录**（权威等级低于用户当场说的）—— 两者性质不同，而原来的实现靠一句话同时管两者。拆开后
+ * 用户能**单独关掉记忆段**（省字节）而保留场景说明。
+ *
+ * 本段**没有任何引导语**：授权语在 2026-09-23 第二次裁定里删掉（上一版把场景说明写成
+ * "一律照办"的约定，而它的实例是「写代码」这种**标签**，让模型"照办一个标签"正是它读不懂
+ * 这一段的原因）；替它补的那句"场景是什么"线索当天也被删了（第三次裁定，连同六个域的动作句
+ * 一起，理由见 `DomainFrame`）。现在本段只有 `sceneLine` 一行 —— 用户的原则是「上下文注入
+ * 就是当前的情况，不需要模型知道没用的信息」。
+ *
+ * 与记忆段的分工：这里给"框架"，记忆段给"内容"（各场景下的条目）。**场景说明只在这里出现**
+ * —— 记忆段的场景块只留标题（`sceneHeading`），否则同一句话会在上下文里出现两遍。代价是
+ * 关掉本段后记忆段少了"这个场景是什么"的语境，但那正是用户关掉它的意思。
+ *
+ * 场景清单取**磁盘目录 ∪ 索引记录**：两者通常一致（建场景时同时落目录与记录），取并集是
+ * 为了手工建的目录 / 手工删过记录的目录也能如实列出。**空场景也列** —— "这个场景存在但还
+ * 没有内容"本身就是框架信息（记忆段只列有记忆的场景，两者不是同一份清单）。
+ *
+ * **只列启用的非保留场景**（排除 `global` / `_shared`）：那两个桶恒常生效，说"当前处于全局"
+ * 是废话 —— 默认状态不该占上下文（用户 2026-09-23 裁定）。一个具体场景都没启用时整段返回
+ * 空串（通道不发这条消息），而不是发一句"当前处于全局"。
+ *
+ * **场景是单选的**：除保留场景（`global` / `_shared`）外至多一个处于启用状态。这条约束由
+ * `rules-set-active`（界面单选）+ `rules-create-scene` 的 `collapseActiveForNewScene`（把
+ * 历史「全部启用」收敛成单选）保证，本函数**只读**、不替用户收敛。历史遗留的"同时启用多个"
+ * 在收敛之前会如实列出多个 —— 注入反映现状，界面另有 `scenes.legacyAll` 提示与一键收敛。
  */
+export function renderSceneCatalog(
+// 只要清单与截断标记：场景段不读正文（`refs` 是记忆段才需要的）。
+probe, index, maxBytes) {
+    const { active } = resolveActiveScenes(index, probe.scenes);
+    const names = new Set([...probe.scenes, ...Object.keys(index.scenes || {})]);
+    const wanted = [...names]
+        .filter((scene) => scene !== '' && scene !== GLOBAL_SCENE && scene !== SHARED_GROUP && active.has(scene))
+        .sort((a, b) => compareSceneBuckets(a, b, index));
+    // 默认状态（只有保留桶生效）：整段不注入。返回空串而不是"当前处于全局"——后者是废话，
+    // 而且会让通道每轮都发一条没有信息量的消息。
+    if (wanted.length === 0) {
+        return { text: '', bytes: 0, truncated: probe.truncated, maxBytes, scenes: [], items: [], dropped: [] };
+    }
+    // 这一段**只给当前情况**：启用了哪些非保留场景、各自是什么（`sceneLine`）。
+    //
+    // 曾经在这里加过一句因果（"下面的记忆、MCP、技能与人设都已按它筛过"），已删（用户
+    // 2026-09-23 裁定）：「上下文注入就是当前的情况，目的是让 agent 知道现在的情况，不需要它
+    // 知道没用的信息，反推更是浪费 token」。那句话解释的是**另外四段是怎么产生的**（机制），
+    // 不是当前情况本身。留着它的两个额外代价也一并消失：① 场景**启用**（`active`）与场景
+    // **进入**（`mode.scene`）是两份状态、两个 op，只启用没进入时那句是假话，得按 mode 分叉
+    // 才能不说错；② 它排在场景名之前时「它」没有指代。
+    const marker = `\n${TRUNCATION_MARKER}\n`;
+    const kept = [];
+    let used = 0;
+    let dropped = false;
+    for (const scene of wanted) {
+        const block = sceneLine(scene, index);
+        // 场景是单选的（至多一个 + 两个保留场景），正常永远碰不到预算 —— 这一层只是不让
+        // "预算被配得极小"变成一段没有边界说明的静默截断。
+        if (used + byteLen(block) + marker.length > maxBytes) {
+            dropped = true;
+            continue;
+        }
+        kept.push(scene);
+        used += byteLen(block);
+    }
+    let text = kept.map((scene) => sceneLine(scene, index)).join('');
+    if (dropped)
+        text += marker;
+    text = text.replace(/^\n+/, '');
+    return {
+        text,
+        bytes: byteLen(text),
+        truncated: probe.truncated || dropped,
+        maxBytes,
+        scenes: kept,
+        items: [],
+        dropped: [],
+    };
+}
 export const sceneNoteBytes = () => byteLen(`${SCENE_MEMORY_NOTE}\n\n`);
 // ── 创建服务 ───────────────────────────────────────────────────────────────

package/lib/op-registry.js

@@ -55,7 +55,7 @@ export const OP_REGISTRY = Object.freeze({
     // 会停在启用态 —— 是写不是读。（0.6.0 / 0.7.0 各有漏列前科，见文件头。）
     'mcpm-tools-refresh': { write: true },
     'mcpm-tools': { readonly: true },
-    // ── 技能域（21，含内联的 skill-open）───────────────────────────────────────
+    // ── 技能域（22，含内联的 skill-open）───────────────────────────────────────
     'skill-state': { annotatesLock: true },
     'skill-detail': { readonly: true },
     'skill-browse': { readonly: true },
@@ -70,6 +70,9 @@ export const OP_REGISTRY = Object.freeze({
     'skill-prefer': { serviceWrite: true, frozen: true },
     'skill-unprefer': { serviceWrite: true, frozen: true },
     'skill-create': { serviceWrite: true, frozen: true },
+    // 改写 hub 里已存在的那一份技能（`skill_manager_save` 的改分支）。与 create 同规格：
+    // 都是往 hub 落文件。它**不动**官方根里的技能 —— 那层边界在 service 的胜出者判定里。
+    'skill-update': { serviceWrite: true, frozen: true },
     'skill-import': { serviceWrite: true, frozen: true },
     'skill-upload': { serviceWrite: true, frozen: true },
     'skill-delete': { serviceWrite: true, frozen: true },
@@ -180,8 +183,11 @@ export const OP_REGISTRY = Object.freeze({
     'scene-settings': { write: true },
     // 清理 patch 备份：删磁盘文件（备份里含明文凭据副本），按写操作门禁。
     'backups-clean': { write: true },
-    // ── 场景候选源（3）与内联（1）──────────────────────────────────────────────
+    // ── 场景候选源（4）与内联（1）──────────────────────────────────────────────
     'model-candidates': { readonly: true },
+    // 思考强度档位：要问 adapter（`llm.resolveModelInfo`，异步、可能联网），但只读不写任何状态
+    // —— 与 model-candidates 同一档。它不进 scene-inventory，是**按需**拉取的。
+    'model-reasoning': { readonly: true },
     'scene-inventory': { readonly: true },
     // 跨域悬空引用体检：只读对账（索引走 readIndexSync，权威集合各读一次）。
     'state-doctor': { readonly: true },