dsh-plugin-tool-management 0.5.1 → 0.7.0

package/lib/rules/service.js

@@ -32,7 +32,9 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { parseSkillDoc, resolveDshHome, unquote } from '../skills/core.js';
 import { expandUploads, planMemoryImport } from '../imports/upload.js';
 import { createRuleProviderRegistrar } from './provider.js';
+import { normalizePresetId } from '../agents-md/preset-id.js';
 import { normalizeArchive, memoryAllowed } from './archive.js';
+import { listTrashEntries, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
 // ── 常量 ───────────────────────────────────────────────────────────────────
 const MAX_SOURCE_DEPTH = 64; // 与 core.js 一致
 const MAX_DIRECTORIES = 2000; // 目录预算
@@ -336,6 +338,11 @@ function parseSceneEntry(raw) {
         out.label = obj.label;
     if (typeof obj.description === 'string' && obj.description !== '')
         out.description = obj.description;
+    if (typeof obj.prompt === 'string') {
+        const prompt = normalizeScenePromptId(obj.prompt);
+        if (prompt)
+            out.prompt = prompt;
+    }
     if (typeof obj.order === 'number' && Number.isFinite(obj.order))
         out.order = obj.order;
     if (typeof obj.createdAt === 'string' && obj.createdAt !== '')
@@ -457,10 +464,20 @@ function sceneRecordOf(name, entry) {
         name,
         ...(name === GLOBAL_SCENE ? { label: e.label || GLOBAL_SCENE_LABEL } : (e.label ? { label: e.label } : {})),
         ...(e.description ? { description: e.description } : {}),
+        ...(e.prompt ? { prompt: e.prompt } : {}),
         order: e.order ?? (name === GLOBAL_SCENE ? 0 : DEFAULT_GROUP_ORDER),
         ...(e.createdAt ? { createdAt: e.createdAt } : {}),
     };
 }
+/** 提示词预设 id 的口径与 agents-md 服务**同源**（用户裁定：id 什么都能写）。 */
+/** 校验场景要绑定的提示词预设 id；返回 `''` 表示解绑，`null` 表示非法。 */
+function normalizeScenePromptId(value) {
+    const id = String(value ?? '').trim();
+    if (id === '')
+        return '';
+    const result = normalizePresetId(id);
+    return result.ok ? result.id : null;
+}
 /** 路径是否存在（不跟随符号链接；用于迁移前置判断）。 */
 async function pathExists(path) {
     try {
@@ -561,12 +578,14 @@ function normalizeActive(raw) {
     return out;
 }
 /**
- * 活动场景解析（§4 对照表）：
- *   - `index.active` 缺失 / null → **全部场景启用**（默认；保证"丢进去就有用"）
- *   - `index.active` 为数组 → 只有列出的场景启用（显式收窄）
+ * 活动场景解析（用户裁定 2026-09-15：**除「全局」外同时只能启用一个场景**）：
+ *   - `index.active` 为数组（新写入的唯一形态）→ 至多一个非保留场景启用；
+ *   - `index.active` 缺失 / null → 历史默认（"全部场景启用"）；**不再产生**新值，
+ *     新建场景时会被收敛成显式数组（见 `collapseActiveForNewScene`），
+ *     因此"新建即启用"不会发生；存量数据仍按老语义读，避免升级后注入范围突变。
  *   - `_shared` 恒常启用（公共基线），不受开关影响
  *   - 保留场景 `global` 恒常启用：它的记忆对任何对话都成立
- * 缺失 rules-index.json 一律按默认值运行（"全部场景启用"），不抛错（§9.3）。
+ * 缺失 rules-index.json 一律按默认值运行，不抛错（§9.3）。
  * 场景生效与否只由 index.active 决定（场景档案/模式也写这一份）。
  */
 function resolveActiveScenes(index, knownScenes) {
@@ -577,6 +596,30 @@ function resolveActiveScenes(index, knownScenes) {
     active.add(GLOBAL_SCENE);
     return { active, mode };
 }
+/** 当前启用的**非保留**场景（单选模型下至多一个；多个时按场景顺序取第一个）。 */
+function enabledSceneOf(index) {
+    const names = Object.keys(index.scenes || {});
+    const { active } = resolveActiveScenes(index, names);
+    const enabled = names
+        .filter((n) => n !== SHARED_GROUP && n !== GLOBAL_SCENE && active.has(n))
+        .sort((a, b) => sceneOrderOf(index, a) - sceneOrderOf(index, b) || a.localeCompare(b));
+    return enabled[0] ?? null;
+}
+/**
+ * 新建场景前把历史默认（`active = null` = 全部启用）收敛成显式数组，保证
+ * **新场景默认不启动**、且收敛后仍满足"至多一个非保留场景启用"：
+ *   - 已存在其它非保留场景 → 取顺序第一个作为启用场景（其余收敛掉，返回 `collapsed: true`）
+ *   - 不存在 → 空数组（什么都不启用）
+ * @returns 是否发生了收敛（供 UI 如实提示）。
+ */
+function collapseActiveForNewScene(index) {
+    if (normalizeActive(index.active) !== null)
+        return false;
+    const names = Object.keys(index.scenes || {}).filter((n) => n !== SHARED_GROUP && n !== GLOBAL_SCENE);
+    const first = names.sort((a, b) => sceneOrderOf(index, a) - sceneOrderOf(index, b) || a.localeCompare(b))[0];
+    index.active = first === undefined ? [] : [first];
+    return true;
+}
 /** 场景名 = 分组路径的第一段（`web/frontend` 属于场景 `web`）。 */
 function sceneOf(group) {
     const idx = String(group || '').indexOf('/');
@@ -1054,6 +1097,122 @@ export function createRulesService(ctx, deps) {
         sceneCache = { signature: probe.signature, value };
         return value;
     }
+    // ── 场景提示词段（绑定预设正文；只读，绝不写 ~/.dsh/AGENTS.md）──────────────
+    //
+    // 语义（用户裁定 2026-09-15）：
+    //   - 场景可绑定**一个**提示词预设（`scenes[].prompt` → `agents-md/<id>/AGENTS.md`）；
+    //   - 除保留场景 `global` 外**同时只能启用一个场景**，所以同一时刻至多一份提示词在场；
+    //   - 没有启用其它场景时才轮到 `global` 自己的绑定（它恒常生效，覆盖"永远在场的提示词"）；
+    //   - 预设文件不存在 / 未绑定 → 返回 `''`（renderPrompt 会删掉空段，不产生空标题）。
+    //
+    // 为什么不用 fs.watch 也不用每请求读盘：段契约要求**同步返回**且逐字节稳定，
+    // 因此按 `mtimeMs + size` 做一次 stat 缓存 —— 命中时零读盘，外部编辑器改了预设
+    // 也会在下一个请求自动刷新（与记忆段的"两相扫描"同一哲学）。
+    const promptFileCache = new Map();
+    /** 读一个预设正文（同步、带 stat 指纹缓存）；不存在返回 `''`。 */
+    function readPresetTextSync(id) {
+        const file = join(stateDir, 'agents-md', id, 'AGENTS.md');
+        let key;
+        try {
+            const st = statSync(file);
+            if (!st.isFile())
+                return '';
+            key = `${st.mtimeMs}:${st.size}`;
+        }
+        catch {
+            promptFileCache.delete(id);
+            return '';
+        }
+        const cached = promptFileCache.get(id);
+        if (cached && cached.key === key)
+            return cached.text;
+        let text = '';
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            return '';
+        }
+        promptFileCache.set(id, { key, text });
+        return text;
+    }
+    /** 预设文件是否存在（同步；绑定前校验用，避免悬空绑定）。 */
+    function presetExistsSync(id) {
+        try {
+            return statSync(join(stateDir, 'agents-md', id, 'AGENTS.md')).isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 读当前 `~/.dsh/AGENTS.md`（同步、带 stat 指纹缓存）。
+     * 用途只有一个：**去重**——绑定的预设与文件内容逐字节相同时不再注入第二遍正文。
+     */
+    let globalAgentsCache = null;
+    function readGlobalAgentsMdSync() {
+        const file = join(resolveDshHome(), 'AGENTS.md');
+        let key;
+        try {
+            const st = statSync(file);
+            if (!st.isFile())
+                return '';
+            key = `${st.mtimeMs}:${st.size}`;
+        }
+        catch {
+            globalAgentsCache = null;
+            return '';
+        }
+        if (globalAgentsCache && globalAgentsCache.key === key)
+            return globalAgentsCache.text;
+        let text = '';
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            return '';
+        }
+        globalAgentsCache = { key, text };
+        return text;
+    }
+    /**
+     * 当前生效的场景提示词：启用场景的绑定优先，其次 `global` 的绑定；都没有则 `''`。
+     * 绑定内容与 `~/.dsh/AGENTS.md` 相同时标记 `duplicate` 且返回空段 —— 那份正文已经在
+     * 基线里了，再注入一遍只会把同样的内容塞进上下文两次。
+     */
+    function scenePrompt() {
+        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))
+            .sort((a, b) => sceneOrderOf(index, a) - sceneOrderOf(index, b) || a.localeCompare(b));
+        for (const scene of enabled) {
+            const id = index.scenes?.[scene]?.prompt;
+            if (!id)
+                continue;
+            const projected = project(scene, id);
+            // 绑了但预设为空/已删 → 继续找下一个（不注入空段）。
+            if (projected.missing)
+                continue;
+            return projected;
+        }
+        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 = () => {
@@ -1205,6 +1364,7 @@ export function createRulesService(ctx, deps) {
         }
         const known = [...names];
         const { active } = resolveActiveScenes(index, known);
+        const enabledScene = enabledSceneOf(index);
         return known
             .map((name) => ({
             name,
@@ -1215,6 +1375,9 @@ export function createRulesService(ctx, deps) {
             shared: name === SHARED_GROUP,
             global: name === GLOBAL_SCENE,
             description: index.scenes?.[name]?.description || '',
+            prompt: index.scenes?.[name]?.prompt || '',
+            // 单选模型下"能不能点开"：已被别的场景占用时，这个开关要置灰。
+            selectable: name !== SHARED_GROUP && name !== GLOBAL_SCENE && (enabledScene === null || enabledScene === name),
         }))
             .sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
     }
@@ -1229,6 +1392,7 @@ export function createRulesService(ctx, deps) {
         const groups = groupFilter ? snap.groups.filter((g) => g.name === groupFilter) : snap.groups;
         const scenes = sceneRows(snap, index);
         const projection = sceneMemory();
+        const promptProjection = scenePrompt();
         return {
             ok: true,
             rules,
@@ -1237,7 +1401,17 @@ export function createRulesService(ctx, deps) {
             // 场景 = 显式记录（含保留场景 global 与尚无记忆的空场景）；active = 是否参与注入。
             scenes,
             activeMode: normalizeActive(index.active) === null ? 'all' : 'custom',
+            // 单选模型：当前启用的那个场景（null = 只留 `_shared` 与 `global`）。
+            activeScene: enabledSceneOf(index),
             sceneMemory: { usedBytes: projection.bytes, maxBytes: projection.maxBytes, truncated: projection.truncated, dropped: projection.dropped },
+            // 当前生效的场景提示词（绑定的预设正文；与 ~/.dsh/AGENTS.md 一致时不重复注入）。
+            scenePrompt: {
+                scene: promptProjection.scene,
+                presetId: promptProjection.presetId,
+                missing: promptProjection.missing,
+                duplicate: promptProjection.duplicate === true,
+                bytes: Buffer.byteLength(promptProjection.text, 'utf8'),
+            },
             // 路径供 UI 显示「文件在哪」；不再让界面硬编码 ~/.dsh/scene-memory。
             paths: { memories: rulesRoot, scenes: scenesRoot, hub: stateDir },
             stats: {
@@ -1874,9 +2048,16 @@ export function createRulesService(ctx, deps) {
         const parts = parseId(id);
         if (!parts)
             return fail('error.rules.notFound', `规则不存在：${id}`);
+        // `enabled` 必须显式给。缺省时旧实现回落到"沿用当前值"，却照样刷新
+        // updatedAt 并返回 ok:true —— 调用方按 toggle（翻转）理解时会以为自己改了
+        // 状态，实际什么都没改（界面不受影响：它一直显式传值）。与 rulesSetActive
+        // 同一条口径：参数缺失就明确拒绝，不猜。
+        if (typeof (args && args.enabled) !== 'boolean') {
+            return fail('error.rules.invalidArgs', '缺少参数：enabled 必须是布尔值（toggle 只按传入值写入，不做"翻转"推断）');
+        }
         const index = await readIndex(stateDir);
         const idxEntry = index.rules[id] || {};
-        const enabled = args && args.enabled !== undefined ? args.enabled === true : (idxEntry.enabled ?? true);
+        const enabled = args.enabled === true;
         index.rules[id] = { ...idxEntry, enabled, updatedAt: new Date().toISOString() };
         await writeIndex(stateDir, index);
         invalidateSnapshot();
@@ -1884,35 +2065,45 @@ export function createRulesService(ctx, deps) {
         return { ok: true, rule: await buildProjected(id) };
     }
     /**
-     * 设置"启用场景"集合（全局持久化，切换后**下一个请求即生效**，§4 对照表）。
-     *   - `args.all === true` → 清空显式集合，回到"全部启用"默认（新建场景自动生效）
-     *   - `args.scenes` 数组 → 显式收窄（`_shared` 恒常，无需列出）
+     * 设置"启用场景"（全局持久化，切换后**下一个请求即生效**，§4 对照表）。
+     *   - `args.scenes` 数组 → 启用集合；**至多一个非保留场景**（用户裁定：除「全局」外
+     *     同时只能启用一个），`[]` = 全部关闭（只留恒常的 `_shared` 与 `global`）
+     *   - `args.all === true` → 旧的"全部启用"形态，与新模型冲突，明确拒绝（不猜）
      * 场景名按放宽后的规则校验；不存在的场景名也允许保存（目录随后创建即可生效）。
      */
     async function rulesSetActive(args) {
-        const index = await readIndex(stateDir);
-        if (args && args.all === true) {
-            index.active = null;
+        // 参数必须显式二选一。旧实现把「没传参数」「传了未知参数名」都落进 else 分支、
+        // 用空数组覆盖 active，于是 `rules-set-active {}` 会静默把模式切成 custom 且零激活场景
+        // （用户以为自己只是"没改动"，实际已经改了注入范围）。这里显式拒绝。
+        const hasAll = !!(args && args.all === true);
+        const hasScenes = Array.isArray(args && args.scenes);
+        if (!hasAll && !hasScenes) {
+            return fail('error.rules.invalidArgs', '缺少参数：需要 scenes:[...]（启用集合，至多一个场景）');
         }
-        else {
-            const raw = Array.isArray(args && args.scenes) ? args.scenes : [];
-            const names = [];
-            const seen = new Set();
-            for (const item of raw) {
-                const name = String(item == null ? '' : item).trim();
-                // 恒常启用的保留场景不入显式集合：`_shared`（公共基线）与 `global`（「全局」）。
-                if (name === '' || name === SHARED_GROUP || name === GLOBAL_SCENE)
-                    continue;
-                if (!isValidGroupPath(name)) {
-                    return fail('error.rules.invalidGroup', `场景名非法：${name}（非空、≤${MAX_GROUP_SEGMENT_LENGTH} 字符、不含路径分隔符与 < > : " | ? *、不以 . 开头）`);
-                }
-                if (seen.has(name))
-                    continue;
-                seen.add(name);
-                names.push(name);
+        if (hasAll) {
+            return fail('error.rules.singleSceneOnly', '除「全局」外同时只能启用一个场景：不支持"全部启用"，请改用 scenes:[<场景名>] 或 scenes:[]（全部关闭）');
+        }
+        const index = await readIndex(stateDir);
+        const raw = Array.isArray(args && args.scenes) ? args.scenes : [];
+        const names = [];
+        const seen = new Set();
+        for (const item of raw) {
+            const name = String(item == null ? '' : item).trim();
+            // 恒常启用的保留场景不入显式集合：`_shared`（公共基线）与 `global`（「全局」）。
+            if (name === '' || name === SHARED_GROUP || name === GLOBAL_SCENE)
+                continue;
+            if (!isValidGroupPath(name)) {
+                return fail('error.rules.invalidGroup', `场景名非法：${name}（非空、≤${MAX_GROUP_SEGMENT_LENGTH} 字符、不含路径分隔符与 < > : " | ? *、不以 . 开头）`);
             }
-            index.active = names;
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            names.push(name);
         }
+        if (names.length > 1) {
+            return fail('error.rules.singleSceneOnly', `除「全局」外同时只能启用一个场景（收到 ${names.length} 个：${names.join('、')}）`);
+        }
+        index.active = names;
         await writeIndex(stateDir, index);
         invalidateSnapshot();
         invalidateProviders();
@@ -1942,6 +2133,10 @@ export function createRulesService(ctx, deps) {
         if (description.length > MAX_DESCRIPTION_LENGTH) {
             return fail('error.rules.descriptionTooLong', `场景描述过长（≤${MAX_DESCRIPTION_LENGTH} 字符）`);
         }
+        const prompt = args && args.prompt !== undefined ? normalizeScenePromptId(args.prompt) : undefined;
+        if (prompt === null) {
+            return fail('error.rules.invalidGroup', `提示词预设 id 非法：${String(args.prompt)}（仅小写字母/数字/连字符，且不能是备份槽）`);
+        }
         await ensureLayout();
         try {
             await mkdir(join(rulesRoot, name), { recursive: true });
@@ -1950,6 +2145,9 @@ export function createRulesService(ctx, deps) {
             return fail('error.rules.ioFailed', `创建场景目录失败：${message(e)}`);
         }
         const index = await readIndex(stateDir);
+        // **新场景默认不启动**：先把历史默认（active=null=全部启用）收敛成显式集合，
+        // 新建的这个自然不在其中；收敛后仍是"至多一个场景启用"。
+        const collapsed = collapseActiveForNewScene(index);
         if (!index.scenes)
             index.scenes = {};
         const prev = index.scenes[name] || {};
@@ -1957,6 +2155,7 @@ export function createRulesService(ctx, deps) {
             ...prev,
             ...(label !== '' && name !== GLOBAL_SCENE ? { label } : {}),
             ...(description !== '' ? { description } : {}),
+            ...(prompt !== undefined && prompt !== '' ? { prompt } : {}),
             order: prev.order ?? DEFAULT_GROUP_ORDER,
             createdAt: prev.createdAt ?? new Date().toISOString(),
         };
@@ -1966,10 +2165,10 @@ export function createRulesService(ctx, deps) {
         await writeIndex(stateDir, index);
         invalidateSnapshot();
         invalidateProviders();
-        return { ok: true, scene: sceneRecordOf(name, next) };
+        return { ok: true, scene: sceneRecordOf(name, next), ...(collapsed ? { collapsedActive: true } : {}) };
     }
     /**
-     * 更新场景记录（描述 / 显示名 / 顺序）。记忆文件不动。
+     * 更新场景记录（描述 / 显示名 / 顺序 / 绑定的提示词预设）。记忆文件不动。
      * 这是「场景有描述」的写入口——旧版场景只有目录名，没有可编辑元数据。
      */
     async function rulesUpdateScene(args) {
@@ -1993,6 +2192,20 @@ export function createRulesService(ctx, deps) {
             else
                 next.description = description;
         }
+        if (args && args.prompt !== undefined) {
+            const prompt = normalizeScenePromptId(args.prompt);
+            if (prompt === null) {
+                return fail('error.rules.invalidGroup', `提示词预设 id 非法：${String(args.prompt)}（仅小写字母/数字/连字符，且不能是备份槽）`);
+            }
+            // 绑定前校验预设确实存在：宁可现在拒绝，也不要留一个永远注入不出东西的悬空绑定。
+            if (prompt !== '' && !presetExistsSync(prompt)) {
+                return fail('error.rules.notFound', `提示词预设不存在：${prompt}`);
+            }
+            if (prompt === '')
+                delete next.prompt;
+            else
+                next.prompt = prompt;
+        }
         if (args && args.label !== undefined && name !== GLOBAL_SCENE) {
             const label = String(args.label).trim();
             if (label === '')
@@ -2047,6 +2260,15 @@ export function createRulesService(ctx, deps) {
         if (index.mode?.scene === name) {
             return fail('error.rules.sceneInMode', `场景「${name}」正处在当前模式，请先退出模式再删除`);
         }
+        // 场景本体（记录 + 档案）**先移入回收站**，再从索引里摘掉——这样「删除场景」
+        // 是可恢复的。记忆目录必须是空的（上面已拦），所以没有正文需要搬。
+        const trashed = await moveToTrash('scenes', name, [], {
+            record: (index.scenes && index.scenes[name]) || null,
+            archive: (index.archives && index.archives[name]) || null,
+        });
+        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 });
@@ -2072,8 +2294,91 @@ export function createRulesService(ctx, deps) {
             await writeIndex(stateDir, index);
         invalidateSnapshot();
         invalidateProviders();
+        return { ok: true, name, trashId: trashed.id };
+    }
+    /** 场景回收站列表（只读）：`<hub>/trash/scenes-trash/<id>/manifest.json`。 */
+    async function sceneTrashList() {
+        return { ok: true, trash: await listTrashEntries('scenes') };
+    }
+    /**
+     * 从回收站恢复一个场景：重建记忆目录 + 写回记录与档案。
+     * 同名场景已存在时**拒绝**（绝不覆盖既有场景）。
+     */
+    async function sceneTrashRestore(args) {
+        const id = String((args && args.id) || '').trim();
+        const entry = await readTrashEntry('scenes', id);
+        if (!entry)
+            return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+        const name = String(entry.name || '').trim();
+        if (!isValidGroupSegment(name))
+            return fail('error.rules.invalidGroup', `回收站里的场景名非法：${name || '(空)'}`);
+        const index = await readIndex(stateDir);
+        if (index.scenes?.[name])
+            return fail('error.rules.invalidGroup', `无法恢复，同名场景已存在：${name}`);
+        const dir = join(rulesRoot, name);
+        let entries = [];
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            entries = [];
+        }
+        if (entries.filter((n) => !n.startsWith('.')).length > 0) {
+            return fail('error.rules.sceneNotEmpty', `无法恢复，记忆目录「${name}」里已有内容，请先处理`);
+        }
+        const data = (entry.data || {});
+        try {
+            await mkdir(dir, { recursive: true });
+        }
+        catch (e) {
+            return fail('error.rules.ioFailed', `重建场景目录失败：${message(e)}`);
+        }
+        if (data.record && typeof data.record === 'object')
+            index.scenes = { ...(index.scenes || {}), [name]: data.record };
+        if (data.archive && typeof data.archive === 'object')
+            index.archives = { ...(index.archives || {}), [name]: data.archive };
+        await writeIndex(stateDir, index);
+        await purgeTrashEntry('scenes', id);
+        invalidateSnapshot();
+        invalidateProviders();
         return { ok: true, name };
     }
+    /** 永久删除一条场景回收站条目。 */
+    async function sceneTrashDelete(args) {
+        const id = String((args && args.id) || '').trim();
+        const gone = await purgeTrashEntry('scenes', id);
+        if (!gone)
+            return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+        return { ok: true, id };
+    }
+    /**
+     * 提示词预设改名后**同步场景绑定**：把所有 `scenes[].prompt === from` 改成 `to`。
+     * 由 AGENTS.md 预设库的改名路径调用——绑定存在 `rules-index.json` 里，预设库
+     * 自己看不到它，不叫这一声改名就会留下悬空绑定（场景卡片显示「预设不存在」）。
+     * @returns 改了几个场景。
+     */
+    async function rulesRebindPrompt(args) {
+        const from = String((args && args.from) || '').trim();
+        const to = String((args && args.to) || '').trim();
+        if (!from || !to)
+            return fail('error.rules.invalidArgs', '需要 from 与 to 两个预设 id');
+        const index = await readIndex(stateDir);
+        const scenes = index.scenes || {};
+        let changed = 0;
+        for (const [name, entry] of Object.entries(scenes)) {
+            if (entry && entry.prompt === from) {
+                scenes[name] = { ...entry, prompt: to };
+                changed++;
+            }
+        }
+        if (changed) {
+            index.scenes = scenes;
+            await writeIndex(stateDir, index);
+            invalidateSnapshot();
+            invalidateProviders();
+        }
+        return { ok: true, from, to, changed };
+    }
     async function rulesSetIndex(args) {
         const id = String((args && args.id) || '');
         const parts = parseId(id);
@@ -2130,8 +2435,10 @@ export function createRulesService(ctx, deps) {
     // index.ts 从本集合派生，勿在宿主端另抄一份。
     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-set-index', 'rules-set-active', 'rules-create-scene', 'rules-update-scene', 'rules-remove-scene', 'rules-rebind-prompt',
         'rules-attach', 'rules-detach', 'rules-trash-remove',
+        // 场景回收站（与记忆回收站 rules-trash-* 分开：那套管记忆正文，这套管场景记录与档案）
+        'scene-trash-restore', 'scene-trash-delete',
     ]);
     const ops = {
         'rules-list': (args) => rulesList(args || {}),
@@ -2153,6 +2460,10 @@ export function createRulesService(ctx, deps) {
         'rules-create-scene': (args) => runWrite(() => rulesCreateScene(args || {})),
         'rules-update-scene': (args) => runWrite(() => rulesUpdateScene(args || {})),
         'rules-remove-scene': (args) => runWrite(() => rulesRemoveScene(args || {})),
+        'scene-trash-list': () => sceneTrashList(),
+        'scene-trash-restore': (args) => runWrite(() => sceneTrashRestore(args || {})),
+        'scene-trash-delete': (args) => runWrite(() => sceneTrashDelete(args || {})),
+        'rules-rebind-prompt': (args) => runWrite(() => rulesRebindPrompt(args || {})),
     };
     const service = {
         ops,

package/lib/scene-prompt-sync.js

@@ -0,0 +1,112 @@
+// dsh-plugin-tool-management —— 场景绑定提示词 ⇄ 全局基线（`~/.dsh/AGENTS.md`）同步。
+//
+// 用户裁定（2026-09-15）：「切换场景，对应的提示词直接把 AGENTS.md 直接修改」。
+// 因此场景绑定的提示词不再作为 systemPrompt 段注入，而是**真写全局基线文件**，
+// 与「提示词」页的「应用」走同一条路（覆盖前多代备份到 `agents-md/__last-applied__/`）。
+//
+// 四个动作会触发同步（调用方在 op 层包一层 `withSync`）：
+//   ① 启用/切换场景    ② 关掉场景（恢复进场景前的基线）
+//   ③ 改场景绑定的预设  ④ 编辑"正在驱动基线的那份预设"的正文
+//
+// 「进场景前的基线」快照存在 hub 的 `scene-baseline.json`：进场景时记下当时的
+// AGENTS.md 正文（以及当时匹配到的预设 id），关掉场景时**按原文**写回 ——
+// 那份内容可能是用户手写的，不一定对应任何预设。恢复后把快照清空，避免之后再关一次
+// 场景时复活旧基线。
+//
+// 幂等与如实：文件已经是那份（`duplicate`）时不写盘；没有场景驱动、也没有快照时什么都不做；
+// 写失败**不改**原操作的成功结论，而是把原因放进 `error` 交给界面显示成警告。
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export function createScenePromptSync(deps) {
+    const warn = (message) => { try {
+        deps.logger?.warn?.(message);
+    }
+    catch { /* ignore */ } };
+    async function readBaseline() {
+        try {
+            const raw = await readFile(deps.baselineFile, 'utf8');
+            const obj = JSON.parse(raw);
+            if (!obj || typeof obj !== 'object')
+                return null;
+            return {
+                v: 1,
+                at: Number.isFinite(obj.at) ? Number(obj.at) : 0,
+                presetId: typeof obj.presetId === 'string' ? obj.presetId : null,
+                content: typeof obj.content === 'string' ? obj.content : null,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async function writeBaseline(next) {
+        try {
+            await mkdir(dirname(deps.baselineFile), { recursive: true });
+            await writeFile(deps.baselineFile, JSON.stringify(next), 'utf8');
+        }
+        catch (e) {
+            warn(`scene-prompt: could not persist baseline: ${String(e)}`);
+        }
+    }
+    async function state() {
+        try {
+            const r = await deps.rules.ops['rules-list']({});
+            const sp = r && r.ok ? r.scenePrompt : null;
+            if (!sp)
+                return null;
+            return {
+                scene: sp.scene ? String(sp.scene) : null,
+                presetId: sp.presetId ? String(sp.presetId) : null,
+                missing: sp.missing === true,
+                duplicate: sp.duplicate === true,
+            };
+        }
+        catch (e) {
+            warn(`scene-prompt: probe failed: ${String(e)}`);
+            return null;
+        }
+    }
+    async function sync() {
+        const current = await state();
+        if (!current)
+            return { unchanged: true };
+        const driving = current.scene !== null && !current.missing && current.presetId !== null;
+        if (driving) {
+            if (current.duplicate)
+                return { applied: current.presetId, unchanged: true };
+            // 进场景的第一笔写入之前，先记下当时的基线（已有快照就不覆盖：连续切场景时
+            // 基线始终是"进场景之前"那一份）。
+            const baseline = await readBaseline();
+            if (!baseline || baseline.content === null) {
+                const cur = await deps.agentsMd.getCurrent();
+                await writeBaseline({
+                    v: 1,
+                    at: Date.now(),
+                    presetId: cur && cur.ok && cur.presetId ? String(cur.presetId) : null,
+                    content: cur && cur.ok && cur.exists ? String(cur.content) : null,
+                });
+            }
+            const res = await deps.agentsMd.apply(current.presetId);
+            if (res && res.ok === false)
+                return { error: String(res.error || '写入 AGENTS.md 失败') };
+            return { applied: current.presetId };
+        }
+        // 没有场景驱动 → 如果刚从驱动态退出，把进场景前的基线写回去。
+        const baseline = await readBaseline();
+        if (!baseline || baseline.content === null)
+            return { unchanged: true };
+        const res = await deps.agentsMd.restore(baseline.content);
+        if (res && res.ok === false)
+            return { error: String(res.error || '恢复 AGENTS.md 失败') };
+        await writeBaseline({ v: 1, at: Date.now(), presetId: null, content: null });
+        return { restored: true };
+    }
+    async function withSync(res) {
+        const anyRes = res;
+        if (!anyRes || anyRes.ok === false)
+            return res;
+        const agentsMd = await sync();
+        return { ...res, agentsMd };
+    }
+    return { sync, withSync, state };
+}