dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/ops/scene-records.js

@@ -4,13 +4,28 @@
 // 提示词改绑。动的是 index 的 scenes / active 切片与 AGENTS.md 投影，与记忆正文 ops 互不调用。
 import { mkdir, readdir, rename, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { listTrashEntries, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
+import { listTrashEntries, moveIntoTrash, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
 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, sceneRows, snapshot, stateDir } = rc;
+    const { ensureLayout, invalidateSnapshot, presetExistsSync, memoriesRoot, refuseOutsideRoot, sceneRows, snapshot, stateDir } = rc;
     /**
      * 设置"启用场景"（全局持久化，切换后**下一个请求即生效**，§4 对照表）。
      *   - `args.scenes` 数组 → 启用集合；**至多一个非保留场景**（用户裁定：除「全局」外
@@ -39,7 +54,13 @@ export function buildSceneRecordOps(rc) {
             // 恒常启用的保留场景不入显式集合：`_shared`（公共基线）与 `global`（「全局」）。
             if (name === '' || name === SHARED_GROUP || name === GLOBAL_SCENE)
                 continue;
-            if (!isValidGroupPath(name)) {
+            // 启用集合里的场景名必须是**单个路径段**（2026-09-30 审查 P2-4）。此前这里走
+            // `isValidGroupPath`，于是 `a/b` 这种多段名**通过校验并被写进 `active`**，但它压根
+            // 不是一个场景：场景恒等于一级目录（见 `snapshot.ts` 的 `depth === 1` 与
+            // `projection.ts` 的 `sceneOf`），注入时桶名是 `a`、`active` 里写的是 `a/b` ——
+            // 两边对不上，用户看到的是"开关点了、场景没生效"，且**没有任何报错**。
+            // 改成单段后这种名字会当场被拒（响亮地失败），与创建/改名的口径一致。
+            if (!isValidGroupSegment(name)) {
                 return fail('error.rules.invalidGroup', `场景名非法：${name}（${SEGMENT_RULE_HINT}）`);
             }
             if (seen.has(name))
@@ -63,8 +84,14 @@ export function buildSceneRecordOps(rc) {
     /**
      * 新建场景：写一条场景记录（索引 scenes 切片）+ 建空目录 `memories/<场景>/`。
      * 场景是**显式实体**——空场景（还没有记忆）也是合法场景，会出现在场景列表里。
-     * 场景名是**单个路径段**（不允许 `a/b`）：界面把场景当一级列表展示，
-     * 允许多段只会让「记忆的场景」与「目录层级」两套语义互相打架。
+     *
+     * 场景名的统一口径（2026-09-30 审查 P2-4 收敛，此前全仓分成两派）：
+     *   - **命名路径**（新建 / 改名目标 / 启用集合）一律是**单个路径段**。场景恒等于一级目录
+     *     （见 `snapshot.ts` 的 `depth === 1` 与 `projection.ts` 的 `sceneOf`），允许 `a/b`
+     *     只会让「场景」与「场景内的分组」两套语义互相打架，而且启用时桶名对不上（静默失效）。
+     *   - **定位路径**（改名的旧名 / 锁定 / 删除 / 回收站恢复）按**完整路径**寻址，`isValidGroupPath`。
+     *     历史与导入留下的多段记录因此仍能被改名或删除 —— 否则它们成了"看得见、动不了"的死条目。
+     *
      * 幂等：已存在则更新描述/标签，不报错。`_shared` 与 `global` 是保留名。
      */
     async function rulesCreateScene(args) {
@@ -120,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 } : {}) };
@@ -192,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 === '')
@@ -249,6 +301,18 @@ export function buildSceneRecordOps(rc) {
                     index.archives[nextRaw] = index.archives[name];
                     delete index.archives[name];
                 }
+                // 该场景下的**记忆条目**也要跟着换前缀（2026-09-30 审查 P1-1）。不迁的话：改名后
+                // 旧键 `<旧场景>/<名>` 在磁盘上找不到对应文件，`buildSnapshot` 的清理会把它删掉
+                // （见 `memories/snapshot.ts` 的"索引有记录但文件已删"分支）→ 那条记忆失去索引条目
+                // → `projectRule` 的 `enabled ?? true` 把它**重新启用** —— 用户显式停用的记忆复活，
+                // 且 order / tags / pinned / note 一并丢失。记忆自己的改名路径（`ops/memory.ts`）
+                // 一直是迁索引的，场景这条漏了同一件事。
+                // 只换前缀、原值不动；`nextRaw` 的场景名已被上面的占用检查保证为空，不会覆盖。
+                const sceneRules = index.rules || {};
+                for (const id of Object.keys(sceneRules).filter((k) => k.startsWith(name + '/'))) {
+                    sceneRules[nextRaw + id.slice(name.length)] = sceneRules[id];
+                    delete sceneRules[id];
+                }
                 const act = normalizeActive(index.active);
                 if (act !== null && act.indexOf(name) >= 0)
                     index.active = act.map((n) => (n === name ? nextRaw : n));
@@ -308,11 +372,15 @@ export function buildSceneRecordOps(rc) {
     /**
      * 删除场景：**仅空目录可删**（避免一次操作带走整组记忆）。
      * 同时删掉场景记录、把它从 `active` 集合里摘掉、清掉它的档案，避免悬空引用。
-     * 保留场景 `global` 不可删除；场景名口径与创建一致（单个路径段）。
+     * 保留场景 `global` 不可删除。
+     *
+     * 场景名在这里按**完整路径**寻址（`isValidGroupPath`，2026-09-30 审查 P2-4）：命名路径
+     * （创建 / 改名目标 / 启用集合）一律要求单段，而历史与导入留下的多段记录得能**被清掉** ——
+     * 否则它就成了"看得见、动不了"的死条目。删除只是定位 + 移入回收站，多段名不会造成歧义。
      */
     async function rulesRemoveScene(args) {
         const name = String((args && args.name) || '').trim();
-        if (!isValidGroupSegment(name))
+        if (!isValidGroupPath(name))
             return fail('error.rules.invalidGroup', `场景名非法：${name || '(空)'}`);
         if (name === SHARED_GROUP)
             return fail('error.rules.invalidGroup', `_shared 是保留场景名，不可删除`);
@@ -333,6 +401,15 @@ export function buildSceneRecordOps(rc) {
         // 但一律**先移入回收站**（与场景记录、档案装在同一条条目里），所以「删错了」还能整条恢复：
         // 记忆文件按原来的相对路径放回，场景记录与档案也一起回来。
         const sceneDir = join(memoriesRoot, name);
+        // 删除前先确认落点仍在根内（realpath 口径）—— 与 `rulesRemove` / `rulesRestore` 同一道闸。
+        // 为什么删除侧最需要它（2026-09-30 审查 P1-2，已实测复现）：`memories/<场景>` 若是指向根外的
+        // 目录链接（用户手工建、或旧布局迁移带进来的），下面 `collect` 的 `readdir` 会**列出链接目标
+        // 的内容**，于是 `from` 拼成 `<memoriesRoot>/<场景>/x.md` 看着在根内、`rename` 实际作用于
+        // **根外的真实文件** —— 删除场景会把 `D:\重要数据` 里的文件搬进回收站。`isValidGroupSegment`
+        // 挡不住（名字本身合法），`lstat` 也挡不住（只看末级）。
+        const deniedDir = await refuseOutsideRoot(sceneDir);
+        if (deniedDir)
+            return deniedDir;
         const moves = [];
         const collect = async (abs, rel) => {
             let items = [];
@@ -343,6 +420,12 @@ export function buildSceneRecordOps(rc) {
                 return; // 目录不存在（只有记录的场景）或读不了 → 当作没有文件
             }
             for (const item of items) {
+                // 跳过符号链接（含 Windows junction），与 `snapshot.ts` 的 `discover` 同口径。
+                // 上面那道 realpath 断言挡的是「场景目录本身是链接」；这一条挡的是「场景目录内的某一项是
+                // 链接」—— 两者是不同的路径，缺一条就漏一条。链接本身也不搬走（它是环境相关的，
+                // 不该被回收站带到另一台机器上），留给后面的 `rm` 清掉。
+                if (item.isSymbolicLink())
+                    continue;
                 const childAbs = join(abs, item.name);
                 const childRel = rel === '' ? item.name : `${rel}/${item.name}`;
                 if (item.isDirectory())
@@ -352,10 +435,19 @@ export function buildSceneRecordOps(rc) {
             }
         };
         await collect(sceneDir, '');
+        // 该场景下每条记忆的索引条目（enabled / order / tags / pinned / note）一并收进回收站条目
+        // 的 `data`（2026-09-30 审查 P1-1）。不带的话：恢复出来的记忆全部按 `enabled ?? true`
+        // 重置 —— 用户停用的会复活，其余元数据归零。文件在回收站、元数据也得跟着在。
+        const sceneRuleSubset = {};
+        for (const id of Object.keys(index.rules || {})) {
+            if (id.startsWith(name + '/'))
+                sceneRuleSubset[id] = index.rules[id];
+        }
         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),
+            rules: sceneRuleSubset,
         });
         if (trashed.ok === false) {
             return fail('error.rules.ioFailed', `移入回收站失败：${trashed.error}`);
@@ -366,11 +458,21 @@ export function buildSceneRecordOps(rc) {
         }
         catch (e) {
             // 目录没清掉就把记忆放回去：宁可整个操作失败，也不要「文件在回收站、场景还留在列表里」。
+            let rollbackFailed = 0;
             for (const move of moves) {
                 try {
                     await moveOutOfTrash('scenes', trashed.id, move.dest, move.from);
                 }
-                catch { /* 尽力而为 */ }
+                catch {
+                    rollbackFailed += 1;
+                }
+            }
+            // **回滚没做完就绝不 purge**：purge 会把条目整目录删掉，而没能放回的那些文件还在里面
+            // —— 那是一次静默的**永久删除**（用户记忆），且场景目录还留在原地（一个被掏空的场景）。
+            // 宁可留一条脏条目（界面看得见、能再点一次恢复），也不要"删干净"（审查 P0-2）。
+            if (rollbackFailed > 0) {
+                return fail('error.rules.ioFailed', `删除场景目录失败：${message(e)}；另有 ${rollbackFailed} 个记忆文件没能放回原位，`
+                    + `它们仍在回收站条目 ${trashed.id} 里（未删除），可从回收站恢复`);
             }
             try {
                 await purgeTrashEntry('scenes', trashed.id);
@@ -392,6 +494,17 @@ export function buildSceneRecordOps(rc) {
             delete index.archives[name];
             dirty = true;
         }
+        // 记忆条目也跟着进了回收站（见上面的 `sceneRuleSubset`）→ 索引里同步删掉。不删的话会留下
+        // "索引有记录、磁盘没文件"的悬空键：`buildSnapshot` 下一轮也会清掉，但中间那一轮界面会
+        // 把它显示成"这条记忆不存在"，且恢复时 `data.rules` 合并回来会与残留键打架。显式删干净。
+        if (index.rules) {
+            for (const id of Object.keys(index.rules)) {
+                if (id.startsWith(name + '/')) {
+                    delete index.rules[id];
+                    dirty = true;
+                }
+            }
+        }
         if (dirty)
             await writeIndex(stateDir, index);
         invalidateSnapshot();
@@ -404,6 +517,9 @@ export function buildSceneRecordOps(rc) {
     /**
      * 从回收站恢复一个场景：重建记忆目录 + 写回记录与档案。
      * 同名场景已存在时**拒绝**（绝不覆盖既有场景）。
+     *
+     * 场景名按**完整路径**寻址（2026-09-30 审查 P2-4，与删除侧同口径）：回收站里的名字来自
+     * 当初删掉的那条记录，多段名同样得能恢复回来 —— 否则删得掉、恢复不了，数据就卡在回收站里。
      */
     async function sceneTrashRestore(args) {
         const id = String((args && args.id) || '').trim();
@@ -411,12 +527,18 @@ export function buildSceneRecordOps(rc) {
         if (!entry)
             return fail('error.rules.notFound', `回收站条目不存在：${id}`);
         const name = String(entry.name || '').trim();
-        if (!isValidGroupSegment(name))
+        if (!isValidGroupPath(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(memoriesRoot, name);
+        // 恢复是**写入**方向：落点若是指向根外的目录链接，`mkdir` 会顺着链接成功、随后
+        // `moveOutOfTrash` 把记忆文件写到**根外**去。与删除侧同一个根因（缺 realpath 根内断言），
+        // 2026-09-30 审查 P1-2 的相邻面 —— 修一处必须一起修，否则只是把同一个洞挪了个方向。
+        const deniedDir = await refuseOutsideRoot(dir);
+        if (deniedDir)
+            return deniedDir;
         let entries = [];
         try {
             entries = await readdir(dir);
@@ -443,13 +565,38 @@ export function buildSceneRecordOps(rc) {
                 restored.push(String(rel));
             }
             catch (e) {
-                return fail('error.rules.ioFailed', `恢复记忆文件失败（已放回 ${restored.length}/${files.length}）：${message(e)}`);
+                // 已放回的文件**搬回回收站**再报错：原来这里是直接 return，已放回的那几个留在记忆目录里
+                // —— 下一次点恢复会撞上面那条「目录里已有内容」的检查，于是这个场景**永远恢复不了**
+                // （审查 P0-2）。回滚失败也如实说清楚，别让用户以为还能原样重试。
+                let backFailed = 0;
+                for (const doneRel of [...restored].reverse()) {
+                    try {
+                        await moveIntoTrash('scenes', id, join(dir, doneRel), doneRel);
+                    }
+                    catch {
+                        backFailed += 1;
+                    }
+                }
+                const tail = backFailed === 0
+                    ? '（已放回的记忆文件已退回回收站，可重试）'
+                    : `（另有 ${backFailed} 个文件没能退回回收站，它们现在在记忆目录「${name}」里，请先手工处理再重试）`;
+                return fail('error.rules.ioFailed', `恢复记忆文件失败：${message(e)}${tail}`);
             }
         }
         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 };
+        // 记忆条目随文件一起回来（删除时存进 `data.rules`，见 `rulesRemoveScene`）——
+        // 否则恢复出来的记忆全部按 `enabled ?? true` 重置，用户停用的会复活（审查 P1-1）。
+        // **只补不覆盖**：同名键若已存在以现有为准（上面已拒绝同名场景，正常情况下不会撞）。
+        if (data.rules && typeof data.rules === 'object' && !Array.isArray(data.rules)) {
+            const rules = index.rules || (index.rules = {});
+            for (const [ruleId, ruleEntry] of Object.entries(data.rules)) {
+                if (rules[ruleId] === undefined)
+                    rules[ruleId] = ruleEntry;
+            }
+        }
         await writeIndex(stateDir, index);
         await purgeTrashEntry('scenes', id);
         invalidateSnapshot();

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

@@ -220,9 +220,47 @@ export function buildSessionOps(deps) {
             const sessionId = String((args && args.sessionId) || '').trim();
             if (!sessionId)
                 return { ok: false, error: '缺少 sessionId' };
+            // 范围收敛（2026-09-30 审查 P1-7）：单删也只允许删**已归档**的会话 —— 与批量路径
+            // （`deleteArchivedSessions` → `archivedSessionIdsForTarget` 的四种 scope 全部与
+            // `archivedSessionIds` 求交）同一口径，也与界面对齐（`history-list` 只回已归档会话，
+            // 删除按钮只出现在那份列表里）。原先这里直接 `registry.deleteSession(sessionId)`，而
+            // `deleteLocalSession` 只问「这个 id 在持久化里存在吗」—— 于是一个客户端 bug 或一次
+            // 手工请求就能**永久删除任意已持久化会话**，包括未归档的和当前正开着的。
+            // 判据必须是**权威归档集合**，不是摘要投影（2026-09-30 审查 F9）。
+            // `archivedSessionMetadata()` 是**有损**的：逐条 try，读不到 header 或 `createdAt`
+            // 非有限就 `continue` 且不抛（`workspace.ts` 的 `archivedSessionMetadata`）。拿它的
+            // `items` 拼门禁集合，就会把「确实已归档、只是头部暂时读不到」的会话判成未归档 →
+            // 回一句「只能删除已归档的会话：请先归档，再删除」——**诊断是错的**（真因是读失败）。
+            // 而批量路径（`deleteArchivedSessions` → `archivedSessionIdsForTarget`）用的是
+            // `requireState().archivedSessionIds`，同一份数据两条路给出相反结论。
+            // 这里改成与批量路径同源；`requireState` 缺失（旧宿主）才退回投影 —— 投影只会**更小**，
+            // 方向仍是 fail-closed（宁可这次删不掉，也不要凭未知状态做不可逆操作）。
+            let archived;
             try {
-                await registry.deleteSession(sessionId);
-                return { ok: true, sessionId, deleted: true };
+                const authoritative = typeof registry.requireState === 'function' ? registry.requireState() : undefined;
+                if (authoritative && Array.isArray(authoritative.archivedSessionIds)) {
+                    archived = new Set(authoritative.archivedSessionIds.map((id) => String(id)));
+                }
+                else {
+                    const meta = await registry.archivedSessionMetadata();
+                    const items = meta && Array.isArray(meta.items) ? meta.items : [];
+                    archived = new Set(items.map((i) => String(i && i.sessionId)));
+                }
+            }
+            catch (e) {
+                // 查不到归档状态 → **拒绝删除**（fail-closed）：宁可这次删不掉，也不要凭一个未知状态
+                // 去执行不可逆操作。
+                return { ok: false, error: '无法确认会话的归档状态，已拒绝删除：' + deps.message(e) };
+            }
+            if (!archived.has(sessionId)) {
+                return { ok: false, error: '只能删除已归档的会话：请先归档，再删除' };
+            }
+            try {
+                const r = await registry.deleteSession(sessionId);
+                // 级联只吃已归档的子会话（见 `deleteDescendants`）：未归档的会被**保留**，
+                // 这里如实带出去，界面/模型才不会以为「这一支已经全没了」。
+                const kept = (r && Array.isArray(r.keptUnarchivedDescendants)) ? r.keptUnarchivedDescendants : [];
+                return { ok: true, sessionId, deleted: true, ...(kept.length ? { keptUnarchivedDescendants: kept } : {}) };
             }
             catch (e) {
                 return { ok: false, error: deps.message(e) };
@@ -294,8 +332,9 @@ export function buildSessionOps(deps) {
             if (!fileName || !content.trim())
                 return { ok: false, error: '缺少文件内容' };
             let turns;
+            let format;
             try {
-                const format = detectFormat(fileName, content);
+                format = detectFormat(fileName, content);
                 turns = format === 'jsonl' ? parseJsonlTranscript(content)
                     : format === 'markdown' ? parseMarkdownTranscript(content)
                         : parseGenericText(content);
@@ -305,6 +344,13 @@ export function buildSessionOps(deps) {
             }
             if (!turns.length)
                 return { ok: false, error: '未能从该文件中识别出对话内容' };
+            // 「折成一条 user 消息」这件事本身要出声（2026-09-30 审查 F12）。
+            // 嗅探（`detectFormat`）已经能救回「JSONL / Markdown 被改名成 .txt」那一种，但**真的**
+            // 没有说话人标记的文本仍会走 generic：多行内容全塞进 1 条 user turn、结构全失，
+            // 而 op 此前回的是 `{ok:true,count:1}` —— 零警告。这里把它标出来（`lossy` 给界面出
+            // 本地化文案，`warning` 给模型看原因原文）。
+            const lossy = format === 'generic' && turns.length === 1
+                && content.split(/\r?\n/).filter((line) => line.trim()).length >= 5;
             if (typeof deps.createSession !== 'function')
                 return { ok: false, error: '当前环境不支持创建会话（agents.create 不可用）' };
             // 仅接受绝对路径的 cwd；非法或缺失时会话不带目录（归入未分组）。
@@ -334,7 +380,7 @@ export function buildSessionOps(deps) {
                 if (live === undefined || live === null) {
                     return { ok: false, error: `创建会话失败：宿主未登记该会话（${id}），未导入任何内容` };
                 }
-                return { ok: true, sessionId: id, count: turns.length };
+                return { ok: true, sessionId: id, count: turns.length, ...(lossy ? { format, lossy: true, warning: '整份文本没有识别出任何说话人标记（如 User: / Assistant:），已折成一条用户消息：原对话的分轮结构可能已丢失。若源文件是 JSONL 或 Markdown 转录稿，请按原扩展名（.jsonl / .md）重新导入。' } : {}) };
             }
             catch (e) {
                 return { ok: false, error: '创建会话失败: ' + deps.message(e) };
@@ -346,15 +392,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() 拼出名字），
@@ -362,7 +408,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)
@@ -395,16 +441,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 });