dsh-plugin-tool-management 0.8.5 → 0.9.1

package/lib/rules/service.js

@@ -1,21 +1,23 @@
 // dsh-plugin-tool-management —— 规则/记忆（Rules v0.3，见 CHANGE-REQUEST-01）服务层。
 //
-// 记忆 = $DSH_HOME/tool-management/memories/<场景>/<name>.md（flat）或 <场景>/<name>/SKILL.md（bundle）。
+// 记忆 = $DSH_HOME/tool-management/memories/<场景>/<name>.md（flat）或 <场景>/<name>/<name>.md（bundle）。
+// 历史遗留的 bundle 正文文件名 `SKILL.md` 仍被识别（只读兼容），但新建/更新一律写 `<name>.md`。
 // **场景是显式记录**：$DSH_HOME/tool-management/scenes/<场景>.json（见 SceneRecord），
 // 不再是「memories/ 下恰好有这个名字的目录」这种隐式约定——空场景因此可以存在，
 // 且场景可以有描述。目录名即场景名（任意 Unicode，见 isValidGroupSegment）。
 // 保留场景 `global`（界面显示「全局」）：其记忆注入任何对话；它恒定存在、不可删除。
-// 勾选启用后，该目录树内所有 .md 的正文自动进入系统提示词（provider.ts 注册的
-// per-agent systemPrompt 段），模型无需做任何动作 —— 这就是"不用每次都要解释"。
+// 勾选启用后，该目录树内所有 .md 的正文自动进入模型的上下文（index.ts 注册的注入通道，
+// 每步一条消息；见 src/context-inject.ts），模型无需做任何动作 —— 这就是"不用每次都要解释"。
 //
 // 单投影（原 ADR-4 的"双投影"已被本变更单修订）：
-//   - 活动场景记忆 → systemPrompt 段（自动在场，会话级恒定 → 前缀稳定、缓存可命中）
+//   - 活动场景记忆 → 上下文注入（自动在场，会话级恒定 → 前缀稳定、缓存可命中；
+//     文本没变时不重发 —— 2026-09-16 从 systemPrompt 段改道，理由见 context-inject.ts 文件头）
 //   - `_shared/` 承担"恒常"语义（所有场景共用）；原 per-rule `always` 标志已移除
 //   - 不再写 ~/.dsh/AGENTS.md（原始终层投影下线）
 //
 // 状态分层（两份文件各司其职，互不写回）：
 //   - 规则文件：正文真源。frontmatter 可声明 name/description/whenToUse/globs/metadata。
-//   - rules-index.json：启停/排序/标签/启用场景集合等**索引为准**字段（不写回记忆文件）。
+//   - memories-index.json：启停/排序/标签/启用场景集合等**索引为准**字段（不写回记忆文件）。
 //
 // 发现必须自实现（不复用 readonly-discovery）：可写来源只扫一层会压扁子目录场景，
 // 而规则的目录树天然是多层的；且 readonly-discovery 的 flat 只认顶层。
@@ -31,7 +33,6 @@ import { copyFile, cp, lstat, mkdir, readFile, readdir, realpath, rename, rm, st
 import { basename, dirname, join, resolve } from 'node:path';
 import { parseSkillDoc, renameWithRetry, resolveDshHome, unquote } from '../skills/core.js';
 import { expandUploads, planMemoryImport } from '../imports/upload.js';
-import { SECTION_ORDER, createPromptSectionRegistrar } from '../prompt-sections.js';
 import { normalizePresetId } from '../agents-md/preset-id.js';
 import { normalizeArchive } from './archive.js';
 import { listTrashEntries, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
@@ -47,12 +48,16 @@ const DEFAULT_GROUP_ORDER = 1000; // 新场景默认 order
 const SNAPSHOT_TTL_MS = 1000; // 读路径短 TTL 缓存，吸收 UI 密集轮询
 const DEFAULT_MAX_BYTES = 65536; // 场景记忆段预算上限（字节）
 const TRUNCATION_MARKER = '<!-- truncated -->';
-const DROPPED_HEADING = '## 场景记忆：未注入（超出预算）'; // 段尾清单：让模型知道自己漏了什么
+// 段尾清单：让模型知道自己漏了什么。去掉伞标题后这里也不再挂「场景记忆」前缀 ——
+// 它紧跟在场景块之后，`参考信息` 与段首引导语同一说法。
+const DROPPED_HEADING = '## 未注入的参考信息（超出预算）';
 // bundle 附件限制（body 走 HTTP JSON + base64，故比技能上传收紧一档）。
 const MAX_ATTACH_ENTRY_BYTES = 8 << 20; // 单个附件 8 MiB
 const MAX_ATTACH_TOTAL_BYTES = 16 << 20; // 单次总大小 16 MiB
 const MAX_ATTACH_ENTRIES = 32; // 单次最多 32 个
-const BUNDLE_DOC = 'SKILL.md'; // bundle 的正文文件（附件列表里排除）
+const LEGACY_BUNDLE_DOC = 'SKILL.md'; // 旧版 bundle 的正文文件名；仅在发现/附件排除时作只读兼容，新建一律用 bundleDocName()
+/** bundle 的正文文件名 = `<记忆名>.md`（与目录名一致，不再是固定的 SKILL.md）。 */
+const bundleDocName = (name) => `${name}.md`;
 const SHARED_GROUP = '_shared'; // 保留场景名：公共基线（历史语义，仍可使用）
 const INDEX_VERSION = 1;
 // 场景/子目录段名约束（§4 对照表 + §5.3）：任意 Unicode，但必须对文件系统安全。
@@ -91,13 +96,22 @@ const identity = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
  * 场景/记忆根目录名（$DSH_HOME 下），集中在 `tool-management/` 一个目录内：
  *   - `scenes/<场景>.json`   场景记录（名称/描述/顺序）
  *   - `memories/<场景>/…`    记忆正文真源
- *   - `..`（即 tool-management 根）侧车：rules-index.json / config.json / trash/
+ *   - `..`（即 tool-management 根）侧车：memories-index.json / skills-state.json / trash/
  *
  * 历史位置 `$DSH_HOME/scene-memory/` 由 `relocateLegacyLayout()` 在首次读写前搬入。
  */
 export const HUB_DIR = 'tool-management';
 export const SCENES_DIR = 'scenes';
 export const MEMORIES_DIR = 'memories';
+/**
+ * 记忆索引文件名 / 记忆回收站目录名（hub 根下）。
+ * 域叫「记忆」（工具 `memory_manager_*`、界面「记忆」页），所以按域命名 ——
+ * 旧名 `rules-index.json` / `rules-trash/` 由 hub 的启动迁移搬过来（见 hub.ts）。
+ */
+export const MEMORIES_INDEX_FILE = 'memories-index.json';
+export const MEMORIES_TRASH_DIR = 'memories-trash';
+/** 提示词预设库目录名（hub 根下；域 = 提示词，工具 `prompt_manager_*`）。 */
+export const PRESETS_DIR = 'prompts';
 /** 保留场景名：界面显示「全局」，恒定存在、不可删除，其记忆注入任何对话。 */
 export const GLOBAL_SCENE = 'global';
 /** 保留场景在界面上的显示名（磁盘上仍用 ASCII 目录/文件名）。 */
@@ -105,7 +119,7 @@ export const GLOBAL_SCENE_LABEL = '全局';
 /**
  * 记忆导出的落盘映射（`bundle-export` 的 `kind: 'memories'` 用，见 design-plan D14）。
  *
- * 记忆有两种形态（见文件头）：flat = `<场景>/<name>.md`，bundle = `<场景>/<name>/SKILL.md`；
+ * 记忆有两种形态（见文件头）：flat = `<场景>/<name>.md`，bundle = `<场景>/<name>/<name>.md`；
  * 而且**场景名本身可含 `/`**（多段场景名，见 `isValidGroupPath`）。所以「按 id 的最后一个
  * `/` 切出场景与名字、再拼 `.md`」是错的：bundle 会被读成 `<场景>/<name>.md` → 读不到 →
  * 该项目静默丢失（只在 `missing` 里留个名，界面按「导出成功」显示）。
@@ -143,7 +157,7 @@ export function planMemoryExport(names, rules) {
 /**
  * 同目录临时文件 + rename 原子写（临时名 `.xxx.dsh-rules-<uuid>.tmp`）。
  * rename 走 `renameWithRetry`：Windows 上杀软/索引器会短暂占住目标文件报
- * EPERM/EACCES/EBUSY（用户实测：进入/退出模式时 rules-index.json 被 rename 撞上，
+ * EPERM/EACCES/EBUSY（用户实测：进入/退出模式时 memories-index.json 被 rename 撞上，
  * 运行时已切换但状态落盘失败，界面开关停在旧状态、还得再点一次）。这种占用是
  * 瞬时的，重试几轮就能过去；全失败才清理临时文件并把错误抛出。
  */
@@ -175,8 +189,9 @@ async function writeFileAtomicBinary(path, data) {
  * BFS 发现（realpath 防环、深度/目录/条目预算），与 readonly-discovery 同构，
  * 但规则的场景是**多层相对路径**（readonly-discovery 的 group 恒为第一层）。
  *
- * 目录语义：目录含 SKILL.md → 它是 bundle 规则（叶子，不再深入），其「父路径」
- * 是场景、目录名是规则名；否则它是场景/子分类，继续遍历其下 .md（flat，任意层级）
+ * 目录语义：目录含 `<目录名>.md` → 它是 bundle 规则（叶子，不再深入），其「父路径」
+ * 是场景、目录名是规则名；找不到时再退回认旧文件名 `SKILL.md`（只读兼容，不再新建）；
+ * 都没有则它是场景/子分类，继续遍历其下 .md（flat，任意层级）
  * 与子目录。同名 flat 与 bundle 冲突时 bundle 优先，flat 记入 shadowed。
  */
 async function discover(rulesRoot) {
@@ -241,22 +256,35 @@ async function discover(rulesRoot) {
         catch {
             continue; // 失效链接或不可读目录不阻断其他来源
         }
-        // bundle 检查：当前目录（非根）含 SKILL.md → 它是规则叶子，父路径为场景。
+        // bundle 检查：当前目录含 `<目录名>.md`（或旧版 `SKILL.md`）→ 它是规则叶子，父路径为场景。
+        //
+        // **根下的一级目录恒为场景**（`parentGroup === ''` 时不做 bundle 判断）——与
+        // `probeSceneFilesSync`（注入段）同口径。场景 `1` 里一条叫 `1` 的记忆（`memories/1/1.md`）
+        // 与「根层的 bundle `1`」在磁盘上同形，认成后者会把整个场景目录吃成叶子：同场景其余
+        // 记忆全从列表消失、多出一条「未归属场景」的同名记忆，新建记忆还会被误报「同名 bundle
+        // 遮蔽」（2026-09-16 用户实测）。根层因此没有 bundle，只有 legacy 裸 .md（见 rulesCheck 的 noScene）。
         if (current.group !== '') {
-            const docPath = join(current.path, 'SKILL.md');
-            try {
-                const st = await lstat(docPath);
-                if (st.isFile() && !st.isSymbolicLink()) {
-                    const sepIdx = current.group.lastIndexOf('/');
-                    const parentGroup = sepIdx >= 0 ? current.group.slice(0, sepIdx) : '';
-                    const name = sepIdx >= 0 ? current.group.slice(sepIdx + 1) : current.group;
-                    const id = parentGroup ? `${parentGroup}/${name}` : name;
-                    addEntry({ id, group: parentGroup, name, kind: 'bundle', docPath, entryPath: current.path });
-                    continue;
+            const sepIdx = current.group.lastIndexOf('/');
+            const parentGroup = sepIdx >= 0 ? current.group.slice(0, sepIdx) : '';
+            const name = sepIdx >= 0 ? current.group.slice(sepIdx + 1) : current.group;
+            let docPath = '';
+            if (parentGroup !== '') {
+                for (const candidate of [bundleDocName(name), LEGACY_BUNDLE_DOC]) {
+                    const p = join(current.path, candidate);
+                    try {
+                        const st = await lstat(p);
+                        if (st.isFile() && !st.isSymbolicLink()) {
+                            docPath = p;
+                            break;
+                        }
+                    }
+                    catch { /* 该候选名不存在 → 试下一个 */ }
                 }
             }
-            catch {
-                /* 无 SKILL.md → 作为场景/子分类继续 */
+            if (docPath !== '') {
+                const id = parentGroup ? `${parentGroup}/${name}` : name;
+                addEntry({ id, group: parentGroup, name, kind: 'bundle', docPath, entryPath: current.path });
+                continue;
             }
         }
         if (current.group !== '') {
@@ -458,9 +486,9 @@ export function parseModeState(raw) {
                 list.push(tool);
         }
     }
-    // v2 快照的**服务器级 / 来源级**名单与 v0.8 的子智能体名单必须原样透传 ——
-    // 这里曾把它们剥掉，结果退出模式时两张恢复名单全是空的：服务器级 MCP 与技能来源
-    // 永远不回滚（用户报的「MCP 不复原」「技能目录不回退」），只有工具级 / 技能级能还原。
+    // v2 快照的**服务器级 / 来源级**名单、v0.8 的子智能体名单、v0.9.1 的人设全量映射
+    // 必须原样透传 —— 这里曾把它们剥掉，结果退出模式时两张恢复名单全是空的：服务器级 MCP 与
+    // 技能来源永远不回滚（用户报的「MCP 不复原」「技能目录不回退」），只有工具级 / 技能级能还原。
     const mcpServers = (Array.isArray(snapshotRaw.mcpServers) ? snapshotRaw.mcpServers : [])
         .filter((x) => !!x && typeof x === 'object')
         .map((x) => ({ id: String(x.id || ''), level: String(x.level || ''), disabled: x.disabled === true }))
@@ -470,6 +498,12 @@ export function parseModeState(raw) {
         .map((x) => ({ root: String(x.root || ''), enabled: x.enabled === true }))
         .filter((x) => x.root !== '');
     const subagents = (Array.isArray(snapshotRaw.subagents) ? snapshotRaw.subagents : []).map((x) => String(x)).filter(Boolean);
+    // 同 subagents 一组：进入时被档案**关掉**的人设（退出要重新打开）。漏掉它 = 用户实测的
+    // 「进场景关掉了，退出却没开回来」——快照落盘后读回来就只剩「被启用」那一半名单。
+    const subagentsOn = (Array.isArray(snapshotRaw.subagentsOn) ? snapshotRaw.subagentsOn : []).map((x) => String(x)).filter(Boolean);
+    // v0.9.1 的人设**全量**开关映射（名字 → 进场景时是否开着）：同样必须原样透传 ——
+    // 剥掉它，退出模式就只能退回上面两个部分名单，「场景里手动开过的人设」不再被还原。
+    const subagentsAll = toFlagMap(snapshotRaw.subagentsAll);
     // v0.8.1 的场景备注恢复名单：**必须原样透传**——这里漏掉它，退出模式时备注永不回退
     //（与历史上 mcpServers / skillSources 被剥掉是同一类 bug）。
     const mcpNotes = (Array.isArray(snapshotRaw.mcpNotes) ? snapshotRaw.mcpNotes : [])
@@ -485,12 +519,14 @@ export function parseModeState(raw) {
                 ...(mcpServers.length ? { mcpServers } : {}),
                 ...(skillSources.length ? { skillSources } : {}),
                 ...(subagents.length ? { subagents } : {}),
+                ...(subagentsOn.length ? { subagentsOn } : {}),
+                ...(Object.keys(subagentsAll).length ? { subagentsAll } : {}),
                 ...(mcpNotes.length ? { mcpNotes } : {}),
             }
             : null,
     };
 }
-/** 解析 rules-index.json 原文；任何异常/版本不符 → 默认索引（容忍缺失，§9.3）。 */
+/** 解析 memories-index.json 原文；任何异常/版本不符 → 默认索引（容忍缺失，§9.3）。 */
 function parseIndex(raw) {
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.version !== INDEX_VERSION || typeof parsed.rules !== 'object' || parsed.rules === null)
@@ -507,15 +543,15 @@ function parseIndex(raw) {
 }
 async function readIndex(stateDir) {
     try {
-        return parseIndex(await readFile(join(stateDir, 'rules-index.json'), 'utf8'));
+        return parseIndex(await readFile(join(stateDir, MEMORIES_INDEX_FILE), 'utf8'));
     }
     catch {
         return defaultIndex();
     }
 }
-/** 同步读索引：systemPrompt 段的渲染路径不能 await（见文件内「两相扫描」注释）。 */
+/** 同步读索引：注入文本的渲染路径不能 await（见文件内「两相扫描」注释）。 */
 function readIndexSync(stateDir) {
-    const raw = readFileIfExistsSync(join(stateDir, 'rules-index.json'));
+    const raw = readFileIfExistsSync(join(stateDir, MEMORIES_INDEX_FILE));
     if (raw === null)
         return defaultIndex();
     try {
@@ -527,9 +563,9 @@ function readIndexSync(stateDir) {
 }
 async function writeIndex(stateDir, index) {
     await mkdir(stateDir, { recursive: true });
-    await writeFileAtomically(join(stateDir, 'rules-index.json'), JSON.stringify(index, null, 2));
+    await writeFileAtomically(join(stateDir, MEMORIES_INDEX_FILE), JSON.stringify(index, null, 2));
 }
-// ── 场景记录（索引内，`rules-index.json` 的 scenes 切片）+ 旧布局迁移 ────────
+// ── 场景记录（索引内，`memories-index.json` 的 scenes 切片）+ 旧布局迁移 ────────
 /** 索引条目 → 场景记录（供 UI 直接渲染）。 */
 function sceneRecordOf(name, entry) {
     const e = entry || {};
@@ -658,7 +694,7 @@ function normalizeActive(raw) {
  *     因此"新建即启用"不会发生；存量数据仍按老语义读，避免升级后注入范围突变。
  *   - `_shared` 恒常启用（公共基线），不受开关影响
  *   - 保留场景 `global` 恒常启用：它的记忆对任何对话都成立
- * 缺失 rules-index.json 一律按默认值运行，不抛错（§9.3）。
+ * 缺失 memories-index.json 一律按默认值运行，不抛错（§9.3）。
  * 场景生效与否只由 index.active 决定（场景档案/模式也写这一份）。
  */
 function resolveActiveScenes(index, knownScenes) {
@@ -766,10 +802,10 @@ async function buildSnapshot(rulesRoot, stateDir) {
 }
 // ── 场景记忆段：两相扫描（廉价指纹 → 按需读正文）──────────────────────────
 //
-// 硬约束 1（§5.1）：`systemPrompt.section({ text })` 的 provider 在**每次装配**时
-// 同步求值（`text: string | ((context) => string)`），返回 Promise 会破坏 renderPrompt。
+// 硬约束 1（§5.1）：注入通道每个 step 都要求**同步**取一次文本（`text: () => string`，
+// 见 src/context-inject.ts），返回 Promise 会让这一步的注入直接失败（异常被吞）。
 //
-// 缓存策略（§5.4 S3）：段 provider 必须同步返回 string，但不希望每个模型步骤都
+// 缓存策略（§5.4 S3）：文本出口必须同步返回 string，但不希望每个模型步骤都
 // 读一遍所有记忆正文。因此拆成两相：
 //   ① `probeSceneFilesSync()`：只走目录树 + `statSync`（**不读正文**），产出候选文件
 //      与**指纹**（`id|mtime|size` + 影响渲染的索引字段）。
@@ -781,8 +817,8 @@ async function buildSnapshot(rulesRoot, stateDir) {
 // 一次 stat 遍历（个人记忆树是亚毫秒级），换来"永远最新且永不静默失效"，优先于"零 IO"。
 //
 // 与 discover() 的关系：discover 是异步全量快照（供 CRUD/列表/体检），这里是同步轻量
-// 扫描（供提示词段），两者对"什么是规则"的定义保持一致：
-//   目录含 SKILL.md → bundle 规则（叶子）；否则继续下钻；只认 .md；跳过隐藏项；
+// 扫描（供注入通道），两者对"什么是规则"的定义保持一致：
+//   目录含 `<目录名>.md`（或旧版 `SKILL.md`）→ bundle 规则（叶子）；否则继续下钻；只认 .md；跳过隐藏项；
 //   同名 flat 与 bundle 冲突时 bundle 优先。
 function readFileIfExistsSync(path) {
     try {
@@ -856,14 +892,23 @@ function probeSceneFilesSync(rulesRoot, index) {
                 continue; // 同步扫描不跟随符号链接（防环）
             if (item.isDirectory()) {
                 budget.items++;
-                const skillDoc = join(child, 'SKILL.md');
-                const stamp = fileStampSync(skillDoc);
-                if (stamp !== 'missing') {
+                let docPath = '';
+                for (const candidate of [bundleDocName(item.name), LEGACY_BUNDLE_DOC]) {
+                    const p = join(child, candidate);
+                    if (fileStampSync(p) !== 'missing') {
+                        docPath = p;
+                        break;
+                    }
+                }
+                // 指纹带上**目录本身**的 mtime：附件只在段里以「路径 + 文件名」出现，
+                // 增删附件不改正文文件，只靠它的话指纹不变、段不会重算，列表就会停在旧值。
+                if (docPath !== '') {
+                    const stamp = `${fileStampSync(docPath)}:${fileStampSync(child)}`;
                     // bundle 规则（叶子）：父路径为场景，目录名为记忆名。
                     const id = scene ? `${scene}/${relChild}` : relChild;
                     if (index.rules[id]?.enabled === false)
                         continue; // 单条停用 → 不进入段
-                    add({ id, scene, name: item.name, kind: 'bundle', path: skillDoc, order: index.rules[id]?.order ?? DEFAULT_ORDER, stamp });
+                    add({ id, scene, name: item.name, kind: 'bundle', path: docPath, order: index.rules[id]?.order ?? DEFAULT_ORDER, stamp });
                     continue;
                 }
                 walk(scene, child, relChild, depth + 1);
@@ -946,6 +991,9 @@ function renderSceneMemory(probe, index, maxBytes) {
             descriptionDerived: derived.descriptionDerived,
             order: ref.order,
             body: doc.body,
+            kind: ref.kind,
+            // bundle 的正文是 `<目录>/<名>.md`，附件是**同目录**的其余文件。
+            bundleDir: ref.kind === 'bundle' ? dirname(ref.path) : '',
         });
     }
     const { active } = resolveActiveScenes(index, probe.scenes);
@@ -968,14 +1016,15 @@ 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 = `${sceneHeading(scene)}\n\n${SCENE_MEMORY_NOTE}\n\n`;
+        const header = sceneHeader(scene, index);
         for (const file of sceneFiles) {
-            const block = `### ${ruleHeading(file)}\n\n${String(file.body ?? '').trim()}\n`;
+            const { text: block, inline } = memoryBlock(file);
             candidates.push({
                 seq: seq++,
                 scene,
                 header,
                 block,
+                inline,
                 item: { id: file.id, scene: file.scene, name: file.name, bytes: byteLen(block) },
             });
         }
@@ -983,18 +1032,36 @@ function renderSceneMemory(probe, index, maxBytes) {
     if (candidates.length === 0) {
         return { text: '', bytes: 0, truncated: probe.truncated, maxBytes, scenes: [], items: [], dropped: [] };
     }
-    /** 选中块 → 段正文（同一场景的 `## 场景记忆：x` 只在首次出现时发出一次）。 */
-    const renderBody = (selected) => {
+    /**
+     * 选中块 → 段正文（同一场景的 `## 场景：x` 只在首次出现时发出）。
+     * `dropped` 决定引导语用哪一版：真有条目没注入时不再声称「以下就是全部信息」。
+     */
+    const renderBody = (selected, dropped) => {
+        if (selected.length === 0)
+            return '';
+        const note = dropped ? SCENE_MEMORY_NOTE_PARTIAL : SCENE_MEMORY_NOTE;
         const chunks = [];
         let current = null;
         let buf = '';
+        // 上一条是不是「单行条目」。连续两条单行条目紧挨着（列表的自然形态），
+        // 其余情况都要空一行 —— 多行正文（含其缩进挂载的附件行）与下一条之间没有空行的话，
+        // 读起来会连成一片、看不出条目边界。
+        let prevInline = false;
         for (const c of selected) {
             if (c.scene !== current) {
                 if (buf !== '')
                     chunks.push(buf);
                 current = c.scene;
-                buf = c.header;
+                // 引导语跟着**场景块**走（场景说明之后、条目之前）：它管的就是下面这些条目，
+                // 放最顶层会飘在场景之外（用户实测反馈「怎么跑到最顶层了」）。场景数有上限
+                // （`global`/`_shared` 恒常启用 + 至多一个启用场景），最多出现 3 次，代价可接受。
+                buf = `${c.header}${note}\n\n`;
+                prevInline = false;
             }
+            const inline = c.inline;
+            if (!(inline && prevInline) && !buf.endsWith('\n\n'))
+                buf += '\n';
+            prevInline = inline;
             buf += c.block;
         }
         if (buf !== '')
@@ -1032,9 +1099,12 @@ function renderSceneMemory(probe, index, maxBytes) {
     const selected = [];
     const missed = [];
     const takenScenes = new Set();
+    // 场景标题与引导语也是开销，按「每个首次出现的场景」计进预算 —— 否则它们会挤掉
+    // 本该放得下的记忆（引导语的字节见 SCENE_NOTE_BYTES）。
     let used = 0;
+    const noteBytes = sceneNoteBytes();
     for (const c of candidates) {
-        const headerCost = takenScenes.has(c.scene) ? 0 : byteLen(c.header);
+        const headerCost = takenScenes.has(c.scene) ? 0 : byteLen(c.header) + noteBytes;
         if (used + headerCost + c.item.bytes + markerReserve > maxBytes) {
             missed.push(c);
             continue;
@@ -1045,12 +1115,12 @@ function renderSceneMemory(probe, index, maxBytes) {
     }
     missed.sort((a, b) => a.seq - b.seq);
     // ── ② 尾注自身也占字节：放不下就把已入选的块从后往前退回，直到回到预算内 ──
-    let body = renderBody(selected);
+    let body = renderBody(selected, probe.truncated || missed.length > 0);
     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);
+        body = renderBody(selected, true);
         tail = renderTail(missed, maxBytes - byteLen(body), true);
     }
     let text = `${body}${tail}`.replace(/^\n+/, '');
@@ -1105,15 +1175,175 @@ function sceneLabel(scene, index) {
     const label = index?.scenes?.[scene]?.label;
     return label && label !== '' ? label : scene;
 }
-/** 场景标题：`''` → 全局；其余用目录名（可追溯）。 */
-const sceneHeading = (scene) => `## 场景记忆：${sceneLabel(scene)}`;
+/** 单个场景的标题：**场景在最顶层**（`##`，与「子智能体」「MCP 服务器」等段同级）。 */
+const sceneHeading = (scene) => `## 场景：${sceneLabel(scene)}`;
+/**
+ * 没填描述时的默认「场景说明」（用户裁定 2026-09-16：全局桶一直没有描述，读起来像缺了一块，
+ * 统一成"每个场景块都有场景说明"）。
+ *
+ * 默认句同时承担"这个场景是什么"的答疑（此前只有光秃秃的 `## 场景：X`，模型读不懂 —— 用户实测）：
+ * 两个恒常桶说明生效范围，用户场景说明它是当前启用的那份配置。
+ */
+const defaultSceneDescription = (scene) => (scene === GLOBAL_SCENE ? '全局记忆，任何对话都生效'
+    : scene === SHARED_GROUP ? '共享记忆，任何对话都生效'
+        : '用户配置的上下文，当前启用');
+/**
+ * 单个场景的段头：场景标题 + **恒有**的 `场景说明：<描述>`。
+ *
+ * 场景描述（界面「描述（可选）」，≤60 字符）**此前从未注入过** —— 它正是「这个场景是
+ * 干什么的」的答案，属于模型做判断需要的上下文，而不是只给人看的元数据；界面上的文案
+ * 也从没把它标成「只给使用者看」（对比 AGENTS.md 预设的描述，那里是明确标注的）。
+ * 描述为空时给 `defaultSceneDescription` 的默认句（用户裁定：全局桶没描述时读起来像
+ * 缺了一块，统一成每个场景块都有说明）。
+ */
+function sceneHeader(scene, index) {
+    const head = sceneHeading(scene);
+    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`;
+}
+/**
+ * 段首的引导语：让模型知道下面是**用户提供的参考信息**，而不是对话历史或临时说明
+ * —— 相关就用、无关可忽略。
+ *
+ * 写法（2026-09-16 用户裁定，基于真实注入结果的三次修正）：
+ *   - **单行、加粗**，不再用括号分两行 —— 括号跨行在真实提示词里读起来像被截断，
+ *     而加粗是 Markdown 里最省字符的强调手段（用户要求「加强模型对此的重视程度」）。
+ *   - **提到段首、整段只出现一次**：原来它挂在每个场景的段头里，多场景时会重复注入。
+ *   - **不点名任何工具**：模型从工具 schema 就知道 `memory_manager_list` 存在，点名反而
+ *     像在提示它去调；用户裁定「没启用的信息就是不想在当前用」，所以工具指引整句删除。
+ *     真正防探测的是**完整性声明**（「以下就是全部信息」），那半句必须留。
+ *   - **完整性声明按截断状态自适应**：真有条目因预算没注入时，段尾会有未注入清单，
+ *     此时不能再声称「全部」，否则和清单自相矛盾 —— 也正因为那时确实有东西没给到，
+ *     模型去查工具是**合理**的，不该再拦。
+ *
+ * 用词：不用「常驻」「注入」这类内部行话（模型没有先验）；用户裁定用「信息」而不是
+ * 「记忆」——「记忆」在系统提示词里指代不明，而这段的实质就是用户写的参考信息。
+ */
+const SCENE_MEMORY_NOTE = '**用户提供的参考信息：与当前任务相关时直接采用，无关时忽略。以下就是全部信息。**';
+/** 有未注入条目时的版本：去掉完整性声明（见上）。 */
+const SCENE_MEMORY_NOTE_PARTIAL = '**用户提供的参考信息：与当前任务相关时直接采用，无关时忽略。**';
+/**
+ * 段首固定块。以 `\n` 结尾，与场景块 join 后自然空一行。
+ * 预算按**较长**的那版算（见 renderSceneMemory），保守一点只会浪费几个字节。
+ */
+/**
+ * 引导语所占的字节（含它后面的一个空行）。跟着场景块走，所以按**每个场景**计入段头开销；
+ * 用较长的那版（带完整性声明）算，保守一点只会浪费几个字节。
+ *
+ * 注意：模块级不能直接算 —— `byteLen` 是后面才声明的 const，模块初始化期取它会 TDZ 报错。
+ */
+const sceneNoteBytes = () => byteLen(`${SCENE_MEMORY_NOTE}\n\n`);
+/** 单行正文的最大长度：超过就退回「标题 + 正文块」，避免出现一条几千字符的列表行。 */
+const INLINE_BODY_MAX = 120;
+/** 附件行里最多列几个文件名；多的只报总数（路径已经给了，缺的名字模型自己列目录即可）。 */
+const ATTACHMENT_LIST_MAX = 10;
+/**
+ * bundle 记忆的附件名（**同步**版 —— 段渲染必须同步返回，`listAttachments` 是异步的）。
+ * 口径与异步版一致：跳过正文本体（`<名>.md`，旧数据可能是 `SKILL.md`），只认普通文件。
+ */
+function attachmentNamesSync(bundleDir, name) {
+    try {
+        const docNames = new Set([bundleDocName(name), LEGACY_BUNDLE_DOC]);
+        return readdirSync(bundleDir, { withFileTypes: true })
+            .filter((e) => e.isFile() && !docNames.has(e.name))
+            .map((e) => e.name)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * bundle 记忆的附件**摘要**（列表页用）：数量 / 总体积 / 前几个文件名。
+ *
+ * 口径与 `attachmentNamesSync`（也就是注入给模型的那份清单）逐字一致：跳过正文本体，
+ * 只认普通文件 —— 所以页面上的数字与模型实际看到的一致，不会出现「界面说 3 个、模型只见 2 个」。
+ * `names` 截到 ATTACHMENT_LIST_MAX：tooltip 列不下更多，要全看到编辑弹窗里去看。
+ *
+ * 目录读不到（索引残留了已消失的条目）→ 返回 null，让界面**什么都不显示**，
+ * 而不是谎报「0 个附件」。
+ */
+function attachmentSummarySync(bundleDir, name) {
+    let names;
+    try {
+        const docNames = new Set([bundleDocName(name), LEGACY_BUNDLE_DOC]);
+        names = readdirSync(bundleDir, { withFileTypes: true })
+            .filter((e) => e.isFile() && !docNames.has(e.name))
+            .map((e) => e.name)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return null;
+    }
+    let bytes = 0;
+    for (const entry of names) {
+        try {
+            bytes += statSync(join(bundleDir, entry)).size;
+        }
+        catch { /* 读不到的条目不计体积 */ }
+    }
+    return { count: names.length, bytes, names: names.slice(0, ATTACHMENT_LIST_MAX) };
+}
+/**
+ * 附件行（只有 bundle 记忆才有）：**给目录与文件名，不给内容**。
+ * 附件可能是图片、二进制、大 md —— 全文注入又贵又会把段预算吃光；给路径，模型需要时自己读。
+ */
+function attachmentLine(file) {
+    if (file.kind !== 'bundle')
+        return '';
+    const names = attachmentNamesSync(file.bundleDir, file.name);
+    if (names.length === 0)
+        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} 个` : ''}）`;
+}
 /**
- * 场景标题后的固定引导语（常量，不破坏前缀缓存稳定）：让模型知道这段是当前场景的
- * 常驻参考知识，而不是对话历史或临时说明 —— 相关就用、无关可忽略。
+ * 单条信息的渲染形态 —— **能一行就一行，但恒为列表项**。
+ *
+ *   单行且不长的正文 → `- **名称**（描述） — 正文`（与 MCP / 子智能体两个段的列表同形；无显式描述时括号不出现）
+ *   多行或过长的正文 → `- **名称**（描述）` + 空行 + 缩进 2 格的正文（挂在条目下）
+ *
+ * 名称恒为标题：它就是这条记忆的身份（工具 id `<场景>/<名称>`、bundle 目录/文件名都以它为准），
+ * 用户说「记忆里的 X」、模型再调 `memory_manager_*` 时都对得上号；显式描述是括号注解，不抢标题。
+ *
+ * 为什么全都做成列表项：早先多行正文走 `### 名称` 标题块，附件行只能退化成与记忆**同级**的
+ * `- 附件目录：…`（没有父列表项可挂）—— 既可能被读成一条独立记忆，某些渲染器里还会把下一个
+ * `###` 标题吞进列表（与上一条粘连）。统一成「一条记忆 = 一个列表项、正文与附件都缩进挂在
+ * 条目下」后，两种记忆外观完全一致，归属也不再靠位置猜测。
+ *
+ * 为什么要分两种：用户常有十几条「一句话事实」（「提交格式：PDF」），每条都占标题 + 空行 +
+ * 正文三行，整段会散成一长串标题；压成一行后十条信息就是十行。多行正文是**用户写的完整
+ * Markdown**（可能自带标题、代码块、嵌套列表），整体缩进 2 格挂到条目下，结构原样保留。
+ *
+ * 返回值带 `inline`：调用方据此决定下一条记忆前要不要空行（单行条目连续排列，其余空行分隔）。
  */
-const SCENE_MEMORY_NOTE = '（本场景的常驻参考知识：与当前任务相关时直接采用，无关时忽略）';
-/** 单条记忆的标题：显式 description 优先；派生描述与正文重复，改用文件名。 */
-const ruleHeading = (f) => (f.descriptionDerived || !f.description ? f.name : f.description);
+function memoryBlock(file) {
+    const desc = explicitDescriptionOf(file);
+    // 加粗的只有名称：`- **名称**（描述） — 正文`，与 MCP 段 `- **server**（N 个工具） — …` 同形。
+    const title = `**${file.name}**` + (desc === '' ? '' : `（${desc}）`);
+    const text = String(file.body ?? '').trim();
+    const inline = text === '' || (!text.includes('\n') && text.length <= INLINE_BODY_MAX);
+    const head = text === ''
+        ? `- ${title}`
+        : (inline ? `- ${title} — ${text}` : `- ${title}\n\n${indentBody(text)}`);
+    const attach = attachmentLine(file);
+    if (attach === '')
+        return { text: `${head}\n`, inline };
+    // 附件行恒为缩进子项：只用 `- ` 会被解析成与记忆**同级**的列表项（`- A` / `- 附件目录：A的` /
+    // `- B` … 四条平级，归属读不出来）。单行条目紧跟其后保持列表连续；多行条目前面空一行，
+    // 免得被读成用户正文自己的列表项。
+    return { text: inline ? `${head}\n  - ${attach}\n` : `${head}\n\n  - ${attach}\n`, inline };
+}
+/** 多行正文整体缩进 2 格（列在条目内容列上），空行保持空行、不加尾随空白。 */
+const indentBody = (text) => text
+    .split('\n')
+    .map((line) => (line === '' ? line : '  ' + line))
+    .join('\n');
+/** 括号注解用的显式描述：派生描述与正文重复、不进段（只存在于界面投影）；换行压成单行，避免把「一行一条」的列表项撑断。 */
+const explicitDescriptionOf = (f) => (f.descriptionDerived || !f.description ? '' : String(f.description).replaceAll(/\s+/g, ' ').trim());
 const byteLen = (s) => Buffer.byteLength(s, 'utf8');
 // ── 创建服务 ───────────────────────────────────────────────────────────────
 export function createRulesService(ctx, deps) {
@@ -1175,10 +1405,10 @@ export function createRulesService(ctx, deps) {
         sceneCache = { signature: probe.signature, value };
         return value;
     }
-    // ── 场景提示词段（绑定预设正文；只读，绝不写 ~/.dsh/AGENTS.md）──────────────
+    // ── 场景提示词（绑定预设正文；读盘、只读；写文件由 scene-prompt-sync.ts 负责）──
     //
     // 语义（用户裁定 2026-09-15）：
-    //   - 场景可绑定**一个**提示词预设（`scenes[].prompt` → `agents-md/<id>/AGENTS.md`）；
+    //   - 场景可绑定**一个**提示词预设（`scenes[].prompt` → `prompts/<id>/AGENTS.md`）；
     //   - 除保留场景 `global` 外**同时只能启用一个场景**，所以同一时刻至多一份提示词在场；
     //   - 没有启用其它场景时才轮到 `global` 自己的绑定（它恒常生效，覆盖"永远在场的提示词"）；
     //   - 预设文件不存在 / 未绑定 → 返回 `''`（renderPrompt 会删掉空段，不产生空标题）。
@@ -1189,7 +1419,7 @@ export function createRulesService(ctx, deps) {
     const promptFileCache = new Map();
     /** 读一个预设正文（同步、带 stat 指纹缓存）；不存在返回 `''`。 */
     function readPresetTextSync(id) {
-        const file = join(stateDir, 'agents-md', id, 'AGENTS.md');
+        const file = join(stateDir, PRESETS_DIR, id, 'AGENTS.md');
         let key;
         try {
             const st = statSync(file);
@@ -1217,7 +1447,7 @@ export function createRulesService(ctx, deps) {
     /** 预设文件是否存在（同步；绑定前校验用，避免悬空绑定）。 */
     function presetExistsSync(id) {
         try {
-            return statSync(join(stateDir, 'agents-md', id, 'AGENTS.md')).isFile();
+            return statSync(join(stateDir, PRESETS_DIR, id, 'AGENTS.md')).isFile();
         }
         catch {
             return false;
@@ -1254,24 +1484,13 @@ export function createRulesService(ctx, deps) {
         return text;
     }
     /**
-     * 当前生效的场景提示词：启用场景的绑定优先，其次 `global` 的绑定；都没有则 `''`。
-     * 绑定内容与 `~/.dsh/AGENTS.md` 相同时标记 `duplicate` 且返回空段 —— 那份正文已经在
-     * 基线里了，再注入一遍只会把同样的内容塞进上下文两次。
+     * 当前生效的场景提示词：启用场景的绑定优先，其次 `global` 的绑定；都没有 → `null`。
+     * 「绑了但预设为空/已删」按没绑处理（不注入空段），继续找下一个。
      */
-    function scenePrompt() {
+    function resolveScenePreset() {
         const index = readIndexSync(stateDir);
         const names = Object.keys(index.scenes || {});
         const { active } = resolveActiveScenes(index, names);
-        const globalText = readGlobalAgentsMdSync().trim();
-        /** 绑定 → 投影；与文件一致时是 duplicate（不注入），否则原样注入。 */
-        const project = (scene, id) => {
-            const text = readPresetTextSync(id);
-            if (text.trim() === '')
-                return { scene, presetId: id, text: '', missing: true };
-            if (globalText !== '' && text.trim() === globalText)
-                return { scene, presetId: id, text: '', missing: false, duplicate: true };
-            return { scene, presetId: id, text, missing: false };
-        };
         // 单选：取唯一一个非保留启用场景（resolveActiveScenes 已保证 ≤1，这里仍做确定性排序兜底）。
         const enabled = names
             .filter((n) => n !== SHARED_GROUP && n !== GLOBAL_SCENE && active.has(n))
@@ -1280,27 +1499,35 @@ export function createRulesService(ctx, deps) {
             const id = index.scenes?.[scene]?.prompt;
             if (!id)
                 continue;
-            const projected = project(scene, id);
+            const text = readPresetTextSync(id);
             // 绑了但预设为空/已删 → 继续找下一个（不注入空段）。
-            if (projected.missing)
+            if (text.trim() === '')
                 continue;
-            return projected;
+            return { scene, presetId: id, text };
         }
         const globalId = index.scenes?.[GLOBAL_SCENE]?.prompt;
-        if (globalId)
-            return project(GLOBAL_SCENE, globalId);
-        return { scene: null, presetId: null, text: '', missing: false };
-    }
-    const providerInvalidators = new Set();
-    /** 通知已注册的 provider 提示词已变化（best-effort）。 */
-    const invalidateProviders = () => {
-        for (const invalidate of providerInvalidators) {
-            try {
-                invalidate();
-            }
-            catch { /* 单个失效失败不影响其余 */ }
+        if (globalId) {
+            const text = readPresetTextSync(globalId);
+            if (text.trim() !== '')
+                return { scene: GLOBAL_SCENE, presetId: globalId, text };
         }
-    };
+        return null;
+    }
+    /**
+     * 当前生效的场景提示词（只读投影，界面用）：绑定内容与 `~/.dsh/AGENTS.md` 相同时标记
+     * `duplicate` 且返回空段 —— 那份正文已经在基线里了，界面据此显示「生效中」。
+     * （注入侧不看这个字段：预设挂不到 AGENTS.md 通道时照样要注入，见 `promptText`。）
+     */
+    function scenePrompt() {
+        const found = resolveScenePreset();
+        if (!found)
+            return { scene: null, presetId: null, text: '', missing: false };
+        const globalText = readGlobalAgentsMdSync().trim();
+        if (globalText !== '' && found.text.trim() === globalText) {
+            return { scene: found.scene, presetId: found.presetId, text: '', missing: false, duplicate: true };
+        }
+        return { scene: found.scene, presetId: found.presetId, text: found.text, missing: false };
+    }
     // ── 写操作串行队列（避免并发覆盖同一索引/文件）──
     let mutationQueue = Promise.resolve();
     const enqueueMutation = (task) => {
@@ -1322,17 +1549,26 @@ export function createRulesService(ctx, deps) {
             return null;
         return { group, name };
     }
-    /** 磁盘定位（bundle 优先）。返回规则文件与条目路径。 */
+    /**
+     * 磁盘定位（bundle 优先）。返回规则文件与条目路径。
+     * 根层（`group === ''`）**没有 bundle**：一级目录恒为场景（见 discover 的注释），
+     * 否则 `memories/1/1.md`（场景 1 的 flat 记忆 1）会被这里读成根层 bundle「1」，
+     * 与列表/注入两端不一致（编辑、删除都会落到错误的文件上）。
+     */
     async function locateRule(group, name) {
-        const bundleDir = join(rulesRoot, group, name);
-        const bundleDoc = join(bundleDir, 'SKILL.md');
-        try {
-            const st = await lstat(bundleDoc);
-            if (st.isFile() && !st.isSymbolicLink()) {
-                return { id: group ? `${group}/${name}` : name, group, name, kind: 'bundle', docPath: bundleDoc, entryPath: bundleDir };
+        if (group !== '') {
+            const bundleDir = join(rulesRoot, group, name);
+            for (const candidate of [bundleDocName(name), LEGACY_BUNDLE_DOC]) {
+                const bundleDoc = join(bundleDir, candidate);
+                try {
+                    const st = await lstat(bundleDoc);
+                    if (st.isFile() && !st.isSymbolicLink()) {
+                        return { id: group ? `${group}/${name}` : name, group, name, kind: 'bundle', docPath: bundleDoc, entryPath: bundleDir };
+                    }
+                }
+                catch { /* 该候选名不存在 → 试下一个 */ }
             }
         }
-        catch { /* 非 bundle */ }
         const flatPath = join(rulesRoot, group, name + '.md');
         try {
             const st = await lstat(flatPath);
@@ -1407,7 +1643,6 @@ export function createRulesService(ctx, deps) {
     const refresh = async () => {
         invalidateSnapshot();
         sceneCache = null;
-        invalidateProviders();
     };
     /** 场景档案引擎专用：读-改-写 mode/archives/active 切片（写队列内，保持与其余索引写串行）。 */
     const patchIndex = (patch) => enqueueMutation(async () => {
@@ -1467,7 +1702,16 @@ export function createRulesService(ctx, deps) {
         const index = await readIndex(stateDir);
         const rules = snap.rules
             .filter((r) => !groupFilter || r.group === groupFilter)
-            .sort((a, b) => a.group.localeCompare(b.group) || a.order - b.order || a.name.localeCompare(b.name));
+            .sort((a, b) => a.group.localeCompare(b.group) || a.order - b.order || a.name.localeCompare(b.name))
+            // bundle 记忆附带附件摘要（用户裁定 2026-09-17）：界面要显示「几个附件」。
+            // 每条 bundle 一次 readdirSync + 每个附件一次 statSync —— bundle 记忆通常只有几条，
+            // 这个开销可以忽略；flat 没有目录，直接原样返回（不加字段 = 界面不显示附件标签）。
+            .map((r) => {
+            if (r.form !== 'bundle')
+                return r;
+            const attach = attachmentSummarySync(dirname(r.path), r.name);
+            return attach ? { ...r, attach } : r;
+        });
         const groups = groupFilter ? snap.groups.filter((g) => g.name === groupFilter) : snap.groups;
         const scenes = sceneRows(snap, index);
         // 场景锁定状态（v0.8）：任意一个场景锁定 = 五个管理域整体冻结。界面据此禁用各页的写控件。
@@ -1488,8 +1732,11 @@ export function createRulesService(ctx, deps) {
             activeScene: enabledSceneOf(index),
             sceneMemory: { usedBytes: projection.bytes, maxBytes: projection.maxBytes, truncated: projection.truncated, dropped: projection.dropped },
             // 当前生效的场景提示词（绑定的预设正文；与 ~/.dsh/AGENTS.md 一致时不重复注入）。
+            // `label` 是给用户指路用的显示名（「去场景设置里改『全局』的绑定」）——`global`
+            // 这类磁盘名直接甩给用户看没有意义。
             scenePrompt: {
                 scene: promptProjection.scene,
+                label: promptProjection.scene ? sceneLabel(promptProjection.scene, index) : null,
                 presetId: promptProjection.presetId,
                 missing: promptProjection.missing,
                 duplicate: promptProjection.duplicate === true,
@@ -1525,7 +1772,7 @@ export function createRulesService(ctx, deps) {
             rule: {
                 ...rule,
                 body: doc.body,
-                attachments: entry.kind === 'bundle' ? await listAttachments(entry.entryPath) : [],
+                attachments: entry.kind === 'bundle' ? await listAttachments(entry.entryPath, entry.name) : [],
                 frontmatter: {
                     name: doc.map.name != null ? String(doc.map.name) : undefined,
                     description: doc.map.description != null ? String(doc.map.description) : undefined,
@@ -1648,9 +1895,11 @@ export function createRulesService(ctx, deps) {
         if (!isValidGroupSegment(name))
             return fail('error.rules.invalidName', `记忆名非法：${name}（非空、≤${MAX_GROUP_SEGMENT_LENGTH} 字符、不含 / \\ < > : " | ? *、不以 . 开头）`);
         // 目标已存在（bundle 或 flat 皆算）→ 拒绝，避免静默覆盖。
+        // 用 exists 而不是 shadowed：后者说的是「同名 bundle 把 flat 遮蔽了」，用户看到
+        // 「被同名 bundle 遮蔽」会去找一个并不存在的 bundle（2026-09-16 实测）。
         const existing = await locateRule(group, name);
         if (existing) {
-            return fail('error.rules.shadowed', `同名规则已存在（${existing.kind === 'bundle' ? 'bundle' : 'flat'}）：${group}/${name}`);
+            return fail('error.rules.exists', `同名记忆已存在（${existing.kind === 'bundle' ? 'bundle' : 'flat'}）：${existing.id}`);
         }
         const body = String((args && args.body) ?? '');
         if (body.trim() === '')
@@ -1679,7 +1928,7 @@ export function createRulesService(ctx, deps) {
         const text = serializeRuleFile(fields, body);
         if (form === 'bundle') {
             await mkdir(join(rulesRoot, targetGroup, name), { recursive: true });
-            await writeFileAtomically(join(rulesRoot, targetGroup, name, 'SKILL.md'), text);
+            await writeFileAtomically(join(rulesRoot, targetGroup, name, bundleDocName(name)), text);
         }
         else {
             await mkdir(join(rulesRoot, targetGroup), { recursive: true });
@@ -1696,7 +1945,6 @@ export function createRulesService(ctx, deps) {
             index.groups[targetGroup] = { order: DEFAULT_GROUP_ORDER, label: targetGroup };
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, rule: await buildProjected(createdId) };
     }
     /**
@@ -1781,10 +2029,10 @@ export function createRulesService(ctx, deps) {
             const id = `${item.group}/${item.name}`;
             try {
                 if (item.kind === 'bundle') {
-                    // 与 rules-create 同落点：bundle = <场景>/<名>/ 目录，正文 SKILL.md，附件平铺同层。
+                    // 与 rules-create 同落点：bundle = <场景>/<名>/ 目录，正文 <名>.md，附件平铺同层。
                     const bundleDir = join(rulesRoot, item.group, item.name);
                     await mkdir(bundleDir, { recursive: true });
-                    await writeFileAtomically(join(bundleDir, 'SKILL.md'), item.text);
+                    await writeFileAtomically(join(bundleDir, bundleDocName(item.name)), item.text);
                     for (const att of item.attachments)
                         await writeFileAtomicBinary(join(bundleDir, att.name), att.data);
                 }
@@ -1887,7 +2135,7 @@ export function createRulesService(ctx, deps) {
         }
         else if (located.kind === 'flat' && newForm === 'bundle') {
             await mkdir(join(rulesRoot, parts.group, newName), { recursive: true });
-            await writeFileAtomically(join(rulesRoot, parts.group, newName, 'SKILL.md'), serialize());
+            await writeFileAtomically(join(rulesRoot, parts.group, newName, bundleDocName(newName)), serialize());
             await rm(join(rulesRoot, parts.group, parts.name + '.md'), { force: true });
         }
         else if (located.kind === 'flat' && newName !== parts.name) {
@@ -1911,7 +2159,6 @@ export function createRulesService(ctx, deps) {
         }
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, rule: await buildProjected(newId) };
     }
     async function rulesRemove(args) {
@@ -1923,7 +2170,7 @@ export function createRulesService(ctx, deps) {
         if (!located)
             return fail('error.rules.notFound', `规则不存在：${id}`);
         const trashId = Date.now().toString(36) + '-' + randomUUID().slice(0, 8);
-        const trashDir = join(stateDir, 'rules-trash', trashId);
+        const trashDir = join(stateDir, MEMORIES_TRASH_DIR, trashId);
         const manifest = { group: parts.group, name: parts.name, form: located.kind, deletedAt: new Date().toISOString() };
         await mkdir(trashDir, { recursive: true });
         if (located.kind === 'bundle') {
@@ -1940,14 +2187,13 @@ export function createRulesService(ctx, deps) {
         delete index.rules[id];
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, trashId };
     }
     async function rulesRestore(args) {
         const trashId = String((args && args.trashId) || '');
         if (!isValidTrashId(trashId))
             return fail('error.rules.notFound', `回收站条目不存在：${trashId}`);
-        const trashDir = join(stateDir, 'rules-trash', trashId);
+        const trashDir = join(stateDir, MEMORIES_TRASH_DIR, trashId);
         let manifest;
         try {
             manifest = JSON.parse(await readFile(join(trashDir, 'manifest.json'), 'utf8'));
@@ -1961,7 +2207,7 @@ export function createRulesService(ctx, deps) {
         // 恢复目标已存在（期间用户重建了同名规则）→ 拒绝，避免覆盖。
         const conflict = await locateRule(manifest.group, manifest.name);
         if (conflict) {
-            return fail('error.rules.shadowed', `同名规则已存在：${manifest.group}/${manifest.name}，请先移除后再恢复`);
+            return fail('error.rules.exists', `同名记忆已存在：${conflict.id}，请先移除后再恢复`);
         }
         const form = manifest.form === 'bundle' ? 'bundle' : 'flat';
         if (form === 'bundle') {
@@ -1975,7 +2221,6 @@ export function createRulesService(ctx, deps) {
         }
         await rm(trashDir, { recursive: true, force: true });
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, rule: await buildProjected(manifest.group ? `${manifest.group}/${manifest.name}` : manifest.name) };
     }
     /** trashId 只由本插件生成（时间戳 base36 + uuid 前 8 位）：严格白名单，杜绝路径穿越。 */
@@ -1983,11 +2228,11 @@ export function createRulesService(ctx, deps) {
         return /^[a-z0-9]+-[a-z0-9]{1,32}$/i.test(trashId);
     }
     /**
-     * 记忆回收站列表（只读）：`<stateDir>/rules-trash/<trashId>/`（`rulesRemove` 移入，
+     * 记忆回收站列表（只读）：`<stateDir>/memories-trash/<trashId>/`（`rulesRemove` 移入，
      * `rulesRestore` 恢复）。损坏或内容缺失的条目跳过，不让一个坏条目挡住整份列表。
      */
     async function rulesTrashList() {
-        const root = join(stateDir, 'rules-trash');
+        const root = join(stateDir, MEMORIES_TRASH_DIR);
         let ids = [];
         try {
             ids = await readdir(root);
@@ -2013,9 +2258,20 @@ export function createRulesService(ctx, deps) {
                 const form = manifest.form === 'bundle' ? 'bundle' : 'flat';
                 let bytes = 0;
                 try {
-                    bytes = (await stat(form === 'bundle' ? join(dir, 'bundle', 'SKILL.md') : join(dir, 'rule.md'))).size;
+                    const bundleDoc = form === 'bundle'
+                        ? join(dir, 'bundle', bundleDocName(manifest.name))
+                        : join(dir, 'rule.md');
+                    bytes = (await stat(bundleDoc)).size;
+                }
+                catch {
+                    // 兼容旧回收站条目（正文仍叫 SKILL.md）；仍读不到就按 0 计，恢复时由 rulesRestore 兜底报错。
+                    if (form === 'bundle') {
+                        try {
+                            bytes = (await stat(join(dir, 'bundle', LEGACY_BUNDLE_DOC))).size;
+                        }
+                        catch { /* 内容缺失 */ }
+                    }
                 }
-                catch { /* 内容缺失：仍列出，恢复时由 rulesRestore 兜底报错 */ }
                 entries.push({ trashId, group, name: manifest.name, form, deletedAt: String(manifest.deletedAt || ''), bytes });
             }
             catch { /* 损坏条目跳过 */ }
@@ -2028,7 +2284,7 @@ export function createRulesService(ctx, deps) {
         const trashId = String((args && args.trashId) || '');
         if (!isValidTrashId(trashId))
             return fail('error.rules.notFound', `回收站条目不存在：${trashId}`);
-        const dir = join(stateDir, 'rules-trash', trashId);
+        const dir = join(stateDir, MEMORIES_TRASH_DIR, trashId);
         try {
             const st = await lstat(dir);
             if (!st.isDirectory())
@@ -2040,8 +2296,8 @@ export function createRulesService(ctx, deps) {
         await rm(dir, { recursive: true, force: true });
         return { ok: true };
     }
-    /** bundle 目录下的附件（顶层普通文件，排除正文 SKILL.md）；不存在/不可读返回空数组。 */
-    async function listAttachments(bundleDir) {
+    /** bundle 目录下的附件（顶层普通文件，排除正文 `<名>.md`，兼容旧数据 `SKILL.md`）；不存在/不可读返回空数组。 */
+    async function listAttachments(bundleDir, name) {
         let entries;
         try {
             entries = await readdir(bundleDir, { withFileTypes: true });
@@ -2049,9 +2305,10 @@ export function createRulesService(ctx, deps) {
         catch {
             return [];
         }
+        const docNames = new Set([bundleDocName(name), LEGACY_BUNDLE_DOC]);
         const out = [];
         for (const entry of entries) {
-            if (entry.name === BUNDLE_DOC)
+            if (docNames.has(entry.name))
                 continue;
             if (!entry.isFile())
                 continue; // 子目录 / 符号链接不列出（detach 也只动普通文件）
@@ -2085,10 +2342,13 @@ export function createRulesService(ctx, deps) {
             return fail('error.rules.tooManyFiles', `一次最多 ${MAX_ATTACH_ENTRIES} 个附件`, { limit: MAX_ATTACH_ENTRIES });
         const pending = [];
         let total = 0;
+        const docNames = new Set([bundleDocName(located.name), LEGACY_BUNDLE_DOC]);
         for (const file of files) {
             const name = String((file && (file.path || file.name)) || '');
             if (!isValidGroupSegment(name))
                 return fail('error.rules.invalidName', `附件名非法：${name || '(空)'}`);
+            if (docNames.has(name))
+                return fail('error.rules.invalidName', `附件名不能与正文文件同名：${name}`);
             const data = Buffer.from(String((file && file.data) || ''), 'base64');
             if (data.length === 0)
                 return fail('error.rules.emptyFile', `附件内容为空：${name}`);
@@ -2101,9 +2361,9 @@ export function createRulesService(ctx, deps) {
         }
         for (const file of pending)
             await writeFileAtomicBinary(join(located.entryPath, file.name), file.data);
-        return { ok: true, attachments: await listAttachments(located.entryPath) };
+        return { ok: true, attachments: await listAttachments(located.entryPath, located.name) };
     }
-    /** 删除 bundle 记忆的一个附件；正文 SKILL.md 不可删。 */
+    /** 删除 bundle 记忆的一个附件；正文 `<名>.md`（或旧数据 `SKILL.md`）不可删。 */
     async function rulesDetach(args) {
         const id = String((args && args.id) || '');
         const parts = parseId(id);
@@ -2115,8 +2375,9 @@ export function createRulesService(ctx, deps) {
         if (located.kind !== 'bundle')
             return fail('error.rules.notBundle', `「${parts.name}」是 flat（单文件），没有附件`);
         const name = String((args && args.name) || '');
-        if (!isValidGroupSegment(name) || name === BUNDLE_DOC)
+        if (!isValidGroupSegment(name) || name === bundleDocName(located.name) || name === LEGACY_BUNDLE_DOC) {
             return fail('error.rules.invalidName', `附件名非法：${name || '(空)'}`);
+        }
         const target = join(located.entryPath, name);
         try {
             const st = await lstat(target);
@@ -2127,7 +2388,7 @@ export function createRulesService(ctx, deps) {
             return fail('error.rules.notFound', `附件不存在：${name}`);
         }
         await rm(target, { force: true });
-        return { ok: true, attachments: await listAttachments(located.entryPath) };
+        return { ok: true, attachments: await listAttachments(located.entryPath, located.name) };
     }
     async function rulesToggle(args) {
         const id = String((args && args.id) || '');
@@ -2147,7 +2408,6 @@ export function createRulesService(ctx, deps) {
         index.rules[id] = { ...idxEntry, enabled, updatedAt: new Date().toISOString() };
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, rule: await buildProjected(id) };
     }
     /**
@@ -2192,7 +2452,6 @@ export function createRulesService(ctx, deps) {
         index.active = names;
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         const snap = await snapshot();
         return {
             ok: true,
@@ -2250,7 +2509,6 @@ export function createRulesService(ctx, deps) {
         index.scenes[name] = next;
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, scene: sceneRecordOf(name, next), ...(collapsed ? { collapsedActive: true } : {}) };
     }
     /**
@@ -2378,7 +2636,6 @@ export function createRulesService(ctx, deps) {
         index.scenes[finalName] = next;
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return {
             ok: true,
             ...(finalName === name ? {} : { renamedFrom: name }),
@@ -2503,7 +2760,6 @@ export function createRulesService(ctx, deps) {
         if (dirty)
             await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, name, trashId: trashed.id, movedFiles: moves.length };
     }
     /** 场景回收站列表（只读）：`<hub>/trash/scenes-trash/<id>/manifest.json`。 */
@@ -2562,7 +2818,6 @@ export function createRulesService(ctx, deps) {
         await writeIndex(stateDir, index);
         await purgeTrashEntry('scenes', id);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, name, restoredFiles: restored.length };
     }
     /** 永久删除一条场景回收站条目。 */
@@ -2575,7 +2830,7 @@ export function createRulesService(ctx, deps) {
     }
     /**
      * 提示词预设改名后**同步场景绑定**：把所有 `scenes[].prompt === from` 改成 `to`。
-     * 由 AGENTS.md 预设库的改名路径调用——绑定存在 `rules-index.json` 里，预设库
+     * 由 AGENTS.md 预设库的改名路径调用——绑定存在 `memories-index.json` 里，预设库
      * 自己看不到它，不叫这一声改名就会留下悬空绑定（场景卡片显示「预设不存在」）。
      * @returns 改了几个场景。
      */
@@ -2597,7 +2852,6 @@ export function createRulesService(ctx, deps) {
             index.scenes = scenes;
             await writeIndex(stateDir, index);
             invalidateSnapshot();
-            invalidateProviders();
         }
         return { ok: true, from, to, changed };
     }
@@ -2625,33 +2879,40 @@ export function createRulesService(ctx, deps) {
         index.rules[id] = next;
         await writeIndex(stateDir, index);
         invalidateSnapshot();
-        invalidateProviders();
         return { ok: true, rule: await buildProjected(id) };
     }
     // ── 组装 ─────────────────────────────────────────────────────────────────
-    const registerProviders = () => {
-        try {
-            // 场景绑定的提示词**不再注入**（2026-09-15 用户裁定：「切换场景，对应的提示词直接把
-            // AGENTS.md 修改」）：启用/切换场景、改绑、编辑绑定的预设时，宿主把那份正文写进
-            // `~/.dsh/AGENTS.md`（与「提示词」页的「应用」同一条路，覆盖前多代备份），关掉场景时
-            // 恢复进场景之前的基线。真改文件之后再注入一遍，同一份正文会进上下文两次，而且用户手改
-            // 基线之后还会被重新注入 —— 所以这里只保留场景记忆段。绑定关系的**只读投影**仍由 rules
-            // 服务提供（页面「生效中」标记，以及"文件是否已经同步成它"的判断）。
-            const registrar = createPromptSectionRegistrar(ctx, [{
-                    name: 'tool-management:scene-memory',
-                    order: SECTION_ORDER.sceneMemory,
-                    text: () => sceneMemory().text,
-                }]);
-            providerInvalidators.add(registrar.invalidate);
-            return () => {
-                providerInvalidators.delete(registrar.invalidate);
-                registrar.dispose();
-            };
-        }
-        catch (e) {
-            console.error('[dsh-plugin-tool-management] rules provider setup failed:', message(e));
-            return () => { };
-        }
+    // 注入文本出口（2026-09-16 第四版）。
+    //
+    // 历史：本服务先后把场景记忆做成"系统提示词段"（会被 persona complete 压掉）与
+    // "写 AGENTS.md 文件"（预设不挂 dsh-agent-instructions 时到不了模型）。现在两条都交给
+    // 注入通道（src/context-inject.ts）：每个 step 前把文本并进一条注入消息，任何预设都到得了。
+    // 这里只留**同步取文本**的两个出口，注册/生命周期由 index.ts 的注入器统一管。
+    //
+    //   - `memoryText`：场景记忆段（记忆正文；`''` = 没有可注入的内容）。
+    //   - `promptText`：全局提示词正文 = 场景期间用场景提示词、平时用 AGENTS.md 正文。
+    //     **不判"与文件重复"** —— 预设挂了官方 agent-instructions 时那份正文已经由文件送达
+    //     （注入侧会跳过整个域），没挂时（极简）才需要注入兜底；判定在注入器的 `selectInjections` 里。
+    const memoryText = () => sceneMemory().text;
+    /**
+     * `~/.dsh/AGENTS.md` 正文。上限与官方那一行的 `maxBytes` 同量级（64 KiB）：超大文件按字节
+     * 截断并留一行标记，免得一份手写的巨型基线把上下文撑爆。
+     */
+    const AGENTS_MD_MAX_BYTES = 65536;
+    const agentsMdText = () => {
+        const text = readGlobalAgentsMdSync();
+        if (text.trim() === '')
+            return '';
+        if (Buffer.byteLength(text, 'utf8') <= AGENTS_MD_MAX_BYTES)
+            return text;
+        const cut = Buffer.from(text, 'utf8').subarray(0, AGENTS_MD_MAX_BYTES).toString('utf8');
+        return cut + `\n\n（…文件超过 ${Math.floor(AGENTS_MD_MAX_BYTES / 1024)} KiB，已截断。）`;
+    };
+    // 场景提示词与 AGENTS.md 正文在用户眼里就是同一件事（"全局提示词"）：场景期间前者取代后者，
+    // 与官方语义一致（进场景改写文件、退出恢复）。所以一个域、一份文本，取到非空的场景提示词就用它。
+    const promptText = () => {
+        const scene = resolveScenePreset()?.text ?? '';
+        return scene.trim() !== '' ? scene : agentsMdText();
     };
     /** 写操作：串行队列内执行，成功后触发 refresh（失效缓存，下一请求即生效）。 */
     const runWrite = (task) => enqueueMutation(async () => {
@@ -2700,7 +2961,8 @@ export function createRulesService(ctx, deps) {
     const service = {
         ops,
         writeOps,
-        registerProviders,
+        memoryText,
+        promptText,
         refresh,
         patchIndex,
         readArchiveSlice,