dsh-plugin-tool-management 0.7.0 → 0.8.0

package/lib/rules/service.js

@@ -29,12 +29,12 @@ import { randomUUID } from 'node:crypto';
 import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { copyFile, cp, lstat, mkdir, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
-import { parseSkillDoc, resolveDshHome, unquote } from '../skills/core.js';
+import { parseSkillDoc, renameWithRetry, resolveDshHome, unquote } from '../skills/core.js';
 import { expandUploads, planMemoryImport } from '../imports/upload.js';
-import { createRuleProviderRegistrar } from './provider.js';
+import { SECTION_ORDER, createPromptSectionRegistrar } from '../prompt-sections.js';
 import { normalizePresetId } from '../agents-md/preset-id.js';
-import { normalizeArchive, memoryAllowed } from './archive.js';
-import { listTrashEntries, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
+import { normalizeArchive } from './archive.js';
+import { listTrashEntries, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
 // ── 常量 ───────────────────────────────────────────────────────────────────
 const MAX_SOURCE_DEPTH = 64; // 与 core.js 一致
 const MAX_DIRECTORIES = 2000; // 目录预算
@@ -102,25 +102,68 @@ export const MEMORIES_DIR = 'memories';
 export const GLOBAL_SCENE = 'global';
 /** 保留场景在界面上的显示名（磁盘上仍用 ASCII 目录/文件名）。 */
 export const GLOBAL_SCENE_LABEL = '全局';
+/**
+ * 记忆导出的落盘映射（`bundle-export` 的 `kind: 'memories'` 用，见 design-plan D14）。
+ *
+ * 记忆有两种形态（见文件头）：flat = `<场景>/<name>.md`，bundle = `<场景>/<name>/SKILL.md`；
+ * 而且**场景名本身可含 `/`**（多段场景名，见 `isValidGroupPath`）。所以「按 id 的最后一个
+ * `/` 切出场景与名字、再拼 `.md`」是错的：bundle 会被读成 `<场景>/<name>.md` → 读不到 →
+ * 该项目静默丢失（只在 `missing` 里留个名，界面按「导出成功」显示）。
+ *
+ * 这里一律按索引里那条规则自己的 `path` 与 `form` 决定；bundle 只交出目录，由调用方
+ * 把目录内的文件全部打包（与技能分支同口径）。索引里没有、或已被同名 bundle 遮蔽的 id
+ * 进 `missing`——遮蔽的 flat 不会被加载，导出去只会让人以为它能用。
+ *
+ * 纯函数（不碰磁盘），可直接断言。
+ */
+export function planMemoryExport(names, rules) {
+    const list = Array.isArray(names) ? names.map((n) => String(n).trim()).filter(Boolean) : [];
+    const byId = new Map();
+    for (const row of (Array.isArray(rules) ? rules : [])) {
+        const id = row && typeof row.id === 'string' ? row.id : '';
+        if (id !== '')
+            byId.set(id, row);
+    }
+    const entries = [];
+    const missing = [];
+    for (const id of list) {
+        const row = byId.get(id);
+        const abs = row && typeof row.path === 'string' ? row.path : '';
+        if (!row || abs === '' || row.shadowed === true) {
+            missing.push(id);
+            continue;
+        }
+        entries.push(row.form === 'bundle'
+            ? { id, zip: id, abs: dirname(abs), kind: 'dir' }
+            : { id, zip: `${id}.md`, abs, kind: 'file' });
+    }
+    return { entries, missing };
+}
 // ── 文件工具 ───────────────────────────────────────────────────────────────
-/** 同目录临时文件 + rename 原子写（临时名 `.xxx.dsh-rules-<uuid>.tmp`）。 */
+/**
+ * 同目录临时文件 + rename 原子写（临时名 `.xxx.dsh-rules-<uuid>.tmp`）。
+ * rename 走 `renameWithRetry`：Windows 上杀软/索引器会短暂占住目标文件报
+ * EPERM/EACCES/EBUSY（用户实测：进入/退出模式时 rules-index.json 被 rename 撞上，
+ * 运行时已切换但状态落盘失败，界面开关停在旧状态、还得再点一次）。这种占用是
+ * 瞬时的，重试几轮就能过去；全失败才清理临时文件并把错误抛出。
+ */
 async function writeFileAtomically(path, content) {
     const temp = join(dirname(path), `.${basename(path)}.dsh-rules-${randomUUID()}.tmp`);
     try {
         await writeFile(temp, content, 'utf8');
-        await rename(temp, path);
+        await renameWithRetry(temp, path);
     }
     catch (error) {
         await rm(temp, { force: true }).catch(() => undefined);
         throw error;
     }
 }
-/** 二进制版原子写（附件用）：临时文件 + rename，失败清理临时文件。 */
+/** 二进制版原子写（附件用）：临时文件 + rename（同样带瞬时占用重试），失败清理临时文件。 */
 async function writeFileAtomicBinary(path, data) {
     const temp = join(dirname(path), `.${basename(path)}.dsh-rules-${randomUUID()}.tmp`);
     try {
         await writeFile(temp, data);
-        await rename(temp, path);
+        await renameWithRetry(temp, path);
     }
     catch (error) {
         await rm(temp, { force: true }).catch(() => undefined);
@@ -347,6 +390,9 @@ function parseSceneEntry(raw) {
         out.order = obj.order;
     if (typeof obj.createdAt === 'string' && obj.createdAt !== '')
         out.createdAt = obj.createdAt;
+    // 场景锁定（v0.8）：读盘必须原样保留 —— 这里曾只重建已知字段，锁了也会被剥成未锁。
+    if (obj.locked === true)
+        out.locked = true;
     return out;
 }
 function parseScenes(raw) {
@@ -412,9 +458,29 @@ function parseModeState(raw) {
                 list.push(tool);
         }
     }
+    // v2 快照的**服务器级 / 来源级**名单与 v0.8 的子智能体名单必须原样透传 ——
+    // 这里曾把它们剥掉，结果退出模式时两张恢复名单全是空的：服务器级 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 }))
+        .filter((x) => x.id !== '' && (x.level === 'global' || x.level === 'project'));
+    const skillSources = (Array.isArray(snapshotRaw.skillSources) ? snapshotRaw.skillSources : [])
+        .filter((x) => !!x && typeof x === 'object')
+        .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);
     return {
         scene,
-        snapshot: scene ? { mcp, skills: toFlagMap(snapshotRaw.skills) } : null,
+        snapshot: scene
+            ? {
+                mcp,
+                skills: toFlagMap(snapshotRaw.skills),
+                ...(mcpServers.length ? { mcpServers } : {}),
+                ...(skillSources.length ? { skillSources } : {}),
+                ...(subagents.length ? { subagents } : {}),
+            }
+            : null,
     };
 }
 /** 解析 rules-index.json 原文；任何异常/版本不符 → 默认索引（容忍缺失，§9.3）。 */
@@ -881,9 +947,9 @@ function renderSceneMemory(probe, index, maxBytes) {
         // 保留场景 global 恒定生效（「全局」= 任何对话都注入）；其余由 index.active 决定。
         if (file.scene !== GLOBAL_SCENE && !active.has(file.scene))
             continue;
-        // 场景档案的记忆段（v3）：该场景定过 memories 段 → 只有勾选的记忆进段（纯投影，不改文件）。
-        if (!memoryAllowed(index.archives, file.scene, file.id))
-            continue;
+        // ⚠️ 这里**不再**看场景档案的 memories 段：记忆的开关是**单一真相源** `rules[*].enabled`
+        // （见下方 enabled 判定）。档案弹窗里的记忆勾选就是同一个值，所以两边天然一致，
+        // 不存在「记忆页开了、档案页还显示未开」的两套状态。
         const list = buckets.get(file.scene);
         if (list)
             list.push(file);
@@ -1378,6 +1444,7 @@ export function createRulesService(ctx, deps) {
             prompt: index.scenes?.[name]?.prompt || '',
             // 单选模型下"能不能点开"：已被别的场景占用时，这个开关要置灰。
             selectable: name !== SHARED_GROUP && name !== GLOBAL_SCENE && (enabledScene === null || enabledScene === name),
+            locked: index.scenes?.[name]?.locked === true,
         }))
             .sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
     }
@@ -1391,6 +1458,8 @@ export function createRulesService(ctx, deps) {
             .sort((a, b) => a.group.localeCompare(b.group) || a.order - b.order || a.name.localeCompare(b.name));
         const groups = groupFilter ? snap.groups.filter((g) => g.name === groupFilter) : snap.groups;
         const scenes = sceneRows(snap, index);
+        // 场景锁定状态（v0.8）：任意一个场景锁定 = 五个管理域整体冻结。界面据此禁用各页的写控件。
+        const anyLocked = Object.values(index.scenes || {}).some((s) => s.locked === true);
         const projection = sceneMemory();
         const promptProjection = scenePrompt();
         return {
@@ -1400,6 +1469,8 @@ export function createRulesService(ctx, deps) {
             groups: groups.map((g) => ({ ...g, key: g.name })),
             // 场景 = 显式记录（含保留场景 global 与尚无记忆的空场景）；active = 是否参与注入。
             scenes,
+            // 任一场景被锁定 = 五个管理域整体冻结（客户端据此禁用写控件；服务端 handlers 另有守卫）。
+            anyLocked,
             activeMode: normalizeActive(index.active) === null ? 'all' : 'custom',
             // 单选模型：当前启用的那个场景（null = 只留 `_shared` 与 `global`）。
             activeScene: enabledSceneOf(index),
@@ -1606,7 +1677,9 @@ export function createRulesService(ctx, deps) {
         // id 恒为 `<场景>/<名>`（与 parseId 同构）；场景记录此时必然已存在。
         const createdId = `${targetGroup}/${name}`;
         const index = indexForScene;
-        index.rules[createdId] = { order: DEFAULT_ORDER, enabled: true, updatedAt: new Date().toISOString() };
+        // P5：新建记忆默认**不开启** —— 记忆的开关是单一真相源（`enabled`），
+        // 用户裁定「创建的记忆默认不开启，在记忆页开启后对应的场景档案也要显示开启」。
+        index.rules[createdId] = { order: DEFAULT_ORDER, enabled: false, updatedAt: new Date().toISOString() };
         if (!index.groups[targetGroup])
             index.groups[targetGroup] = { order: DEFAULT_GROUP_ORDER, label: targetGroup };
         await writeIndex(stateDir, index);
@@ -1714,7 +1787,8 @@ export function createRulesService(ctx, deps) {
             }
             // 索引记录：与 rules-create 同口径（order/enabled/updatedAt + 场景分组），用户既有设置不覆盖。
             const entry = index.rules[id];
-            index.rules[id] = { ...(entry || {}), order: entry?.order ?? DEFAULT_ORDER, enabled: entry?.enabled ?? true, updatedAt: new Date().toISOString() };
+            // P5：导入的记忆同样默认**不开启**（与 rules-create 同一口径）；已存在的条目保留原开关。
+            index.rules[id] = { ...(entry || {}), order: entry?.order ?? DEFAULT_ORDER, enabled: entry?.enabled ?? false, updatedAt: new Date().toISOString() };
             if (!index.groups[item.group])
                 index.groups[item.group] = { order: DEFAULT_GROUP_ORDER, label: item.group };
             // 场景记录补齐（导入进来的目录名此前可能没有记录）。
@@ -2168,8 +2242,15 @@ export function createRulesService(ctx, deps) {
         return { ok: true, scene: sceneRecordOf(name, next), ...(collapsed ? { collapsedActive: true } : {}) };
     }
     /**
-     * 更新场景记录（描述 / 显示名 / 顺序 / 绑定的提示词预设）。记忆文件不动。
-     * 这是「场景有描述」的写入口——旧版场景只有目录名，没有可编辑元数据。
+     * 更新场景记录（描述 / 显示名 / 顺序 / 绑定的提示词预设），**可选改名**（nextName）。
+     *
+     * 场景名就是它的一级目录名（`memories/<场景>/…`），所以改名不是改一个字段：
+     *   ① 目录 `memories/<旧>` → `memories/<新>`；
+     *   ② 索引里的四处引用一起改：`scenes` 记录、`archives` 档案、`active` 启用集合、`mode.scene`。
+     * 记忆正文一个字节都不动（只是换了所在目录名）。
+     *
+     * 拒绝的三种情况：保留场景 `global` / `_shared`；目标名已被占用（目录或记录）；
+     * 该场景正在当前模式里——模式快照是按场景名算的，改了名与快照就对不上（同删除的处理）。
      */
     async function rulesUpdateScene(args) {
         const name = String((args && args.name) || '').trim();
@@ -2219,13 +2300,106 @@ export function createRulesService(ctx, deps) {
                 return fail('error.rules.invalidGroup', `非法排序值：${args.order}`);
             next.order = Math.floor(order);
         }
-        if (name === GLOBAL_SCENE)
+        // ── 改名（可选）：目录 + 索引里的四处引用一起动 ──
+        let finalName = name;
+        const nextRaw = args && args.nextName !== undefined ? String(args.nextName).trim() : '';
+        if (nextRaw !== '' && nextRaw !== name) {
+            if (!isValidGroupSegment(nextRaw)) {
+                return fail('error.rules.invalidGroup', `新场景名非法：${nextRaw}（非空、≤${MAX_GROUP_SEGMENT_LENGTH} 字符、不含路径分隔符与 < > : " | ? *、不以 . 开头）`);
+            }
+            if (name === GLOBAL_SCENE)
+                return fail('error.rules.reservedScene', '「全局」是保留场景，不可改名');
+            if (name === SHARED_GROUP || nextRaw === SHARED_GROUP)
+                return fail('error.rules.invalidGroup', '_shared 是保留场景名，不可改名');
+            if ((index.scenes && index.scenes[nextRaw]) || (await pathExists(join(rulesRoot, nextRaw)))) {
+                return fail('error.rules.nameTaken', `目标场景名已被占用：${nextRaw}`);
+            }
+            if (index.mode && index.mode.scene === name) {
+                return fail('error.rules.sceneInMode', `场景「${name}」正处在当前模式，请先退出模式再改名`);
+            }
+            const fromDir = join(rulesRoot, name);
+            const toDir = join(rulesRoot, nextRaw);
+            let movedDir = false;
+            if (await pathExists(fromDir)) {
+                try {
+                    await rename(fromDir, toDir);
+                    movedDir = true;
+                }
+                catch (e) {
+                    return fail('error.rules.ioFailed', `场景目录改名失败：${message(e)}`);
+                }
+            }
+            // 目录已经搬过去了：索引这一步失败就必须把目录搬回来，否则目录名与索引各说各话。
+            try {
+                const scenes = index.scenes || {};
+                if (scenes[name]) {
+                    scenes[nextRaw] = scenes[name];
+                    delete scenes[name];
+                }
+                else {
+                    scenes[nextRaw] = { order: DEFAULT_GROUP_ORDER, createdAt: new Date().toISOString() };
+                }
+                index.scenes = scenes;
+                if (index.archives && index.archives[name]) {
+                    index.archives[nextRaw] = index.archives[name];
+                    delete index.archives[name];
+                }
+                const act = normalizeActive(index.active);
+                if (act !== null && act.indexOf(name) >= 0)
+                    index.active = act.map((n) => (n === name ? nextRaw : n));
+                if (index.mode && index.mode.scene === name)
+                    index.mode = { ...index.mode, scene: nextRaw };
+            }
+            catch (e) {
+                if (movedDir) {
+                    try {
+                        await rename(toDir, fromDir);
+                    }
+                    catch { /* 回滚失败：错误信息里如实带上原因 */ }
+                }
+                return fail('error.rules.ioFailed', `场景改名后索引更新失败：${message(e)}`);
+            }
+            finalName = nextRaw;
+        }
+        if (finalName === GLOBAL_SCENE)
             next.label = GLOBAL_SCENE_LABEL;
-        index.scenes[name] = next;
+        index.scenes[finalName] = next;
         await writeIndex(stateDir, index);
         invalidateSnapshot();
         invalidateProviders();
-        return { ok: true, scene: sceneRecordOf(name, next) };
+        return {
+            ok: true,
+            ...(finalName === name ? {} : { renamedFrom: name }),
+            scene: sceneRecordOf(finalName, next),
+        };
+    }
+    /**
+     * 场景锁定（v0.8）：锁定后五个管理域（MCP/技能/子智能体/记忆/提示词）整体只读 ——
+     * 场景页的档案编辑与功能页的启停/编辑都被拒（index.ts 的 handlers 守卫 + 界面禁用），
+     * 场景自身的启停（进/退模式）不受影响。`locked` 必须显式给布尔值（与 rules-toggle 同一口径）。
+     * 保留场景 `global` 不在场景页出现，不可锁。
+     */
+    async function rulesSceneLock(args) {
+        const name = String((args && args.scene) || '').trim();
+        if (!isValidGroupPath(name))
+            return fail('error.rules.invalidGroup', `场景名非法：${name || '(空)'}`);
+        if (name === GLOBAL_SCENE || name === SHARED_GROUP)
+            return fail('error.rules.reservedScene', '「全局 / _shared」是保留场景，不可锁定');
+        if (typeof (args && args.locked) !== 'boolean') {
+            return fail('error.rules.invalidArgs', '缺少参数：locked 必须是布尔值（只按传入值写入，不做"翻转"推断）');
+        }
+        const index = await readIndex(stateDir);
+        if (!index.scenes || !index.scenes[name])
+            return fail('error.rules.notFound', `场景不存在：${name}`);
+        // 未启动的场景不能上锁（用户裁定）：锁定的意义是冻结**运行中**场景的配置。
+        // 解锁随时允许 —— 否则退出模式后，被锁的场景就没人能解了。
+        if (args.locked === true && (!index.mode || index.mode.scene !== name)) {
+            return fail('error.rules.sceneNotActive', `场景「${name}」未启动：先启动再锁定`);
+        }
+        index.scenes[name] = { ...index.scenes[name], locked: args.locked === true };
+        await writeIndex(stateDir, index);
+        invalidateSnapshot();
+        return { ok: true, scene: name, locked: args.locked === true };
     }
     /**
      * 删除场景：**仅空目录可删**（避免一次操作带走整组记忆）。
@@ -2245,35 +2419,59 @@ export function createRulesService(ctx, deps) {
         if (!index.scenes?.[name] && !(await pathExists(join(rulesRoot, name)))) {
             return fail('error.rules.notFound', `场景不存在：${name}`);
         }
-        let entries = [];
-        try {
-            entries = await readdir(join(rulesRoot, name));
-        }
-        catch {
-            entries = []; // 目录本来就不存在（只有记录）→ 仍允许删记录
-        }
-        if (entries.filter((n) => !n.startsWith('.')).length > 0) {
-            return fail('error.rules.sceneNotEmpty', `场景「${name}」里还有 ${entries.length} 项，请先删除其中的记忆`);
-        }
         // 当前模式场景不可删：快照只在引擎里可退（rules service 反向注入会成环），
         // 直接删除会让运行时启停永久停在档案态且无恢复路径 → 给出可逆出路（先退出模式）。
         if (index.mode?.scene === name) {
             return fail('error.rules.sceneInMode', `场景「${name}」正处在当前模式，请先退出模式再删除`);
         }
-        // 场景本体（记录 + 档案）**先移入回收站**，再从索引里摘掉——这样「删除场景」
-        // 是可恢复的。记忆目录必须是空的（上面已拦），所以没有正文需要搬。
-        const trashed = await moveToTrash('scenes', name, [], {
+        // 删除场景 = **连它下面的全部记忆一起去掉**（用户裁定）：不管有没有启用、是不是子目录、
+        // 是不是 bundle 附件，统统收走。
+        // 但一律**先移入回收站**（与场景记录、档案装在同一条条目里），所以「删错了」还能整条恢复：
+        // 记忆文件按原来的相对路径放回，场景记录与档案也一起回来。
+        const sceneDir = join(rulesRoot, name);
+        const moves = [];
+        const collect = async (abs, rel) => {
+            let items = [];
+            try {
+                items = await readdir(abs, { withFileTypes: true });
+            }
+            catch {
+                return; // 目录不存在（只有记录的场景）或读不了 → 当作没有文件
+            }
+            for (const item of items) {
+                const childAbs = join(abs, item.name);
+                const childRel = rel === '' ? item.name : `${rel}/${item.name}`;
+                if (item.isDirectory())
+                    await collect(childAbs, childRel);
+                else
+                    moves.push({ from: childAbs, dest: childRel });
+            }
+        };
+        await collect(sceneDir, '');
+        const trashed = await moveToTrash('scenes', name, moves, {
             record: (index.scenes && index.scenes[name]) || null,
             archive: (index.archives && index.archives[name]) || null,
+            memories: moves.map((m) => m.dest),
         });
         if (trashed.ok === false) {
             return fail('error.rules.ioFailed', `移入回收站失败：${trashed.error}`);
         }
         try {
-            // fs.rm 删目录必须 recursive（即使已确认它是空的），否则报 EISDIR。
-            await rm(join(rulesRoot, name), { recursive: true, force: true });
+            // 文件已搬空，剩下的只是空子目录；recursive + force 一并清掉。
+            await rm(sceneDir, { recursive: true, force: true });
         }
         catch (e) {
+            // 目录没清掉就把记忆放回去：宁可整个操作失败，也不要「文件在回收站、场景还留在列表里」。
+            for (const move of moves) {
+                try {
+                    await moveOutOfTrash('scenes', trashed.id, move.dest, move.from);
+                }
+                catch { /* 尽力而为 */ }
+            }
+            try {
+                await purgeTrashEntry('scenes', trashed.id);
+            }
+            catch { /* 同上 */ }
             return fail('error.rules.ioFailed', `删除场景目录失败：${message(e)}`);
         }
         // 索引清理一次读-改-写：记录 + 启用集合悬空引用 + 该场景档案（否则 archives 留孤儿条目）。
@@ -2294,7 +2492,7 @@ export function createRulesService(ctx, deps) {
             await writeIndex(stateDir, index);
         invalidateSnapshot();
         invalidateProviders();
-        return { ok: true, name, trashId: trashed.id };
+        return { ok: true, name, trashId: trashed.id, movedFiles: moves.length };
     }
     /** 场景回收站列表（只读）：`<hub>/trash/scenes-trash/<id>/manifest.json`。 */
     async function sceneTrashList() {
@@ -2333,6 +2531,18 @@ export function createRulesService(ctx, deps) {
         catch (e) {
             return fail('error.rules.ioFailed', `重建场景目录失败：${message(e)}`);
         }
+        // 删除场景时一起收进回收站的记忆文件：按原来的相对路径放回（目录已确认是空的，不会覆盖）。
+        const files = Array.isArray(entry.files) ? entry.files : [];
+        const restored = [];
+        for (const rel of files) {
+            try {
+                await moveOutOfTrash('scenes', id, String(rel), join(dir, String(rel)));
+                restored.push(String(rel));
+            }
+            catch (e) {
+                return fail('error.rules.ioFailed', `恢复记忆文件失败（已放回 ${restored.length}/${files.length}）：${message(e)}`);
+            }
+        }
         if (data.record && typeof data.record === 'object')
             index.scenes = { ...(index.scenes || {}), [name]: data.record };
         if (data.archive && typeof data.archive === 'object')
@@ -2341,7 +2551,7 @@ export function createRulesService(ctx, deps) {
         await purgeTrashEntry('scenes', id);
         invalidateSnapshot();
         invalidateProviders();
-        return { ok: true, name };
+        return { ok: true, name, restoredFiles: restored.length };
     }
     /** 永久删除一条场景回收站条目。 */
     async function sceneTrashDelete(args) {
@@ -2409,9 +2619,17 @@ export function createRulesService(ctx, deps) {
     // ── 组装 ─────────────────────────────────────────────────────────────────
     const registerProviders = () => {
         try {
-            const registrar = createRuleProviderRegistrar(ctx, {
-                renderActiveScenes: () => sceneMemory().text,
-            });
+            // 场景绑定的提示词**不再注入**（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);
@@ -2436,6 +2654,7 @@ export function createRulesService(ctx, deps) {
     const writeOps = new Set([
         'rules-create', 'rules-update', 'rules-remove', 'rules-restore', 'rules-toggle', 'rules-import',
         'rules-set-index', 'rules-set-active', 'rules-create-scene', 'rules-update-scene', 'rules-remove-scene', 'rules-rebind-prompt',
+        'rules-scene-lock',
         'rules-attach', 'rules-detach', 'rules-trash-remove',
         // 场景回收站（与记忆回收站 rules-trash-* 分开：那套管记忆正文，这套管场景记录与档案）
         'scene-trash-restore', 'scene-trash-delete',
@@ -2459,6 +2678,7 @@ export function createRulesService(ctx, deps) {
         'rules-set-active': (args) => runWrite(() => rulesSetActive(args || {})),
         'rules-create-scene': (args) => runWrite(() => rulesCreateScene(args || {})),
         'rules-update-scene': (args) => runWrite(() => rulesUpdateScene(args || {})),
+        'rules-scene-lock': (args) => runWrite(() => rulesSceneLock(args || {})),
         'rules-remove-scene': (args) => runWrite(() => rulesRemoveScene(args || {})),
         'scene-trash-list': () => sceneTrashList(),
         'scene-trash-restore': (args) => runWrite(() => sceneTrashRestore(args || {})),

package/lib/skills/core.js

@@ -883,7 +883,10 @@ async function writeFileAtomically(path, content) {
     const temp = join(dirname(path), `.${basename(path)}.dssm-${randomUUID()}.tmp`);
     try {
         await fs.writeFile(temp, content, "utf8");
-        await fs.rename(temp, path);
+        // Windows 上目标文件会被杀软/索引器短暂占住（EPERM/EACCES/EBUSY）——
+        // 场景模式进出时这里写的是技能来源/策略状态，rename 被撞 = 运行时已切、
+        // 状态没落盘。与 rules-index.json 同一处理：重试瞬时占用，全失败才抛。
+        await renameWithRetry(temp, path);
     }
     catch (error) {
         await fs.rm(temp, { force: true }).catch(() => undefined);

package/lib/subagents/catalog.js

@@ -0,0 +1,89 @@
+import { filterBySceneBinding } from './tools.js';
+/**
+ * 描述截断长度 —— 照抄官方技能目录的默认值
+ * （`dsh-tool-skill` 的 `DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH = 500`）。
+ *
+ * 照抄的理由：截断风格与模型**已经见过的**技能目录一致，不用让它适应两套习惯；
+ * 而且这是官方旋钮的默认值，不是本插件拍脑袋定的数。日后 token 成本成为问题时，
+ * 官方对应的旋钮是 `catalogDescriptionMaxLength`。
+ */
+export const DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH = 500;
+/** 段里最多列几个人设；超出部分只报数量，让模型自己去调 subagent_list。 */
+export const DEFAULT_CATALOG_MAX_ENTRIES = 40;
+/** 无描述时的占位，与 `subagent_list` 工具的输出保持同一口径。 */
+const NO_DESCRIPTION = '(无描述)';
+/**
+ * 描述归一化 + 截断 —— 逐字对齐官方 `dsh-tool-skill` 的实现：
+ * 先把所有空白折叠成单空格，再按长度截断并补省略号。保证「一人设一行」。
+ */
+export function catalogDescription(value, maxLength) {
+    const normalized = String(value ?? '').replaceAll(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 3)}...`;
+}
+/**
+ * 渲染人设目录段（纯函数，便于单独推理）。
+ *
+ * 返回 `''` 表示不注入 —— `renderPrompt` 会删除空段，所以不用人设的用户零 token 成本。
+ * 名字按字典序排序：即使底层目录枚举顺序变化，段文本也保持逐字节稳定（前缀缓存契约）。
+ */
+export function renderSubagentCatalog(allowed, maxEntries = DEFAULT_CATALOG_MAX_ENTRIES, maxDescription = DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH) {
+    if (!allowed.length)
+        return '';
+    const sorted = [...allowed].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const shown = sorted.slice(0, Math.max(0, maxEntries));
+    const lines = shown.map((p) => '- **' + p.name + '** — ' + (catalogDescription(p.description, maxDescription) || NO_DESCRIPTION));
+    const hidden = sorted.length - shown.length;
+    const out = [
+        '## 子智能体（人设）',
+        '',
+        '需要委派独立任务时，用 `subagent_run` 并指定下面的人设名。',
+        '',
+        ...lines,
+    ];
+    if (hidden > 0)
+        out.push('', `（另有 ${hidden} 个未列出，用 subagent_list 查看全部。）`);
+    return out.join('\n');
+}
+/**
+ * 创建 SWR 人设目录。
+ *
+ * ⚠️ 计算失败（读盘异常等）时**保留上一次的值**，不把段清空 —— 否则一次瞬时 IO 抖动
+ * 会让模型突然「忘记」有哪些人设。
+ */
+export function createSubagentCatalog(deps, opts = {}) {
+    const maxEntries = opts.maxEntries ?? DEFAULT_CATALOG_MAX_ENTRIES;
+    const maxDescription = opts.maxDescription ?? DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH;
+    const ttlMs = opts.ttlMs ?? 1000;
+    const now = opts.now ?? (() => Date.now());
+    let value = '';
+    let loadedAt = Number.NEGATIVE_INFINITY;
+    let inflight = null;
+    const recompute = async () => {
+        try {
+            const { allowed } = await filterBySceneBinding(await deps.list(), await deps.sceneLists());
+            value = renderSubagentCatalog(allowed, maxEntries, maxDescription);
+        }
+        catch { /* 保留上一次的值；首次失败则维持 '' */ }
+        loadedAt = now();
+    };
+    const revalidate = () => {
+        if (inflight)
+            return inflight;
+        inflight = recompute().finally(() => { inflight = null; });
+        return inflight;
+    };
+    return {
+        text: () => {
+            if (now() - loadedAt > ttlMs)
+                void revalidate();
+            return value;
+        },
+        refresh: () => {
+            loadedAt = Number.NEGATIVE_INFINITY;
+            return revalidate();
+        },
+        warm: () => revalidate(),
+    };
+}