dsh-plugin-tool-management 0.17.0 → 0.18.5

package/lib/memories/snapshot.js

@@ -8,13 +8,17 @@
 //
 // 对 service.ts 只做 type-only 引用（`import type`），避免与它形成运行时循环依赖。
 import { readdirSync, statSync } from 'node:fs';
-import { cp, lstat, mkdir, readFile, readdir, realpath, rename, rm } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { parseSkillDoc, resolveDshHome, unquote } from '../skills/core.js';
-import { MAX_SOURCE_DEPTH, MAX_DIRECTORIES, MAX_ENTRIES, MAX_DESCRIPTION_LENGTH, DEFAULT_ORDER, DEFAULT_GROUP_ORDER, GLOBAL_SCENE, TRUNCATION_MARKER, DROPPED_HEADING, SCENE_MEMORY_NOTE, LEGACY_BUNDLE_DOC, bundleDocName, SEGMENT_RULE_HINT, SHARED_GROUP, byteLen, message, isValidGroupSegment } from './constants.js';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { parseSkillDoc } from '../skills/core.js';
+import { MAX_SOURCE_DEPTH, MAX_DIRECTORIES, MAX_ENTRIES, DEFAULT_ORDER, DEFAULT_GROUP_ORDER, GLOBAL_SCENE, TRUNCATION_MARKER, DROPPED_HEADING, SCENE_MEMORY_NOTE, LEGACY_BUNDLE_DOC, bundleDocName, SHARED_GROUP, byteLen, message, isValidGroupSegment } from './constants.js';
 import { ensureSceneRecords, resolveActiveScenes, signatureOfIndex, sceneLabel, sceneHeading, sceneLine, compareSceneBuckets, memoryBlock } from './projection.js';
-import { isIndexQuarantined, readIndex, writeIndex, pathExists, readFileOrThrowSync, isAbsentError } from './index-io.js';
-export const identity = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
+import { isIndexQuarantined, readIndex, writeIndex, readFileOrThrowSync, isAbsentError } from './index-io.js';
+// 来源发现与投影（扫目录读成条目 / frontmatter 投成规则 / 老布局搬家）2026-10-01 整段搬到
+// ./discovery.js，正文一字未改（moved-verify 逐字对拍）。snapshot.js 的公开面照旧：搬走的
+// 九件全部从这里再出口 —— memories/service.ts 按 ./snapshot.js 引它们。
+export { deriveDescription, deriveFromDoc, discover, identity, projectRule, relocateLegacyLayout, } from './discovery.js';
+import { deriveFromDoc, discover, projectRule, } from './discovery.js';
 // ── 文件工具 ───────────────────────────────────────────────────────────────
 /**
  * BFS 发现（realpath 防环、深度/目录/条目预算），与 readonly-discovery 同构，
@@ -27,213 +31,10 @@ export const identity = (p) => (process.platform === 'win32' ? p.toLowerCase() :
  * 都没有则它是场景/子分类，继续遍历其下 .md（flat，任意层级）
  * 与子目录。同名 flat 与 bundle 冲突时 bundle 优先，flat 记入 shadowed。
  */
-export async function discover(memoriesRoot) {
-    const entries = new Map();
-    const shadowed = [];
-    const groups = new Set();
-    const scenes = [];
-    const warnings = [];
-    const rootPath = resolve(memoriesRoot);
-    try {
-        const st = await lstat(rootPath);
-        if (!st.isDirectory() || st.isSymbolicLink())
-            return { entries, shadowed, groups, scenes, warnings, truncated: false };
-    }
-    catch {
-        return { entries, shadowed, groups, scenes, warnings, truncated: false };
-    }
-    const queue = [
-        { path: rootPath, group: '', depth: 0, ancestors: new Set() },
-    ];
-    let directories = 0;
-    let itemCount = 0;
-    let truncated = false;
-    const addEntry = (entry) => {
-        const existing = entries.get(entry.id);
-        if (!existing) {
-            entries.set(entry.id, entry);
-            return;
-        }
-        if (entry.kind === 'bundle' && existing.kind === 'flat') {
-            shadowed.push({ ...existing, shadowed: true });
-            entries.set(entry.id, entry);
-            return;
-        }
-        if (entry.kind === 'flat' && existing.kind === 'bundle') {
-            shadowed.push({ ...entry, shadowed: true });
-        }
-    };
-    for (let cursor = 0; cursor < queue.length; cursor++) {
-        if (directories >= MAX_DIRECTORIES || itemCount >= MAX_ENTRIES) {
-            truncated = true;
-            break;
-        }
-        const current = queue[cursor];
-        let realDirectory;
-        let dirents = [];
-        try {
-            realDirectory = await realpath(current.path);
-            if (current.ancestors.has(identity(realDirectory)))
-                continue;
-            const dir = await readdir(current.path, { withFileTypes: true });
-            directories++;
-            for (const item of dir) {
-                if (itemCount >= MAX_ENTRIES) {
-                    truncated = true;
-                    break;
-                }
-                itemCount++;
-                dirents.push(item);
-            }
-        }
-        catch {
-            continue; // 失效链接或不可读目录不阻断其他来源
-        }
-        // 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 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 { /* 该候选名不存在 → 试下一个 */ }
-                }
-            }
-            if (docPath !== '') {
-                const id = parentGroup ? `${parentGroup}/${name}` : name;
-                addEntry({ id, group: parentGroup, name, kind: 'bundle', docPath, entryPath: current.path });
-                continue;
-            }
-        }
-        if (current.group !== '') {
-            groups.add(current.group);
-            // 一级目录 = 场景名（多段场景名用 '/' 连接，见 isValidGroupPath）。
-            if (current.depth === 1)
-                scenes.push(current.group);
-        }
-        dirents.sort((a, b) => a.name.localeCompare(b.name));
-        const ancestors = new Set(current.ancestors).add(identity(realDirectory));
-        for (const item of dirents) {
-            if (item.name.startsWith('.'))
-                continue; // 隐藏目录/文件跳过
-            const path = join(current.path, item.name);
-            try {
-                const st = await lstat(path);
-                // 符号链接一律不跟随：注入路径（`probeSceneFilesSync`）本来就不跟随，两端必须同口径 ——
-                // 否则列表里会出现**永远注入不进去**的记忆（用户打开开关却什么也没发生）。顺带也关掉了
-                // 「链接指向根外、写操作顺着链接穿透出去」这条路（写入侧另有 realpath 断言兜底）。
-                if (st.isSymbolicLink())
-                    continue;
-                if (st.isDirectory()) {
-                    if (!isValidGroupSegment(item.name)) {
-                        warnings.push(`跳过非法目录名（${SEGMENT_RULE_HINT}）：${current.group ? current.group + '/' : ''}${item.name}`);
-                        continue;
-                    }
-                    if (current.depth >= MAX_SOURCE_DEPTH || queue.length >= MAX_DIRECTORIES) {
-                        truncated = true;
-                        continue;
-                    }
-                    queue.push({
-                        path,
-                        group: current.group ? `${current.group}/${item.name}` : item.name,
-                        depth: current.depth + 1,
-                        ancestors,
-                    });
-                    continue;
-                }
-                if (!st.isFile())
-                    continue;
-                if (!item.name.toLowerCase().endsWith('.md'))
-                    continue; // 只认 .md
-                const name = item.name.slice(0, -3);
-                const id = current.group ? `${current.group}/${name}` : name;
-                addEntry({ id, group: current.group, name, kind: 'flat', docPath: path, entryPath: path });
-            }
-            catch {
-                /* 来源在扫描期间失效时跳过 */
-            }
-        }
-    }
-    return { entries, shadowed, groups, scenes, warnings, truncated };
-}
 // ── 规则解析 + 派生 ────────────────────────────────────────────────────────
 /** 派生 description：首个 `#` 标题 → 首个非空行；截断 500 字符。 */
-export function deriveDescription(body) {
-    const text = String(body ?? '').trim();
-    if (!text)
-        return '';
-    const heading = /^#\s+(.+)$/m.exec(text);
-    const raw = heading && heading[1].trim() ? heading[1].trim() : text.split(/\r?\n/, 1)[0].trim();
-    return raw.slice(0, MAX_DESCRIPTION_LENGTH);
-}
 /** 从 frontmatter/正文派生字段（派生只存在于内存投影，不写回文件）。 */
-export function deriveFromDoc(entry, doc) {
-    const declaredName = doc.map.name != null && String(doc.map.name).trim() !== '' ? unquote(String(doc.map.name)).trim() : '';
-    const name = declaredName || entry.name;
-    let description = doc.map.description != null ? unquote(String(doc.map.description)).trim() : '';
-    let descriptionDerived = false;
-    if (description === '') {
-        description = deriveDescription(doc.body);
-        descriptionDerived = true;
-    }
-    const globs = doc.map.globs != null && String(doc.map.globs).trim() !== '' ? String(doc.map.globs).trim() : undefined;
-    let whenToUse;
-    if (doc.map.whenToUse != null && String(doc.map.whenToUse).trim() !== '') {
-        whenToUse = String(doc.map.whenToUse).trim();
-    }
-    else if (globs) {
-        whenToUse = `适用路径：${globs}`;
-    }
-    const metadata = doc.map.metadata !== undefined ? doc.map.metadata : undefined;
-    return { name, description, descriptionDerived, whenToUse, globs, metadata };
-}
 /** 合并索引字段（enabled/order 等以索引为准；无记录走默认投影）。 */
-export function projectRule(entry, derived, idxEntry) {
-    // 体积按**正文文件**算（bundle 的附件不计：附件不进注入正文）。一次 stat 一条记忆，
-    // 结果随快照的 1s TTL 缓存一起复用；读不到就不带这个字段，别把"不知道"报成 0 B。
-    let size;
-    try {
-        size = statSync(entry.docPath).size;
-    }
-    catch {
-        size = undefined;
-    }
-    const rule = {
-        id: entry.id,
-        group: entry.group,
-        name: derived.name,
-        form: entry.kind,
-        path: entry.docPath,
-        ...(size !== undefined ? { bytes: size } : {}),
-        description: derived.description,
-        ...(derived.descriptionDerived ? { descriptionDerived: true } : {}),
-        ...(derived.whenToUse !== undefined ? { whenToUse: derived.whenToUse } : {}),
-        ...(derived.globs !== undefined ? { globs: derived.globs } : {}),
-        ...(derived.metadata !== undefined ? { metadata: derived.metadata } : {}),
-        enabled: idxEntry?.enabled ?? true,
-        order: idxEntry?.order ?? DEFAULT_ORDER,
-        tags: Array.isArray(idxEntry?.tags) ? idxEntry.tags : [],
-        pinned: idxEntry?.pinned === true,
-        note: typeof idxEntry?.note === 'string' ? idxEntry.note : '',
-        ...(typeof idxEntry?.updatedAt === 'string' ? { updatedAt: idxEntry.updatedAt } : {}),
-    };
-    return rule;
-}
 // ── 侧车文件（索引 / 场景）─────────────────────────────────────────────────
 /** 把旧布局搬进 `tool-management/`（每个进程只尝试一次，幂等）。
  *
@@ -246,49 +47,6 @@ export function projectRule(entry, derived, idxEntry) {
  * 源目录**保留**（内容已搬走，留空壳不影响正确性，也方便用户核对）。
  * 目标已存在同名项 → 保留目标、跳过该项（绝不覆盖新数据）。
  */
-export async function relocateLegacyLayout(memoriesRoot) {
-    const home = resolveDshHome();
-    const legacyRoots = [join(home, 'scene-memory'), join(home, 'rules')];
-    for (const legacyRoot of legacyRoots) {
-        if (!(await pathExists(legacyRoot)))
-            continue;
-        if (identity(resolve(legacyRoot)) === identity(resolve(memoriesRoot)))
-            continue; // 自定义 roots 落在旧路径 → 不自我搬移
-        let items;
-        try {
-            items = await readdir(legacyRoot, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const item of items) {
-            if (item.name.startsWith('.'))
-                continue;
-            const src = join(legacyRoot, item.name);
-            // 根层 .md = 旧的「全局」桶 → 搬进 `global/`，文件名保留（否则多套一层目录）。
-            // 其余条目（场景目录）整体搬进 memories/，目录名保留。
-            const isRootMd = item.isFile() && item.name.toLowerCase().endsWith('.md');
-            const destDir = isRootMd ? join(memoriesRoot, GLOBAL_SCENE) : memoriesRoot;
-            const dest = join(destDir, item.name);
-            try {
-                if (await pathExists(dest))
-                    continue;
-                await mkdir(destDir, { recursive: true });
-                try {
-                    await rename(src, dest);
-                }
-                catch {
-                    // 跨设备/被占用 → 复制后删源；复制失败则保留源文件（宁可重复，不可丢失）。
-                    await cp(src, dest, { recursive: true });
-                    await rm(src, { recursive: true, force: true });
-                }
-            }
-            catch {
-                /* 单项失败不阻断其余项（如文件被外部程序锁住，下次启动再试） */
-            }
-        }
-    }
-}
 // ── 快照（发现 + 索引合并 + 索引清理）──────────────────────────────────────
 export async function buildSnapshot(memoriesRoot, stateDir) {
     const discovery = await discover(memoriesRoot);

package/lib/op-registry.js

@@ -153,6 +153,22 @@ export const OP_REGISTRY = Object.freeze({
     'agentsmd-import': { write: true, frozen: true },
     'agentsmd-trash-restore': { write: true, frozen: true },
     'agentsmd-trash-delete': { write: true, frozen: true },
+    // ── 快捷提示词域（8）───────────────────────────────────────────────────────
+    // 只改插件自己的侧车（`hub/quick-prompts/`），不写 AGENTS.md、不进场景、不进注入；
+    // 但"改用户存好的东西"按本文件口径就是写操作（判据不是"会不会写盘"，见文件头）。
+    // frozen 与五个管理域同一条：**锁定期间整体只读**（用户裁定 2026-09-30，不给它开例外，
+    // 免得"锁定"这件事要分两套话术解释）。
+    'quickprompt-list': { readonly: true },
+    'quickprompt-trash-list': { readonly: true },
+    'quickprompt-create': { write: true, frozen: true },
+    'quickprompt-update': { write: true, frozen: true },
+    // 那颗开关改的是"这条在不在对话框 `/` 菜单里出现"，动的仍是用户自己的东西 ——
+    // 与 create/update 同档，不因为它不碰正文就免了令牌。`syncsArchive`：场景绑了快捷词时，
+    // 在场景里手动开关一条要跟着改进那份勾选集（未绑定的场景不跟，见 index.ts 那一支的注释）。
+    'quickprompt-toggle': { write: true, frozen: true, syncsArchive: true },
+    'quickprompt-remove': { write: true, frozen: true },
+    'quickprompt-trash-restore': { write: true, frozen: true },
+    'quickprompt-trash-delete': { write: true, frozen: true },
     // ── 历史会话域（16）────────────────────────────────────────────────────────
     'history-list': { readonly: true },
     'history-sessions': { readonly: true },
@@ -205,6 +221,11 @@ export const OP_REGISTRY = Object.freeze({
     // **刻意不冻结**：它只是界面提示，锁着场景的人在场景页照样该能关掉提醒 —— 冻结的是五个
     // 管理域的改动，不是这个页面的显示偏好（判据见文件头 write/frozen 两段的边界）。
     'scene-settings': { write: true, writeWhen: (a) => a.set === true },
+    // 斜杠命令入口的开关（侧车 `slash-settings.json`）：与 `scene-settings` 同规格 —— 写侧车所以
+    // 按写门禁，但**刻意不冻结**（关掉一个界面入口不属于五个管理域的改动）。读侧不带 `set` 是纯读：
+    // 客户端 boot 时必问一次决定挂不挂 `/` 菜单，那一次不能要令牌，否则没配令牌的宿主上这个功能
+    // 永远出不来。
+    'slash-settings': { write: true, writeWhen: (a) => a.set === true },
     // 清理 patch 备份：删磁盘文件（备份里含明文凭据副本），按写操作门禁。
     'backups-clean': { write: true },
     // ── 场景候选源（4）与内联（1）──────────────────────────────────────────────

package/lib/ops/compat.js

@@ -259,6 +259,17 @@ export function buildCompatOps(deps) {
                     key: 'tool-table', label: '模型工具表', tab: 'compat', state: 'ok', detail: offPart,
                     hidden: table.hiddenCount, total: table.totalCount, defaults: table.defaultHiddenCount,
                 });
+                // 斜杠命令入口（`/` 菜单里的「工具」与「快捷提示词」两段，各一颗开关）。服务端只知道
+                // **开关开没开**：真正挂没挂上是浏览器那半的事（宿主有没有 `inputTriggers` 服务），那一句
+                // 由兼容页就地报，不冒充服务端探测（见 client 48-slash.js 的挂载状态）。两个布尔一起带上，
+                // "开着哪一段"由界面按语言说。
+                const slash = await deps.readSlashSettings();
+                push({
+                    key: 'slash-commands', label: '斜杠命令入口', tab: 'compat',
+                    state: slash.tools || slash.quickPrompts ? 'ok' : 'disabled',
+                    detail: slash.tools || slash.quickPrompts ? '开关已开（在对话输入框打 / 唤出已打开的那几段）' : '两段都已关闭（本页可重新打开）',
+                    slashTools: slash.tools, slashQuickPrompts: slash.quickPrompts,
+                });
                 const nativeNote = notes.get('workspace.delete-native');
                 push({
                     key: 'native-delete', label: '宿主原生删除入口', tab: 'compat',

package/lib/ops/quick-prompts.js

@@ -0,0 +1,26 @@
+// 快捷提示词域的 HTTP ops（实现见 ../prompts/quick-service.ts）。
+//
+// 与 `ops/prompts.ts` 的差别不是"少写了几条"，而是**这个域没有宿主状态**：不写
+// `~/.dsh/AGENTS.md`、不参与场景同步、没有"生效中"。所以这里既不需要 `withAgentsMdSync`
+// 也不需要引用探测 —— 反过来，正因为它是纯侧车读写，才更要老老实实进 `op-registry`
+// 的写门禁清单（配了令牌的宿主上，免令牌请求不该能改用户存好的文字）。
+export function buildQuickPromptOps(quick) {
+    const text = (args, key) => args && typeof args[key] === 'string' ? String(args[key]) : undefined;
+    return {
+        // 列表连正文一起回（客户端点用时手里就得有那段字，见 quick-service.ts 头注）。
+        'quickprompt-list': async () => quick.list(),
+        'quickprompt-create': (args) => quick.create(String((args && args.id) || ''), text(args, 'content') ?? '', text(args, 'description')),
+        // 改名不牵连任何别处：快捷提示词不被场景绑定、不被引用，改完就是改完了。
+        'quickprompt-update': (args) => quick.update(String((args && args.id) || ''), text(args, 'content') ?? '', args && args.nextId !== undefined ? String(args.nextId) : undefined, text(args, 'description')),
+        'quickprompt-remove': (args) => quick.remove(String((args && args.id) || '')),
+        // 启停只改侧车的 `enabled`（在不在对话框 `/` 菜单里出现），正文一个字不动。
+        // `enabled` 必须是真布尔：省略它不叫"打开"，而是调用方写错了，静默按某一种处理会
+        // 让界面与落盘各说各话。
+        'quickprompt-toggle': (args) => (args && typeof args.enabled === 'boolean')
+            ? quick.setEnabled(String((args && args.id) || ''), args.enabled === true)
+            : Promise.resolve({ ok: false, error: '缺少 enabled（true / false）' }),
+        'quickprompt-trash-list': () => quick.trashList(),
+        'quickprompt-trash-restore': (args) => quick.trashRestore(String((args && args.id) || '')),
+        'quickprompt-trash-delete': (args) => quick.trashDelete(String((args && args.id) || '')),
+    };
+}

package/lib/ops/scene-records.js

@@ -8,6 +8,21 @@ import { listTrashEntries, moveIntoTrash, moveOutOfTrash, moveToTrash, purgeTras
 import { MAX_DESCRIPTION_LENGTH, DEFAULT_GROUP_ORDER, GLOBAL_SCENE, GLOBAL_SCENE_LABEL, SHARED_GROUP, SEGMENT_RULE_HINT, isValidGroupSegment, isValidGroupPath, message, fail } from '../memories/constants.js';
 import { normalizeActive, collapseActiveForNewScene } from '../memories/projection.js';
 import { readIndex, writeIndex, sceneRecordOf, normalizeScenePromptId, pathExists } from '../memories/index-io.js';
+/** `quickPrompts` 参数的三种形态：不传 = 完全不碰这一域；null / 非数组 = 解绑（删字段）；
+ *  数组 = 勾选集（去重去空）。**空数组是合法值**（= 进入后全部停用），不能当成"没绑"。 */
+function quickPromptsArg(args) {
+    if (!args || args.quickPrompts === undefined)
+        return undefined;
+    if (!Array.isArray(args.quickPrompts))
+        return null;
+    const out = [];
+    for (const item of args.quickPrompts) {
+        const id = String(item == null ? '' : item).trim();
+        if (id && out.indexOf(id) < 0)
+            out.push(id);
+    }
+    return out;
+}
 /** 组装本域 op。rc 由 createMemoriesService 组装，契约见 ./ctx.ts。 */
 export function buildSceneRecordOps(rc) {
     const { ensureLayout, invalidateSnapshot, presetExistsSync, memoriesRoot, refuseOutsideRoot, sceneRows, snapshot, stateDir } = rc;
@@ -132,6 +147,14 @@ export function buildSceneRecordOps(rc) {
                 index.archives = {};
             index.archives[name] = { ...(index.archives[name] || {}), toolTablePreset };
         }
+        // 快捷提示词勾选集（0.18.0）：同样存进**档案**。空数组也要落 —— 它说的是"进入后全部停用"，
+        // 与"没绑"（不碰这一域）是相反的意思。
+        const quickCreate = quickPromptsArg(args);
+        if (quickCreate) {
+            if (!index.archives)
+                index.archives = {};
+            index.archives[name] = { ...(index.archives[name] || {}), quickPrompts: quickCreate };
+        }
         await writeIndex(stateDir, index);
         invalidateSnapshot();
         return { ok: true, scene: sceneRecordOf(name, next), ...(collapsed ? { collapsedActive: true } : {}) };
@@ -204,6 +227,23 @@ export function buildSceneRecordOps(rc) {
             else
                 delete index.archives[name];
         }
+        if (args && args.quickPrompts !== undefined) {
+            // 快捷提示词勾选集（0.18.0，用户裁定入口在「修改场景」表单）：与工具表方案同一族 ——
+            // 绑定存**档案**，这一次读-改-写顺带落掉。`null` = 解绑（这一域回到"保持现状"）；
+            // 空数组 = 绑定了但一条都没勾（进入后全部停用），**不是**解绑。不传这个参数 = 完全不碰。
+            const quick = quickPromptsArg(args);
+            if (!index.archives)
+                index.archives = {};
+            const archive = { ...((index.archives && index.archives[name]) || {}) };
+            if (quick === null)
+                delete archive.quickPrompts;
+            else if (quick !== undefined)
+                archive.quickPrompts = quick;
+            if (Object.keys(archive).length > 0)
+                index.archives[name] = archive;
+            else
+                delete index.archives[name];
+        }
         if (args && args.label !== undefined && name !== GLOBAL_SCENE) {
             const label = String(args.label).trim();
             if (label === '')

package/lib/ops/scene-sync.js

@@ -2,6 +2,56 @@
 //
 // rules 域的**其余 op 由 ./memories/service.ts 直接 spread 进表**，不经过本文件 —— 这里只放
 // 四个要走「场景 ↔ 全局基线同步」包装的写 op。
+import { GLOBAL_SCENE, SHARED_GROUP } from '../memories/constants.js';
+/** 参数形态不归本层管（多场景 / 非法名 / `all`）：交给原 op 校验并报错，运行时一律不动。 */
+const SKIP = Symbol('skip');
+/**
+ * 「启用集合」与「当前模式」是同一个意图的两片状态：`active` 决定记忆与绑定的提示词按哪个
+ * 场景注入，`mode.scene` 决定运行时（MCP / 技能 / 人设 / 工具表 / 快捷词）停在哪份档案上。
+ * 两者必须恒等 —— 历史上每次只有一个动，就出现过一个方向各坏一次：拨开关不应用档案（面板
+ * 0.9.x 的旧账，见 45-scenes.js 的 ⚠️ 注释），以及 `/` 菜单进 / 出场景只写 `active`
+ * （用户 2026-10-01 报，图见 CHANGELOG）。
+ *
+ * 所以这里**在服务端兜住这条不变量**，而不是要求每个调用方各开两枪：`rules-set-active` 是
+ * "我要让哪个场景生效"的那个 op，四个调用方（面板开关、`/` 菜单、模型工具、以后新增的入口）
+ * 只要调它，运行时就会跟着对齐。
+ *
+ * 顺序是**先切运行时、后写启用集合**：引擎会校验场景存在、没被锁、绑的工具表方案还在，
+ * 它拒绝时启用集合必须一个字都不动。反过来（先写 active）留下的正是"开关过去了、运行时没切"
+ * 那个半截状态 —— 也就是这一版要消灭的东西。
+ */
+async function syncModeToActive(args, deps) {
+    const want = targetSceneOf(args);
+    if (want === SKIP)
+        return null;
+    if (want === (await deps.currentModeScene()))
+        return null;
+    return deps.sceneModeSet({ scene: want });
+}
+/**
+ * 从 `scenes:[...]` 里取出"这一次要让哪个场景生效"（`null` = 一个都不让 = 退出模式）。
+ *
+ * 保留名的过滤与去重和 `rulesSetActive` **同源**（同一份常量，不是抄一份）：`_shared` 与
+ * `global` 恒常生效，不进显式集合 —— 所以 `['global','_shared']` 与原 op 一样读成"清空"。
+ * 收敛后仍多于一个 = 单选模型下的非法请求，原 op 会拒，这里回 SKIP 让运行时一动不动
+ * （宁可少切一次，也不要按一个原 op 马上要拒绝的参数去改运行时）。
+ */
+function targetSceneOf(args) {
+    if (args && args.all === true)
+        return SKIP;
+    const raw = args && args.scenes;
+    if (!Array.isArray(raw))
+        return SKIP;
+    const names = [];
+    for (const item of raw) {
+        const name = String(item == null ? '' : item).trim();
+        if (!name || name === SHARED_GROUP || name === GLOBAL_SCENE)
+            continue;
+        if (names.indexOf(name) < 0)
+            names.push(name);
+    }
+    return names.length > 1 ? SKIP : (names[0] ?? null);
+}
 export function buildSceneSyncOps(deps) {
     return {
         // 场景 ↔ 全局基线（AGENTS.md）同步：用户裁定「切换场景，对应的提示词直接把 AGENTS.md
@@ -9,7 +59,20 @@ export function buildSceneSyncOps(deps) {
         // 提示词写进 `~/.dsh/AGENTS.md`（或关掉场景时恢复进场景前的基线），结果并进响应
         // 的 `agentsMd` 字段（`applied` / `restored` / `unchanged` / `error`）。
         // 组装时放在 memoriesService.ops 的 spread **之后**，显式覆盖同名 op。
-        'rules-set-active': async (args) => deps.withAgentsMdSync(await deps.rulesOps['rules-set-active'](args)),
+        //
+        // `rules-set-active` 额外承担「两轴恒等」（见文件头）：先把运行时切到位，再写启用集合。
+        'rules-set-active': async (args) => {
+            const mode = await syncModeToActive(args, deps);
+            if (mode && mode.ok === false)
+                return mode;
+            const res = await deps.rulesOps['rules-set-active'](args);
+            if (!res || res.ok === false)
+                return res;
+            // 引擎跳过的档案键（本机已不存在的服务器 / 技能键）并进来给调用方 —— 面板与 `/` 都要
+            // 那句"进了，但没全进"。
+            const stale = mode && Array.isArray(mode.stale) && mode.stale.length ? mode.stale : null;
+            return deps.withAgentsMdSync(stale ? Object.assign({}, res, { modeStale: stale }) : res);
+        },
         'rules-update-scene': async (args) => {
             const res = await deps.rulesOps['rules-update-scene'](args);
             // 工具表方案绑定改动（0.15.0）：改的是**当前启用场景**且这次真的带了这一参数时即时生效；
@@ -20,6 +83,13 @@ export function buildSceneSyncOps(deps) {
                 }
                 catch { /* 即时生效失败不拦保存；下次进/退场景会对齐 */ }
             }
+            // 快捷提示词勾选集同理：只有这次真的带了这一参数才动（不传 = 不碰这一域）。
+            if (res && res.ok !== false && deps.onQuickPromptsChanged && args && args.quickPrompts !== undefined) {
+                try {
+                    await deps.onQuickPromptsChanged(String(args.name || ''), Array.isArray(args.quickPrompts) ? args.quickPrompts.map((x) => String(x)) : null);
+                }
+                catch { /* 同上 */ }
+            }
             return deps.withAgentsMdSync(res);
         },
         'rules-create-scene': async (args) => deps.withAgentsMdSync(await deps.rulesOps['rules-create-scene'](args)),

package/lib/ops/sessions.js

@@ -205,9 +205,13 @@ export function buildSessionOps(deps) {
             if (!sessionId)
                 return { ok: false, error: '缺少 sessionId' };
             try {
-                const r = await registry.unarchiveSession(sessionId);
+                // 不接 registry 的返回值：官方 `unarchiveSession` 是 `Promise<void>`，而界面只要
+                // ok / error / workspace —— 每次单条恢复都把整个归档集合回传一遍纯属浪费。
+                // 0.18.5 之前这里读 `r.archivedSessionIds`，于是宿主恢复**成功之后**构造回执时抛
+                // TypeError，界面弹「操作失败」，用户以为没恢复、其实已经恢复了。
+                await registry.unarchiveSession(sessionId);
                 const workspace = await deps.restoreWorkspaceAccounting([sessionId]);
-                return { ok: true, archivedSessionIds: r.archivedSessionIds, ...(workspace ? { workspace } : {}) };
+                return { ok: true, sessionId, ...(workspace ? { workspace } : {}) };
             }
             catch (e) {
                 return { ok: false, error: deps.message(e) };
@@ -278,7 +282,8 @@ export function buildSessionOps(deps) {
             try {
                 const r = await registry.unarchiveSessions(parsed.target);
                 const workspace = await deps.restoreWorkspaceAccounting(r.unarchivedSessionIds || []);
-                return { ok: true, unarchivedSessionIds: r.unarchivedSessionIds, archivedSessionIds: r.archivedSessionIds, ...(workspace ? { workspace } : {}) };
+                // 只报「这次恢复了哪些」，不把整个归档集合快照发回界面（同上，界面不读它）。
+                return { ok: true, unarchivedSessionIds: r.unarchivedSessionIds, ...(workspace ? { workspace } : {}) };
             }
             catch (e) {
                 return { ok: false, error: deps.message(e) };
@@ -392,15 +397,15 @@ export function buildSessionOps(deps) {
         // 打包用已在依赖里的 `fflate.zipSync`（此前只用了 unzipSync）。
         'bundle-export': async (args) => {
             const kind = String((args && args.kind) || '');
-            const KINDS = ['skills', 'subagents', 'presets', 'memories'];
+            const KINDS = ['skills', 'subagents', 'presets', 'quick-prompts', 'memories'];
             if (KINDS.indexOf(kind) < 0)
                 return { ok: false, error: `kind 需为 ${KINDS.join(' / ')}` };
             const rawNames = (args && args.names) || [];
             const names = Array.isArray(rawNames) ? rawNames.map((s) => String(s).trim()).filter(Boolean) : [];
             if (!names.length)
                 return { ok: false, error: '请至少选择一项' };
-            // 名字逐项校验：子智能体与提示词这两个域的名字会被拼成绝对路径直接进 readFile，
-            // `..` 或路径分隔符能读到根外（此前只做 trim().filter(Boolean)）。
+            // 名字逐项校验：子智能体、提示词预设与快捷提示词这三个域的名字会被拼成绝对路径直接进
+            // readFile，`..` 或路径分隔符能读到根外（此前只做 trim().filter(Boolean)）。
             // 另外两个域**不套单段谓词**，原因不同：
             //   - 记忆：名字是 `<场景>/<名>` 的 id，只用来查索引拿路径，本身不参与拼接；
             //   - 技能：名字可以是多段相对路径（只读来源的 bundle 用 relative() 拼出名字），
@@ -408,7 +413,7 @@ export function buildSessionOps(deps) {
             //     匹配不上就进 missing，套单段谓词反而会把合法的多段技能名误杀。
             const rejected = [];
             const accepted = names.filter((name) => {
-                const ok = kind === 'presets' ? isValidPresetId(name)
+                const ok = kind === 'presets' || kind === 'quick-prompts' ? isValidPresetId(name)
                     : kind === 'subagents' ? validPersonaName(name)
                         : true;
                 if (!ok)
@@ -441,16 +446,20 @@ export function buildSessionOps(deps) {
                         entries.push({ zip: `${name}.md`, abs });
                     }
                 }
-                else if (kind === 'presets') {
+                else if (kind === 'presets' || kind === 'quick-prompts') {
+                    // 两个提示词域同形（一 id 一目录、正文 + `meta.json` 描述侧车），差别只在根目录与
+                    // 正文文件名 —— 走同一段代码，别让"导出快捷词"变成第二份会漏改的拷贝。
+                    const root = kind === 'quick-prompts' ? deps.quickPromptsDir : deps.promptsDir;
+                    const doc = kind === 'quick-prompts' ? 'PROMPT.md' : 'AGENTS.md';
                     for (const id of accepted) {
-                        const docAbs = join(deps.promptsDir, id, 'AGENTS.md');
-                        if (!isInsideRoot(deps.promptsDir, docAbs)) {
+                        const docAbs = join(root, id, doc);
+                        if (!isInsideRoot(root, docAbs)) {
                             missing.push(id);
                             continue;
                         }
-                        entries.push({ zip: `${id}/AGENTS.md`, abs: docAbs });
+                        entries.push({ zip: `${id}/${doc}`, abs: docAbs });
                         // 描述侧车（预设那句说明）随预设一起走：导出再导入不该把它丢掉。
-                        const metaAbs = join(deps.promptsDir, id, 'meta.json');
+                        const metaAbs = join(root, id, 'meta.json');
                         try {
                             if ((await stat(metaAbs)).isFile())
                                 entries.push({ zip: `${id}/meta.json`, abs: metaAbs });
@@ -560,6 +569,8 @@ export function buildSessionOps(deps) {
         },
         // 把选中的归档会话导出为可再导入的转录文件（Markdown / JSONL），写入指定目录。
         // 每个会话一个文件；读不到正文的冷会话列入 skipped，不中断其余导出。
+        // `detail` 三档**累进**：`simple`（默认）只有正文；`tools` 另加工具调用与结果、附件名；
+        // `full` 再加思考。
         'history-export': async (args) => {
             const rawIds = (args && args.sessionIds) || [];
             const ids = Array.isArray(rawIds) ? rawIds.map((s) => String(s).trim()).filter(Boolean) : [];
@@ -568,6 +579,11 @@ export function buildSessionOps(deps) {
             const format = String((args && args.format) || 'markdown').toLowerCase();
             if (format !== 'markdown' && format !== 'jsonl')
                 return { ok: false, error: 'format 需为 markdown 或 jsonl' };
+            // 收到不认识的档位就出声：静默降级会让用户以为导出的是带工具的版本，而它其实只有正文。
+            const rawDetail = String((args && args.detail) || 'simple').toLowerCase();
+            if (rawDetail !== 'simple' && rawDetail !== 'tools' && rawDetail !== 'full')
+                return { ok: false, error: 'detail 需为 simple / tools / full' };
+            const detail = rawDetail;
             const outDir = String((args && args.outDir) || '').trim();
             if (!/^([A-Za-z]:[\\/]|\\\\|\/)/.test(outDir))
                 return { ok: false, error: '导出目录需为绝对路径' };
@@ -623,9 +639,13 @@ export function buildSessionOps(deps) {
                 const path = join(outDir, fileName);
                 try {
                     const events = await readEvents(sessionId);
-                    const turns = deps.extractTurnsFromEvents(events || []);
+                    const turns = deps.extractTurnsFromEvents(events || [], detail);
                     if (!turns.length) {
-                        skipped.push({ sessionId, error: events ? '会话中没有可导出的消息' : '无法读取会话内容（不在活动存储且无持久化句柄）' });
+                        // 简洁档现在**不含思考与工具**（0.18.5 之前思考被混在正文里），所以"只有思考没正文"
+                        // 的会话会第一次变成导不出来 —— 得说清楚是档位问题，不是内容丢了。
+                        skipped.push({ sessionId, error: !events ? '无法读取会话内容（不在活动存储且无持久化句柄）'
+                                : detail !== 'full' ? '会话中没有可导出的正文（思考与工具调用不计入本档 —— 换更高一档可以导出它们）'
+                                    : '会话中没有可导出的消息' });
                         continue;
                     }
                     // `'wx'`：绝不覆盖已存在的同名文件 —— 覆盖是静默的，用户会以为导出成功