dsh-plugin-tool-management 0.7.0 → 0.8.5

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) {
@@ -374,7 +420,7 @@ function parseArchives(raw) {
     }
     return out;
 }
-function parseModeState(raw) {
+export function parseModeState(raw) {
     const obj = (raw && typeof raw === 'object' ? raw : {});
     const scene = typeof obj.scene === 'string' && obj.scene.trim() !== '' ? obj.scene : null;
     const snapshotRaw = (obj.snapshot && typeof obj.snapshot === 'object' ? obj.snapshot : {});
@@ -412,9 +458,36 @@ 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);
+    // v0.8.1 的场景备注恢复名单：**必须原样透传**——这里漏掉它，退出模式时备注永不回退
+    //（与历史上 mcpServers / skillSources 被剥掉是同一类 bug）。
+    const mcpNotes = (Array.isArray(snapshotRaw.mcpNotes) ? snapshotRaw.mcpNotes : [])
+        .filter((x) => !!x && typeof x === 'object')
+        .map((x) => ({ id: String(x.id || ''), note: typeof x.note === 'string' ? x.note : null }))
+        .filter((x) => x.id !== '');
     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 } : {}),
+                ...(mcpNotes.length ? { mcpNotes } : {}),
+            }
+            : null,
     };
 }
 /** 解析 rules-index.json 原文；任何异常/版本不符 → 默认索引（容忍缺失，§9.3）。 */
@@ -881,9 +954,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);
@@ -895,7 +968,7 @@ 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`;
+        const header = `${sceneHeading(scene)}\n\n${SCENE_MEMORY_NOTE}\n\n`;
         for (const file of sceneFiles) {
             const block = `### ${ruleHeading(file)}\n\n${String(file.body ?? '').trim()}\n`;
             candidates.push({
@@ -1034,6 +1107,11 @@ function sceneLabel(scene, index) {
 }
 /** 场景标题：`''` → 全局；其余用目录名（可追溯）。 */
 const sceneHeading = (scene) => `## 场景记忆：${sceneLabel(scene)}`;
+/**
+ * 场景标题后的固定引导语（常量，不破坏前缀缓存稳定）：让模型知道这段是当前场景的
+ * 常驻参考知识，而不是对话历史或临时说明 —— 相关就用、无关可忽略。
+ */
+const SCENE_MEMORY_NOTE = '（本场景的常驻参考知识：与当前任务相关时直接采用，无关时忽略）';
 /** 单条记忆的标题：显式 description 优先；派生描述与正文重复，改用文件名。 */
 const ruleHeading = (f) => (f.descriptionDerived || !f.description ? f.name : f.description);
 const byteLen = (s) => Buffer.byteLength(s, 'utf8');
@@ -1378,6 +1456,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 +1470,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 +1481,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 +1689,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 +1799,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 +2254,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 +2312,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 +2431,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 +2504,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 +2543,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 +2563,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 +2631,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 +2666,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 +2690,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);
@@ -1650,6 +1653,38 @@ async function setPolicySkillEnabled(root, name, enabled, log) {
 export async function setSkillEnabled(root, name, enabled, log) {
     return setPolicySkillEnabled(root, name, enabled, log);
 }
+/**
+ * 批量显式停用技能（v0.8.5：新建 / 导入 / 回收站恢复默认不启动 —— 用户裁定）。
+ * 直接写 disabledSkills 名单（与 setSkillEnabled 同一张表），不做 frontmatter 等
+ * 二次校验——调用方传入的必然是刚落盘/刚恢复的条目。
+ * 必须在调用方的写锁（service 的 write()）内执行。
+ * @param {{ root: string, name: string }[]} entries - root = 来源 key。
+ */
+export async function markSkillsDisabled(entries, log) {
+    const list = Array.isArray(entries) ? entries : [];
+    const clean = list
+        .map((e) => ({ root: String((e && e.root) || ""), name: String((e && e.name) || "") }))
+        .filter((e) => e.root !== "" && e.name !== "");
+    if (!clean.length)
+        return { ok: true };
+    const current = await readManagerState();
+    if (current.writable === false)
+        return invalidManagerStateWrite();
+    let dirty = false;
+    for (const e of clean) {
+        const prev = current.state.disabledSkills[e.root] || [];
+        if (prev.indexOf(e.name) >= 0)
+            continue;
+        current.state.disabledSkills[e.root] = [...prev, e.name].sort();
+        dirty = true;
+    }
+    if (dirty) {
+        await writeManagerState(current.state);
+        if (log)
+            log("skill-disable-default", `默认停用 ${clean.map((e) => `${e.root}/${e.name}`).join("、")}`);
+    }
+    return { ok: true };
+}
 /**
  * 同名技能「首选来源」：默认同名技能按来源 rank 取优先级最高者生效、其余显示为被覆盖；
  * 这里让用户显式指定哪个同名技能生效（preferred=false 取消，回到 rank 顺序）。

package/lib/skills/service.js

@@ -9,7 +9,7 @@ import { Worker } from 'node:worker_threads';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { state, setSkillEnabled, setPreferredSkill, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, permanentlyDeleteTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, skillDetail, listProviderCandidates, getProviderSkill, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, logPath, trashRootPath, } from './core.js';
+import { state, setSkillEnabled, setPreferredSkill, markSkillsDisabled, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, permanentlyDeleteTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, skillDetail, listProviderCandidates, getProviderSkill, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, logPath, trashRootPath, } from './core.js';
 const MAX_LOG_BYTES = 1 << 20;
 const PROVIDER_NAME = 'dsh-plugin-tool-management-external';
 const message = (e) => String((e && e.message) || e);
@@ -431,17 +431,43 @@ export function createSkillsService(ctx) {
             // requestRoot 未命中时回传原始 key，让 core 的 error.root.unknown 带上来源名
             // （否则传了不存在的 root 会收到「技能来源不存在：(空)」这种指错方向的提示）。
             const key = String(args.root || 'hub');
-            return createSkill({ name: args.name, description: args.description, body: args.body }, log, { root: (await requestRoot(key)) || key });
+            const res = await createSkill({ name: args.name, description: args.description, body: args.body }, log, { root: (await requestRoot(key)) || key });
+            // v0.8.5：新建技能默认不启动（用户裁定）——与子智能体 / MCP 同口径。
+            if (res && res.ok !== false && res.name) {
+                await markSkillsDisabled([{ root: String(res.root || 'hub'), name: String(res.name) }], log).catch(() => undefined);
+            }
+            return res;
+        }), afterWrite),
+        'skill-import': wrap((args) => write(async () => {
+            const res = await importSkill(String(args.source || ''), log, {
+                conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
+                dryRun: args.dryRun === true,
+            });
+            // 导入的技能默认停用；部分成功也对 imported 逐条停用。
+            const names = res && Array.isArray(res.imported) ? res.imported : [];
+            if (names.length)
+                await markSkillsDisabled(names.map((n) => ({ root: 'hub', name: String(n) })), log).catch(() => undefined);
+            return res;
+        }), afterWrite),
+        'skill-upload': wrap((args) => write(async () => {
+            const res = await importUploadedSkill({ name: args.name, entries: args.entries, zip: args.zip }, log, {
+                conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
+            });
+            // 上传/导入同口径：默认停用。
+            const names = res && Array.isArray(res.imported) ? res.imported : (res && res.name ? [res.name] : []);
+            if (names.length)
+                await markSkillsDisabled(names.map((n) => ({ root: 'hub', name: String(n) })), log).catch(() => undefined);
+            return res;
         }), afterWrite),
-        'skill-import': wrap((args) => write(() => importSkill(String(args.source || ''), log, {
-            conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
-            dryRun: args.dryRun === true,
-        })), afterWrite),
-        'skill-upload': wrap((args) => write(() => importUploadedSkill({ name: args.name, entries: args.entries, zip: args.zip }, log, {
-            conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
-        })), afterWrite),
         'skill-delete': wrap((args) => write(async () => deleteSkill(await requestRoot(String(args.root || 'dsh')), String(args.name || ''), log)), afterWrite),
-        'skill-trash-restore': wrap((args) => write(() => restoreTrash(String(args.id || ''), log, projectOptions())), afterWrite),
+        'skill-trash-restore': wrap((args) => write(async () => {
+            const res = await restoreTrash(String(args.id || ''), log, projectOptions());
+            // 恢复的技能默认停用（v0.8.5 用户裁定：新建/导入/恢复一律不启动，手动开启）。
+            if (res && res.ok !== false && res.name) {
+                await markSkillsDisabled([{ root: String(res.root || 'hub'), name: String(res.name) }], log).catch(() => undefined);
+            }
+            return res;
+        }), afterWrite),
         'skill-trash-delete': wrap((args) => write(() => permanentlyDeleteTrashSafely(String(args.id || ''), log))),
         // 自定义技能目录：添加（绝对路径，只读接入）/ 移除（连同策略键）。
         'skill-custom-add': wrap((args) => write(() => addCustomRoot(args && args.path, args && args.label, log)), afterWrite),