dsh-plugin-tool-management 0.19.1 → 0.20.1

package/lib/memories/service.js

@@ -65,7 +65,7 @@ import { deriveFromDoc, projectRule, relocateLegacyLayout, buildSnapshot, probeS
  * 场景/记忆根目录名（$DSH_HOME 下），集中在 `tool-management/` 一个目录内：
  *   - `memories/<场景>/…`    记忆正文真源
  *   - `..`（即 tool-management 根）侧车：memories-index.json（内含 `scenes` 切片 = 场景记录
- *     的**真源**）/ skills-state.json / trash/ / memories-trash/
+ *     的**真源**）/ skills-state.json / trash/（六类回收站，含 `trash/memories-trash/`）
  *
  * `scenes/`（`SCENES_DIR`）是 v0.3 遗留的**空壳**：只创建、只回显路径，没有任何读写。
  * 别把场景记录的位置写成它。
@@ -728,6 +728,7 @@ export function createMemoriesService(ctx, deps) {
     // 抽出去的 ops/*.ts 只通过它访问闭包，任何漏挂都会在 tsc 阶段报「Cannot find name」。
     const rc = {
         stateDir, memoriesRoot, scenesRoot, maxBytes,
+        ...(deps.skillsTrashDir ? { skillsTrashDir: deps.skillsTrashDir } : {}),
         snapshot, invalidateSnapshot, sceneMemory, scenePrompt,
         parseId, locateRule, refuseOutsideRoot, buildProjected, sceneRows,
         copyIntoMemoriesTrash, listAttachments, serializeRuleFile, serializeUpdatedFile,
@@ -759,6 +760,10 @@ export function createMemoriesService(ctx, deps) {
         'rules-remove': (args) => runWrite(() => trashOps.rulesRemove(args || {})),
         'rules-restore': (args) => runWrite(() => trashOps.rulesRestore(args || {})),
         'rules-trash-list': () => trashOps.rulesTrashList(),
+        // 回收站「详情」：跨域只读预览（记忆 / 技能 / 提示词 / 人设 / 场景五类的条目都能查）。
+        // 只 lstat + 递归读文件，不写任何东西 ⇒ 不进写队列、也不 refresh 快照。
+        // 登记在 op-registry 的 `readonly` 一档：**锁定期间照样能看**（锁的是写，不是看）。
+        'trash-preview': (args) => trashOps.trashPreview(args || {}),
         'rules-trash-remove': (args) => runWrite(() => trashOps.rulesTrashRemove(args || {})),
         'rules-attach': (args) => runWrite(() => memoryOps.rulesAttach(args || {})),
         'rules-detach': (args) => runWrite(() => memoryOps.rulesDetach(args || {})),

package/lib/op-registry.js

@@ -57,12 +57,8 @@ export const OP_REGISTRY = Object.freeze({
     // 会停在启用态 —— 是写不是读。（0.6.0 / 0.7.0 各有漏列前科，见文件头。）
     'mcpm-tools-refresh': { write: true },
     'mcpm-tools': { readonly: true },
-    // 配置体检：只读补丁文件 + 一次 PATH 查询（`where`/`which`，不执行配置里的命令）。
-    // 回的是检查项 id + 少量**打码后**的字段值（URL 查询串走 `maskUrlQuery`，与 `mcpm-list`
-    // 同口径；`command` 明文，理由同 `mcpm-list`：命令名不是凭据，`args` 两边都不回）。
-    // 与 `mcpm-list` 同档，不带令牌 —— 0.16.6 之前这里回的是 URL 原文，等于让免令牌的请求
-    // 拿到 `?api_key=…`，绕过了 `mcpm-reveal` 那道防线（审查 P0-5，0.17.0 修）。
-    'mcpm-inspect': { readonly: true },
+    // 把粘贴的补丁片段读成条目：纯文本运算，不读盘也不写盘（客户端在浏览器里解析不了 YAML）。
+    'mcpm-parse-patch': { readonly: true },
     // ── 技能域（22，含内联的 skill-open）───────────────────────────────────────
     'skill-state': { annotatesLock: true },
     'skill-detail': { readonly: true },
@@ -78,8 +74,10 @@ export const OP_REGISTRY = Object.freeze({
     'skill-prefer': { serviceWrite: true, frozen: true },
     'skill-unprefer': { serviceWrite: true, frozen: true },
     'skill-create': { serviceWrite: true, frozen: true },
-    // 改写 hub 里已存在的那一份技能（`skill_manager_save` 的改分支）。与 create 同规格：
-    // 都是往 hub 落文件。它**不动**官方根里的技能 —— 那层边界在 service 的胜出者判定里。
+    // 改写本插件自己写过的那一份技能（`skill_manager_save` 的改分支）。与 create 同规格：
+    // 落点只限本插件可写的两个根 —— hub（导入落点）+ dsh（新建默认落点，2026-10-15 裁定，
+    // 见 service.ts 的 PLUGIN_WRITABLE_ROOTS）。它**不动**官方根里的技能 —— 那层边界在
+    // service 的胜出者判定里。
     'skill-update': { serviceWrite: true, frozen: true },
     'skill-import': { serviceWrite: true, frozen: true },
     'skill-upload': { serviceWrite: true, frozen: true },
@@ -88,6 +86,9 @@ export const OP_REGISTRY = Object.freeze({
     'skill-trash-delete': { serviceWrite: true, frozen: true },
     'skill-custom-add': { serviceWrite: true, frozen: true },
     'skill-custom-remove': { serviceWrite: true, frozen: true },
+    // 永久删除一条**按约定发现**的来源记录（agents / codex / claude）：只写本地状态里的
+    // `forgottenSources`，磁盘源文件一个字节都不动。与 `skill-custom-remove` 同权。
+    'skill-source-forget': { serviceWrite: true, frozen: true },
     // 打开系统编辑器改文件：不改宿主状态，但它是"界面按钮"性质的写入口，按写门禁。
     'skill-open': { write: true },
     // ── 记忆与场景域（27：memories 24 + archive-engine 3）──────────────────────
@@ -96,6 +97,9 @@ export const OP_REGISTRY = Object.freeze({
     'rules-budget': { readonly: true },
     'rules-diagnose': { readonly: true },
     'rules-trash-list': { readonly: true },
+    // 回收站「详情」：跨域只读（五类回收站共用一条，域由 args.domain 区分）。只读 → 不冻，
+    // 锁定的场景里照样能看一眼"删掉的是什么"（看不是改，与「编辑页可打开」同一条口径）。
+    'trash-preview': { readonly: true },
     'rules-create': { serviceWrite: true, frozen: true },
     'rules-update': { serviceWrite: true, frozen: true },
     'rules-remove': { serviceWrite: true, frozen: true },
@@ -171,16 +175,14 @@ export const OP_REGISTRY = Object.freeze({
     'quickprompt-remove': { write: true, frozen: true },
     'quickprompt-trash-restore': { write: true, frozen: true },
     'quickprompt-trash-delete': { write: true, frozen: true },
-    // ── 历史会话域（16）────────────────────────────────────────────────────────
+    // ── 历史会话域（14）────────────────────────────────────────────────────────
     'history-list': { readonly: true },
     'history-sessions': { readonly: true },
     'history-export-defaults': { readonly: true },
     'history-retention-get': { readonly: true },
     'dir-list': { readonly: true },
-    'history-archive': { write: true },
     'history-unarchive': { write: true },
     'history-delete': { write: true },
-    'history-archive-batch': { write: true },
     'history-unarchive-batch': { write: true },
     'history-delete-batch': { write: true },
     'history-retention-set': { write: true },

package/lib/ops/memory.js

@@ -5,7 +5,7 @@
 //
 // ops 表里的包装（enqueueMutation / runWrite）**留在 service.ts**：本文件只导出裸 op，
 // 包装归属集中在一处，改门禁时一眼看全。
-import { lstat, mkdir, readFile, rm } from 'node:fs/promises';
+import { lstat, mkdir, readFile, rename, rm } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { parseSkillDoc, unquote } from '../skills/core.js';
 import { expandUploads, planMemoryImport } from '../imports/upload.js';
@@ -535,15 +535,46 @@ export function buildMemoryOps(rc) {
             await copyIntoMemoriesTrash(located, parts.group, parts.name);
             await rm(join(memoriesRoot, parts.group, parts.name + '.md'), { force: true });
         }
+        else if (located.kind === 'bundle' && newName !== parts.name) {
+            // bundle 改名 = **目录连同附件一起改**（2026-10-14 对抗性审查 P0-4）。
+            //
+            // 此前这条落到下面的 else：只把 frontmatter/正文写回**旧**路径，而索引照新名迁移 ——
+            // 实测（临时目录内复现）结果是索引里多一条指向不存在路径的记录（`rules-read` 报
+            // notFound），真实条目反而丢了索引记录，于是它承载的 `enabled` / `order` / `tags`
+            // 一起丢失：**一条停用的 bundle 记忆改个名就被静默重新启用**（重新进入每轮注入）。
+            // 面板的编辑框走同一个 op（`client/47-memory.js` 的 `submitUpdate`），所以两边同一条路。
+            //
+            // 形状与 flat 改名对齐：旧形态先整份进回收站（可恢复），再搬目录，最后把正文改名。
+            const oldDir = located.entryPath;
+            const newDir = join(memoriesRoot, parts.group, newName);
+            // 只改大小写时新旧是同一个目录（Windows / macOS 不区分大小写），不能按"已存在"拒。
+            const caseOnly = newName.toLowerCase() === parts.name.toLowerCase();
+            if (!caseOnly && await pathExists(newDir)) {
+                return fail('error.rules.exists', `同名记忆已存在（bundle）：${parts.group}/${newName}`);
+            }
+            // 正文文件名：新建的 bundle 一律 `<名>.md`；旧数据可能是 `SKILL.md`，那份**保持原名不动**
+            // （发现侧两个候选都认，改名时顺手动它只会把兼容数据弄坏）。
+            const keepLegacyDoc = basename(located.docPath) === LEGACY_BUNDLE_DOC;
+            await copyIntoMemoriesTrash(located, parts.group, parts.name);
+            await rename(oldDir, newDir);
+            const movedDoc = join(newDir, basename(located.docPath));
+            const targetDoc = join(newDir, keepLegacyDoc ? LEGACY_BUNDLE_DOC : bundleDocName(newName));
+            if (movedDoc !== targetDoc)
+                await rename(movedDoc, targetDoc);
+            await writeFileAtomically(targetDoc, serialize());
+        }
         else {
-            // bundle 不 rename 目录：只更新 frontmatter/正文
+            // bundle 不改名：只更新 frontmatter/正文
             await writeFileAtomically(located.docPath, serialize());
         }
         // 索引：改名则迁移记录（保留 order/tags/enabled 等），否则原地更新。
+        // 判据只看"名字变没变"，不再附加 `index.rules[id]` 存在 —— 磁盘上由外部新增、索引里
+        // 还没有记录的条目（发现侧会认它）改名时，旧判据会走到 else 把记录写回**旧名**，
+        // 于是新名下没有记录、旧名下多一条悬空的（2026-10-14 对抗性审查 P0-4 同族）。
         const index = await readIndex(stateDir);
         const newId = `${parts.group}/${newName}`;
-        if (newId !== id && index.rules[id]) {
-            index.rules[newId] = { ...index.rules[id], updatedAt: new Date().toISOString() };
+        if (newId !== id) {
+            index.rules[newId] = { ...(index.rules[id] || {}), updatedAt: new Date().toISOString() };
             delete index.rules[id];
         }
         else {
@@ -565,6 +596,13 @@ export function buildMemoryOps(rc) {
         if (typeof (args && args.enabled) !== 'boolean') {
             return fail('error.rules.invalidArgs', '缺少参数：enabled 必须是布尔值（toggle 只按传入值写入，不做"翻转"推断）');
         }
+        // 不存在的 id 必须拒绝（2026-10-15 smoke-test P1-4）：`parseId` 只校验 `<场景>/<名字>`
+        // 的形状，原先据此直接 `index.rules[id] = {...}` —— 于是一次拼错的 id 会**写进一条幽灵
+        // 索引**（磁盘上没有正文、清单里也列不出来，索引里却多一条 enabled），调用方还收到 ok。
+        // 判据与 `rulesRead` / `rulesUpdate` 同源：`locateRule` 在磁盘上找得到才算存在。
+        const located = await locateRule(parts.group, parts.name);
+        if (!located)
+            return fail('error.rules.notFound', `规则不存在：${id}`);
         const index = await readIndex(stateDir);
         const idxEntry = index.rules[id] || {};
         const enabled = args.enabled === true;

package/lib/ops/scene-records.js

@@ -514,9 +514,24 @@ export function buildSceneRecordOps(rc) {
     async function sceneTrashList() {
         return { ok: true, trash: await listTrashEntries('scenes') };
     }
+    /**
+     * 同名的场景里第一个空出来的退号名：`甲` → `甲（1）` → `甲（2）`…（全角括号，与界面
+     * `uniqueName` 同一写法）。超过段名长度上限的候选直接跳过 —— 退号名本身也得是合法段名。
+     */
+    function nextFreeSceneName(index, name) {
+        for (let i = 1; i <= 999; i += 1) {
+            const candidate = `${name}（${i}）`;
+            if (!isValidGroupPath(candidate))
+                return null;
+            if (!index.scenes?.[candidate])
+                return candidate;
+        }
+        return null;
+    }
     /**
      * 从回收站恢复一个场景：重建记忆目录 + 写回记录与档案。
-     * 同名场景已存在时**拒绝**（绝不覆盖既有场景）。
+     * 同名场景已存在时默认**拒绝**（绝不覆盖既有场景）；带 `dedupe: true` 时退号恢复
+     * （`甲` → `甲（1）`，用户 2026-10-14 裁定四个域都要能退号）。
      *
      * 场景名按**完整路径**寻址（2026-09-30 审查 P2-4，与删除侧同口径）：回收站里的名字来自
      * 当初删掉的那条记录，多段名同样得能恢复回来 —— 否则删得掉、恢复不了，数据就卡在回收站里。
@@ -526,12 +541,26 @@ export function buildSceneRecordOps(rc) {
         const entry = await readTrashEntry('scenes', id);
         if (!entry)
             return fail('error.rules.notFound', `回收站条目不存在：${id}`);
-        const name = String(entry.name || '').trim();
-        if (!isValidGroupPath(name))
-            return fail('error.rules.invalidGroup', `回收站里的场景名非法：${name || '(空)'}`);
+        const oldName = String(entry.name || '').trim();
+        if (!isValidGroupPath(oldName))
+            return fail('error.rules.invalidGroup', `回收站里的场景名非法：${oldName || '(空)'}`);
         const index = await readIndex(stateDir);
-        if (index.scenes?.[name])
-            return fail('error.rules.invalidGroup', `无法恢复，同名场景已存在：${name}`);
+        let name = oldName;
+        if (index.scenes?.[name]) {
+            // 「同名先问一句」（用户 2026-10-14）：拒绝时把候选名字一起回（`params.next`），
+            // 界面弹窗才能如实写出"确认后会叫 `甲（1）`"；用户确认后带 `dedupe: true` 重来。
+            const next = nextFreeSceneName(index, name);
+            if (args?.dedupe !== true || !next) {
+                // 专用错误码（四个回收站统一）：界面按它认出"这是撞名"并弹确认窗。原先这里复用
+                // `error.rules.invalidGroup`，那一条同时还表示"名字非法"，界面分不出来。
+                return fail('error.dup.conflict', `已存在同名场景：${name}`, {
+                    name,
+                    ...(next ? { next } : {}),
+                });
+            }
+            name = next;
+        }
+        const renamed = name !== oldName;
         const dir = join(memoriesRoot, name);
         // 恢复是**写入**方向：落点若是指向根外的目录链接，`mkdir` 会顺着链接成功、随后
         // `moveOutOfTrash` 把记忆文件写到**根外**去。与删除侧同一个根因（缺 realpath 根内断言），
@@ -590,17 +619,22 @@ export function buildSceneRecordOps(rc) {
         // 记忆条目随文件一起回来（删除时存进 `data.rules`，见 `rulesRemoveScene`）——
         // 否则恢复出来的记忆全部按 `enabled ?? true` 重置，用户停用的会复活（审查 P1-1）。
         // **只补不覆盖**：同名键若已存在以现有为准（上面已拒绝同名场景，正常情况下不会撞）。
+        //
+        // 退号恢复时这批记忆的 key 也要**跟着改名**：索引里的 key 是 `<场景>/<名>`，照抄旧 key
+        // 会让它们挂在旧场景名上 —— 文件躺在 `甲（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;
+                const mapped = renamed && ruleId.startsWith(oldName + '/') ? name + ruleId.slice(oldName.length) : ruleId;
+                if (rules[mapped] === undefined)
+                    rules[mapped] = ruleEntry;
             }
         }
         await writeIndex(stateDir, index);
         await purgeTrashEntry('scenes', id);
         invalidateSnapshot();
-        return { ok: true, name, restoredFiles: restored.length };
+        return { ok: true, name, renamed, restoredFiles: restored.length };
     }
     /** 永久删除一条场景回收站条目。 */
     async function sceneTrashDelete(args) {

package/lib/ops/sessions.js

@@ -4,10 +4,13 @@
 // 整张表上（见 index.ts）。
 //
 // 本域的 op 名：history-list / history-sessions / history-export-defaults / dir-list /
-// history-archive / history-archive-batch / history-unarchive / history-delete /
+// history-unarchive / history-delete /
 // history-unarchive-batch / history-delete-batch / history-workspace-register /
 // history-import / bundle-export / history-export / history-retention-get /
 // history-retention-set。
+//
+// 归档（archive）不在这里：那是宿主的原生入口（官方侧栏），本插件只经 `domain/changed`
+// 事件同步归档时刻（见 src/sessions/bridge.ts），不替用户发起归档。
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
@@ -18,10 +21,35 @@ import { isValidPresetId } from '../prompts/preset-id.js';
 import { defaultPersonasDir, validPersonaName } from '../subagents/service.js';
 import { isInsideRoot } from '../paths.js';
 import { planMemoryExport } from '../memories/service.js';
+/**
+ * Linux 的桌面目录：按 XDG 用户目录规范从 `user-dirs.dirs` 里读 `XDG_DESKTOP_DIR`。
+ *
+ * 为什么需要它：中文 / 日文等本地化环境里，桌面目录的**真名**不是 `Desktop`，而是
+ * `桌面` / `デスクトップ` —— 这时 `join(homedir(), 'Desktop')` 探不到，我们会白白退回主目录。
+ * 配置文件里的值形如 `"$HOME/桌面"`（含 `$HOME` 变量与引号），这里做最小解析：
+ * 去引号、把 `$HOME` / 前导 `~` 换成真实主目录。
+ *
+ * 读不到 / 没有这一行 / 值不是绝对路径 → 返回 undefined，调用方继续试下一个候选。
+ * 纯只读，任何异常都吞掉（这只是"默认值填哪儿"的增强，不该影响导出本身）。
+ */
+async function xdgDesktopDir() {
+    try {
+        const base = String(process.env.XDG_CONFIG_HOME || '').trim() || join(homedir(), '.config');
+        const text = await readFile(join(base, 'user-dirs.dirs'), 'utf8');
+        const m = /^\s*XDG_DESKTOP_DIR\s*=\s*"([^"]*)"/m.exec(text);
+        if (!m)
+            return undefined;
+        const raw = m[1].replace(/^\$HOME(?=[\\/]|$)/, homedir()).replace(/^~(?=[\\/]|$)/, homedir());
+        return raw && (raw.startsWith('/') || /^[A-Za-z]:[\\/]/.test(raw)) ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function buildSessionOps(deps) {
     return {
         // History（归档会话管理）ops。只读：history-list / history-retention-get；
-        // 写：history-archive / history-unarchive / history-delete / history-retention-set。
+        // 写：history-unarchive / history-delete / history-retention-set。
         // workspaceRegistry 缺失（补丁未生效）时返回明确错误，不崩页面。
         'history-list': async () => {
             const registry = deps.getSessionsRegistry();
@@ -114,16 +142,35 @@ export function buildSessionOps(deps) {
                 return { ok: false, error: deps.message(e) };
             }
         },
-        // 导出默认目录：桌面（存在时）否则用户主目录。只读，不门控。
+        // 导入 / 导出的默认目录：桌面（存在时）否则用户主目录。只读，不门控。
+        //
+        // 名字里带 `history` 是历史原因，但它早就是**全插件共用的**默认 IO 目录：整机迁移导出
+        // / 快照位置 / 会话导出 / MCP JSON 导出 / 技能自定义来源目录都取这一份。之所以必须问宿主、
+        // 不能让客户端写死：桌面在哪取决于**跑宿主的那台机器 + 那个用户**——
+        //   Windows  C:\Users\<用户名>\Desktop
+        //   macOS    /Users/<用户名>/Desktop
+        //   Linux    /home/<用户名>/Desktop，且桌面目录**未必存在**（也可能是本地化名字，
+        //            例如中文环境下的 ~/桌面 —— 那种走 XDG 配置，见下）
+        // 全部用 `os.homedir()` 起算，换用户 / 换系统自动跟着走。
         'history-export-defaults': async () => {
             let dir = homedir();
-            try {
-                const desktop = join(homedir(), 'Desktop');
-                const st = await stat(desktop);
-                if (st.isDirectory())
-                    dir = desktop;
+            // Linux 的桌面目录名可能被本地化：先按 XDG 用户目录规范问一次，再退回惯用的 Desktop。
+            // 两条都探不到就用主目录 —— 主目录一定存在，且导出的只是子目录，不影响可用性。
+            const candidates = [join(homedir(), 'Desktop')];
+            if (process.platform === 'linux') {
+                candidates.unshift(await xdgDesktopDir());
+            }
+            for (const candidate of candidates) {
+                if (!candidate)
+                    continue;
+                try {
+                    if ((await stat(candidate)).isDirectory()) {
+                        dir = candidate;
+                        break;
+                    }
+                }
+                catch { /* 这个候选不可用 → 试下一个 */ }
             }
-            catch { /* 桌面路径不可用 → 回退主目录 */ }
             return { ok: true, defaultDir: dir };
         },
         // 列出目录的子目录，供客户端「选择文件夹」弹窗逐级浏览。dir 为空时返回根
@@ -160,43 +207,6 @@ export function buildSessionOps(deps) {
                 return { ok: false, error: deps.message(e) };
             }
         },
-        'history-archive': async (args) => {
-            const registry = deps.getSessionsRegistry();
-            if (!registry)
-                return { ok: false, error: '归档服务未挂载' };
-            const sessionId = String((args && args.sessionId) || '').trim();
-            if (!sessionId)
-                return { ok: false, error: '缺少 sessionId' };
-            try {
-                await registry.archiveSession(sessionId);
-                return { ok: true, sessionId };
-            }
-            catch (e) {
-                return { ok: false, error: deps.message(e) };
-            }
-        },
-        // 批量归档（导出弹窗「归档所选」）：把选中的会话收进 History，纳入保留期管理。
-        'history-archive-batch': async (args) => {
-            const registry = deps.getSessionsRegistry();
-            if (!registry)
-                return { ok: false, error: '归档服务未挂载' };
-            const rawIds = (args && args.sessionIds) || [];
-            const ids = Array.isArray(rawIds) ? rawIds.map((s) => String(s).trim()).filter(Boolean) : [];
-            if (!ids.length)
-                return { ok: false, error: '请至少选择一个会话' };
-            const archived = [];
-            const failed = [];
-            for (const sessionId of ids) {
-                try {
-                    await registry.archiveSession(sessionId);
-                    archived.push(sessionId);
-                }
-                catch (e) {
-                    failed.push({ sessionId, error: deps.message(e) });
-                }
-            }
-            return { ok: true, archived, failed };
-        },
         'history-unarchive': async (args) => {
             const registry = deps.getSessionsRegistry();
             if (!registry)
@@ -321,6 +331,17 @@ export function buildSessionOps(deps) {
                 return { ok: false, error: '当前环境不支持重新登记工作区（registry 未实现 registerWorkspace）' };
             }
             const title = args && args.title ? String(args.title) : undefined;
+            // 目录已被删除时提前拦下（用户 2026-10-12：工作区文件夹删掉后不该还能「重新登记」）。
+            // 宿主 registerWorkspace 内部的 realpath 本来就会拒绝，但报错文本是底层的；这里给
+            // 一句能直接读懂的提示。界面在 dirMissing 时已不再渲染该按钮，这条是防御性兜底。
+            try {
+                const st = await stat(path);
+                if (!st.isDirectory())
+                    return { ok: false, error: '目录已不存在，无法重新登记：' + path };
+            }
+            catch {
+                return { ok: false, error: '目录已不存在，无法重新登记：' + path };
+            }
             try {
                 const workspace = await registry.registerWorkspace(path, title);
                 return { ok: true, workspace };

package/lib/ops/trash.js

@@ -4,9 +4,10 @@
 // 但共用 copyIntoMemoriesTrash 等入口，经 MemoriesOpsCtx 显式传入。
 import { copyFile, cp, lstat, mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { isValidTrashId } from '../hub.js';
+import { isValidTrashId, readTrashPayloadFiles, trashEntryPath } from '../hub.js';
 import { LEGACY_BUNDLE_DOC, bundleDocName, isValidGroupSegment, isValidGroupPath, fail, MEMORIES_TRASH_DIR } from '../memories/constants.js';
 import { readIndex, writeIndex } from '../memories/index-io.js';
+import { isValidSegment } from '../paths.js';
 /** 组装本域 op。rc 由 createMemoriesService 组装，契约见 ./ctx.ts。 */
 export function buildTrashOps(rc) {
     const { buildProjected, copyIntoMemoriesTrash, invalidateSnapshot, locateRule, parseId, refuseOutsideRoot, memoriesRoot, stateDir } = rc;
@@ -33,6 +34,21 @@ export function buildTrashOps(rc) {
         invalidateSnapshot();
         return { ok: true, trashId };
     }
+    /**
+     * 同组里第一个空出来的退号名：`测` → `测（1）` → `测（2）`…（全角括号，与界面 `uniqueName`
+     * 同一写法）。超过段名长度上限的候选直接跳过 —— 退号名本身也必须是合法段名，否则
+     * `locateRule` 查不到、恢复时还会写出一个磁盘不接受的名字。
+     */
+    async function nextFreeRuleName(group, name) {
+        for (let i = 1; i <= 999; i += 1) {
+            const candidate = `${name}（${i}）`;
+            if (!isValidGroupSegment(candidate))
+                return null;
+            if (!(await locateRule(group, candidate)))
+                return candidate;
+        }
+        return null;
+    }
     async function rulesRestore(args) {
         const trashId = String((args && args.trashId) || '');
         if (!isValidTrashId(trashId))
@@ -55,11 +71,29 @@ export function buildTrashOps(rc) {
             || (manifest.group !== '' && !isValidGroupPath(manifest.group))) {
             return fail('error.rules.notFound', `回收站条目损坏：${trashId}`);
         }
-        // 恢复目标已存在（期间用户重建了同名规则）→ 拒绝，避免覆盖。
+        // 恢复目标已存在（期间用户重建了同名规则）→ 默认拒绝，避免覆盖。
+        //
+        // 「同名先问一句」（用户 2026-10-14）：界面上不该静默退号、也不该只丢一句错误让人自己
+        // 回去改名。所以拒绝时**连候选名字一起回**（`params.next`）—— 弹窗才能如实写出"确认后
+        // 会叫 `测（1）`"。用户点确认后带 `dedupe: true` 再来一次，这一次真的按退号的名字恢复。
+        //
+        // `dedupe` 是**可选入参、缺省即旧行为**：模型工具（memory_manager_*）走的是同一个 op，
+        // 它们依赖"撞名就拒"来决定新建还是更新，不能因为界面想要退号就改掉这条语义。
         const conflict = await locateRule(manifest.group, manifest.name);
+        let name = manifest.name;
         if (conflict) {
-            return fail('error.rules.exists', `同名记忆已存在：${conflict.id}，请先移除后再恢复`);
+            const next = await nextFreeRuleName(manifest.group, manifest.name);
+            if (args?.dedupe !== true || !next) {
+                // 专用错误码（四个回收站统一）：界面按它认出"这是撞名"，据此弹确认窗 —— 而不是靠
+                // 比文案。`error.rules.exists` 留给 `rules-create`，那条是"新建撞名"，语义不同。
+                return fail('error.dup.conflict', `已存在同名记忆：${conflict.id}`, {
+                    name: manifest.name,
+                    ...(next ? { next } : {}),
+                });
+            }
+            name = next;
         }
+        const renamed = name !== manifest.name;
         const form = manifest.form === 'bundle' ? 'bundle' : 'flat';
         // 落点根内断言（realpath 口径）：`isValidGroupPath` 只挡 `..` 与分隔符，挡不住
         // 「中间目录是指向根外的链接」。与 `rulesRemove` 的删除前断言同一道闸。
@@ -73,8 +107,8 @@ export function buildTrashOps(rc) {
         // 去删目录。场景回收站（`sceneTrashRestore`）早有这条回滚（`moveIntoTrash` 反向搬回），
         // 记忆回收站这条缺了。这里方向相反：源还在回收站，所以回滚是**删掉没放完整的副本**。
         const target = form === 'bundle'
-            ? join(groupDir, manifest.name)
-            : join(groupDir, manifest.name + '.md');
+            ? join(groupDir, name)
+            : join(groupDir, name + '.md');
         try {
             await mkdir(groupDir, { recursive: true });
             if (form === 'bundle')
@@ -101,10 +135,17 @@ export function buildTrashOps(rc) {
         }
         await rm(trashDir, { recursive: true, force: true });
         invalidateSnapshot();
-        return { ok: true, rule: await buildProjected(manifest.group ? `${manifest.group}/${manifest.name}` : manifest.name) };
+        // 回传**最终落盘的名字**：退号恢复时它与回收站里的原名不同，界面要按它来回执
+        // （见 42-shared-ui.js 的 `resultRestore`），否则用户看到的是"已恢复：测"而磁盘上叫「测（1）」。
+        return {
+            ok: true,
+            name,
+            renamed,
+            rule: await buildProjected(manifest.group ? `${manifest.group}/${name}` : name),
+        };
     }
     /**
-     * 记忆回收站列表（只读）：`<stateDir>/memories-trash/<trashId>/`（`rulesRemove` 移入，
+     * 记忆回收站列表（只读）：`<stateDir>/trash/memories-trash/<trashId>/`（`rulesRemove` 移入，
      * `rulesRestore` 恢复）。损坏或内容缺失的条目跳过，不让一个坏条目挡住整份列表。
      */
     async function rulesTrashList() {
@@ -172,5 +213,63 @@ export function buildTrashOps(rc) {
         await rm(dir, { recursive: true, force: true });
         return { ok: true };
     }
-    return { rulesRemove, rulesRestore, rulesTrashList, rulesTrashRemove };
+    /**
+     * 回收站「详情」（只读）：把一条条目的内容读出来给界面看一眼"删掉的到底是什么"。
+     *
+     * 用户 2026-10-12：「回收站的每条信息应该增加一个详情按键，点开就能看这个信息是什么样子，
+     * 不能更改内容，没有保存按键」。所以这里**只有读**：不写盘、不改名、不动回收站条目。
+     *
+     * 为什么是一条跨域的 op 而不是五个域各加一条：五个回收站落在**三套不同的目录布局**里 ——
+     *   hub 四类：`<hub>/trash/<kind>-trash/<id>/`（`trashEntryPath`）
+     *   记忆：   `<stateDir>/trash/memories-trash/<trashId>/`
+     *   技能：   `<hub>/trash/skills-trash/<id>/`（skills 域的 `trashRootPath()`，由 index 注入）
+     * 但"读出来给人看"这件事完全一样，交给 `readTrashPayloadFiles` 一个函数做完，
+     * 上限 / 二进制判据 / 哪些名字算清单只写一遍。
+     *
+     * 条目目录不存在 / 不是目录 → 明确报"条目不存在"（与"目录在、但里面没有可显示的文件"
+     * 分开：前者是条死链，后者是一条正常但没内容的记录）。读不动的单个文件由
+     * `readTrashPayloadFiles` 自己跳过，不抛 —— 详情打不开不该影响用户对这条目做恢复 / 永久删除。
+     */
+    async function trashPreview(args) {
+        const domain = String((args && args.domain) || '');
+        const id = String((args && args.id) || '').trim();
+        const hubKinds = { presets: 'prompts', quick: 'quick-prompts', agents: 'subagents', scenes: 'scenes' };
+        let dir = null;
+        if (hubKinds[domain] || domain === 'memories') {
+            // hub 四类与记忆回收站的条目名都由 `newTrashId()` 生成（时间戳 base36 + uuid 前 8 位），
+            // 走那一套严格白名单 —— 它同时也是 `rulesRestore` / 硬删除用的同一道闸。
+            if (!isValidTrashId(id))
+                return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+            dir = hubKinds[domain]
+                ? trashEntryPath(hubKinds[domain], id)
+                : join(stateDir, MEMORIES_TRASH_DIR, id);
+        }
+        else if (domain === 'skills') {
+            // ⚠️ 技能回收站的条目名是 `${Date.now()}-${randomUUID()}`（见 core.ts 的移入回收站那段），
+            // **不满足** `isValidTrashId` 那条白名单（多段连字符 + 大写十六进制）—— 拿它去判会把
+            // 每一条技能条目都判成"不存在"，界面上就是"详情点了没反应"。
+            // 这里换成与 `skill-trash.ts` 的 `entryPath` 同一个口径：能安全当**一个路径段**即可
+            //（不含分隔符 / 不是 `.` `..` / 首尾无空白与点）。以点开头的一律拒 —— `listTrash()`
+            // 本来就把 `.stage-*` 那类临时目录排除在外，界面拿不到它们，这里也不该读得到。
+            if (!isValidSegment(id, 128) || id.startsWith('.'))
+                return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+            dir = rc.skillsTrashDir ? join(rc.skillsTrashDir, id) : null;
+        }
+        else
+            return fail('error.rules.notFound', `这个回收站不支持查看详情：${domain || '(空)'}`);
+        if (!dir)
+            return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+        // 条目目录本身必须真实存在（`readTrashPayloadFiles` 对不存在的目录返回空数组，
+        // 那种"空"与"条目不存在"要分开：前者能恢复、后者是条死链）。
+        try {
+            const st = await lstat(dir);
+            if (!st.isDirectory() || st.isSymbolicLink())
+                return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+        }
+        catch {
+            return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+        }
+        return { ok: true, id, domain, files: await readTrashPayloadFiles(dir) };
+    }
+    return { rulesRemove, rulesRestore, rulesTrashList, rulesTrashRemove, trashPreview };
 }

package/lib/request-gate.js

@@ -138,13 +138,20 @@ export function createSceneLock(deps) {
             return null;
         }
     }
-    /** 「当前场景已锁定」的拒绝文案（模型工具用；无活动场景 / 未锁定 → null）。 */
+    /**
+     * 「当前场景已锁定」的拒绝文案（模型工具用；无活动场景 / 未锁定 → null）。
+     *
+     * ⚠️ 读者是**模型**，不是面板用户：这句只陈述事实（哪个场景、被拒、可预期的规则），
+     * **不指路 UI**。「到场景页解锁」是给坐在界面前的人看的，模型照着做不了 —— 它只会
+     * 把这句读成"再试一次也许就好了"，于是重试同一次写入。要用户去解锁，由模型转述。
+     * （与 `src/tools/*.ts` 里那批回执同一条纪律；面板侧的中文报错是另一回事，那些读者是人。）
+     */
     async function lockedSceneGuard() {
         const scene = await activeSceneName();
         if (!scene)
             return null;
         const locked = await lockedSceneNames();
-        return locked.includes(scene) ? `场景「${scene}」已锁定：先到场景页解锁再改。` : null;
+        return locked.includes(scene) ? `场景「${scene}」已锁定，本次写入被拒：锁定期间该域不可修改，需用户解锁后再试。` : null;
     }
     return { lockedSceneNames, activeSceneName, lockedSceneGuard };
 }