dsh-plugin-tool-management 0.8.0 → 0.9.0

package/lib/context-inject.js

@@ -0,0 +1,304 @@
+// src/context-inject.ts —— 模型可见信息的注入通道（本插件唯一的注入实现）。
+//
+// 为什么有这条通道（2026-09-16 用户裁定）：
+//   插件此前用 `systemPrompt.section()` 把信息送进系统提示词，但那条通道会被 persona
+//   `complete: true` 的预设整段压掉（极简等），模型什么都看不到；换成官方的
+//   `systemPrompt.context()` 也不行 —— 极简同时写着 `includeRuntimeContext: false`，
+//   运行时上下文快照照样被压。
+//   官方自己不受影响的三件事走的都是第三条路：**在每一步请求开始前，往本轮消息里插一条
+//   合成的 user 消息**（`agent/pre-step` 瀑布）——
+//     · skill-catalog（@deepseek-ai/dsh-tool-skill）
+//     · ~/.dsh/AGENTS.md（@deepseek-ai/dsh-agent-instructions）
+//     · 时间上下文（@deepseek-ai/dsh-time-context）
+//   这条通道没有任何预设开关能关掉，是"任何预设都到得了"的唯一选择。
+//
+// 形态（2026-09-16 第二版，用户裁定）：**每个域一条自己的消息**，不再是一条大快照 ——
+// 与官方 skill-catalog 同款：各自的来源 kind（轨迹里各自一行、各显各的名字）、各自的
+// form、各自的去重。好处是"只改了一个域就只重发那一条"；代价是进场景这类多域同时变的
+// 时刻会一次发几条（每条带一句自己的引导语）。五个域与轨迹行名：
+//   memory    → scene-memory-manager-catalog（场景和记忆）
+//   mcp       → mcp-manager-catalog
+//   skills    → skill-manager-catalog（不叫 skill-catalog：那是官方那条行的名字）
+//   subagents → subagent-manager-catalog
+//   prompt    → prompt-manager-catalog
+// 来源**不带 `plugin` 字段**：轨迹行标签的规则是「已知 kind 用自己的名字，插件来源用插件 id，
+// 其余用裸 kind」，不带 plugin 才能让每行显示成自己的 kind（官方 agent-instructions /
+// skill-catalog 同样只带 kind）。
+//
+// 本模块的实现口径：
+//   - 每个 step 同步算一遍各域文本（各域自带 SWR/stat 缓存，**绝不在这里读盘**）；
+//   - 与会话**可见表面上**该域最新的己方消息逐字节比对：一样就不发（零 token、零重复），
+//     不一样才追加一条新消息；被压缩移出表面后比对不到 → 自动重发（与 skill-catalog、
+//     agent-instructions 同款做法：两者都直接扫 `session.surface.nodes`）；
+//   - 某域曾经注入过、现在没有内容（域被关掉或正文清空）→ 发一条该域的「已清空」，
+//     免得旧目录继续被当成现状。
+//
+// 注入永远不能让这一步失败：任何异常都在监听器里吞掉、原样返回 decision。
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { SessionSeq } from '@deepseek-ai/dsh-session';
+/**
+ * 权威域顺序（界面勾选、注入消息先后都按它）。
+ * 场景和记忆排第一：它是"当前模式"的框架，先给框架再给内容。
+ */
+export const INJECT_DOMAIN_KEYS = ['memory', 'mcp', 'skills', 'subagents', 'prompt'];
+/**
+ * 域 → 消息来源 kind（轨迹行标签，也是去重时的身份）。
+ *
+ * 命名对齐官方 `*-catalog` 风格与本插件的工具族（`*_manager_*`）；改名等于换身份，
+ * 旧消息会被当成"不在上下文里"而重发一次，所以这几个字符串是稳定契约。
+ */
+export const INJECT_KIND_OF = {
+    memory: 'scene-memory-manager-catalog',
+    mcp: 'mcp-manager-catalog',
+    skills: 'skill-manager-catalog',
+    subagents: 'subagent-manager-catalog',
+    prompt: 'prompt-manager-catalog',
+};
+/**
+ * 「官方已经送得到就别再送」的域 → 对应预设事实的键。
+ *
+ * 这两个域的内容官方也有：提示词（AGENTS.md 正文；场景期间换成场景提示词）由
+ * `dsh-agent-instructions` 连着文件一起送，技能目录由 `dsh-tool-skill` 送。预设挂得到官方
+ * 那条行时本插件不重复注入（否则同一段正文进上下文两次）；挂不到（极简两行都没挂）时才
+ * 由本插件兜底 —— 于是"极简也能选择是否注入"成立，而普通预设下不会出现两份。
+ */
+const CARRIER_FACT_OF = {
+    prompt: 'carriesAgentsMd',
+    skills: 'carriesSkillCatalog',
+};
+export const DEFAULT_INJECT_SETTINGS = {
+    underSuppressingPresets: false,
+    domains: { memory: true, mcp: true, skills: true, subagents: true, prompt: true },
+};
+/** 把任意输入夹成合法设置（缺项/类型不对一律退回默认；默认从不阻止注入）。 */
+export function normalizeInjectSettings(raw) {
+    const obj = (raw && typeof raw === 'object' ? raw : {});
+    const domainsRaw = (obj.domains && typeof obj.domains === 'object' ? obj.domains : {});
+    const domains = {};
+    for (const key of INJECT_DOMAIN_KEYS) {
+        domains[key] = typeof domainsRaw[key] === 'boolean' ? domainsRaw[key] : DEFAULT_INJECT_SETTINGS.domains[key];
+    }
+    return {
+        underSuppressingPresets: typeof obj.underSuppressingPresets === 'boolean'
+            ? obj.underSuppressingPresets
+            : DEFAULT_INJECT_SETTINGS.underSuppressingPresets,
+        domains,
+    };
+}
+/**
+ * 纯函数：按设置 + 预设事实挑出本次要注入的域。
+ *
+ * 规则（设计 2026-09-16）：
+ *   - 域开关关掉的、文本为空的，都不进；
+ *   - **压制型预设**且没开「仍然注入」→ 一个都不进（跟随预设）；
+ *   - 有官方载体的两个域（提示词 / 技能目录）：预设挂得到官方那条行时不进
+ *     —— 官方自己会送，再注入一遍只会重复；预设事实读不到（`undefined`）时按"已承载"处理
+ *     （宁可与现状一致，也不制造重复）；
+ *   - 同一段文本出现两次只保留前一个（跨域保险）。
+ */
+export function selectInjections(domains, settings, facts) {
+    const suppressing = facts !== undefined && facts.suppressing;
+    if (suppressing && !settings.underSuppressingPresets)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const domain of domains) {
+        if (settings.domains[domain.key] !== true)
+            continue;
+        const carrier = CARRIER_FACT_OF[domain.key];
+        // 官方载体已挂（或读不到预设、只能按已挂算）→ 不重复送；只有明确"没挂"才兜底。
+        if (carrier !== undefined && facts?.[carrier] !== false)
+            continue;
+        let text = '';
+        try {
+            text = String(domain.text() ?? '');
+        }
+        catch {
+            text = '';
+        }
+        if (text.trim() === '')
+            continue;
+        const fingerprint = text.trim();
+        if (seen.has(fingerprint))
+            continue;
+        seen.add(fingerprint);
+        out.push({ key: domain.key, name: domain.name, label: domain.label, form: domain.form, text });
+    }
+    return out;
+}
+/**
+ * 一条注入消息的正文（纯函数）：instructions 域原样送（对齐官方 AGENTS.md 那条行），其余带一行引导语。
+ *
+ * 引导语只有**一句话**（用户裁定 2026-09-16：五个域各发各的以后，原来那四行说明在每条消息里
+ * 重复一遍太冗余）：说清"这是什么 + 取代谁"就够 —— 域的名字、怎么查细节（`*_manager_list`
+ * 就在模型自己的工具表里）都不必在这里再说一遍。
+ */
+export function renderDomainText(section) {
+    if (section.form === 'instructions')
+        return section.text;
+    return [
+        '<system-reminder>',
+        `以下是本机插件的${section.label}（取代本次会话中更早的同类内容）。`,
+        '</system-reminder>',
+    ].join('\n') + '\n\n' + section.text;
+}
+/** 「已清空」通知正文：某个域曾经注入过、现在没有内容时发一条（纯函数，测试用）。 */
+export function clearedDomainText(key, label) {
+    return [
+        '<system-reminder>',
+        `dsh-plugin-tool-management：本插件的${label}已清空，本次会话中此前注入的同类内容不再有效。`,
+        '</system-reminder>',
+    ].join('\n');
+}
+/** 取一条消息的正文（只认单 text 块；形如官方 RuntimeContextProjection.textOf）。 */
+function textOf(message) {
+    const content = message?.content;
+    if (!Array.isArray(content) || content.length !== 1)
+        return undefined;
+    const block = content[0];
+    return block && block.type === 'text' && typeof block.text === 'string' ? block.text : undefined;
+}
+/**
+ * 会话**可见表面上**每个域最新一条己方注入的正文。
+ *
+ * 可见表面 = `session.surface.nodes`（dsh-session 的公开面，官方 skill-catalog 与
+ * agent-instructions 都直接扫它）：一条注入若已被压缩移出表面，说明它不在模型上下文里
+ * → 该域不在 map 里 → 该重发。表面接口整个缺失时退回扫事件流（按"仍可见"处理，
+ * 宁可与现状一致，也不制造每步重发）。
+ */
+function newestDomainTexts(agent) {
+    const out = new Map();
+    const session = agent?.session;
+    if (!session || typeof session.seq !== 'number' || typeof session.eventAt !== 'function')
+        return out;
+    const keyOfKind = new Map(INJECT_DOMAIN_KEYS.map((key) => [INJECT_KIND_OF[key], key]));
+    const scan = (seq) => {
+        let event;
+        try {
+            event = session.eventAt(SessionSeq(seq));
+        }
+        catch {
+            return false;
+        }
+        if (!event || event.type !== 'user/message')
+            return false;
+        const source = event.data && event.data.source;
+        const key = source && typeof source.kind === 'string' ? keyOfKind.get(source.kind) : undefined;
+        if (key === undefined || out.has(key))
+            return false;
+        const text = textOf(event.data);
+        if (text === undefined)
+            return false;
+        out.set(key, text);
+        return out.size === INJECT_DOMAIN_KEYS.length;
+    };
+    const nodes = session.surface && Array.isArray(session.surface.nodes) ? session.surface.nodes : undefined;
+    if (nodes !== undefined) {
+        const seqs = [];
+        for (const node of nodes) {
+            const n = Number(node);
+            if (Number.isFinite(n))
+                seqs.push(n);
+        }
+        seqs.sort((a, b) => b - a); // 从新到旧（表面自身的顺序不保证）
+        for (const seq of seqs)
+            if (scan(seq))
+                break;
+        return out;
+    }
+    for (let seq = session.seq - 1; seq >= 0; seq -= 1)
+        if (scan(seq))
+            break;
+    return out;
+}
+/**
+ * 注册 `agent/pre-step` 注入监听；返回清理函数。
+ *
+ * 宿主平面注册即可覆盖所有 agent（含子智能体、含任何预设）——dsh-scope 的
+ * `scopeTarget` 过滤对没有 scope 标记的 ctx 直接放行，官方 time-context 就是这么挂的。
+ */
+export function createContextInjector(deps) {
+    const log = (message) => {
+        try {
+            (deps.logger ?? ((m) => console.error('[dsh-plugin-tool-management] ' + m)))(message);
+        }
+        catch { /* ignore */ }
+    };
+    const ctx = deps.ctx;
+    if (!ctx || typeof ctx.on !== 'function')
+        return { dispose: () => { } };
+    const stop = ctx.on('agent/pre-step', async (payload, next) => {
+        const decision = await next();
+        try {
+            if (!decision || decision.kind === 'reject')
+                return decision;
+            const agent = payload && payload.agent;
+            if (!agent)
+                return decision;
+            // 空 turn 不注入（官方 dsh-agent-instructions 同款守卫）：step 1 且一条消息都没有时，
+            // 这一步本来就该原地结束（宿主随后把 turn 判为 completed）。此时注入会把空 turn
+            // 变成一次真实的模型请求 —— 凭空烧一次调用。
+            if (Number(payload.step) === 1 && messagesOf(decision).length === 0)
+                return decision;
+            const domains = deps.domains();
+            const sections = selectInjections(domains, deps.settings(), await deps.factsFor(agent));
+            const visible = newestDomainTexts(agent);
+            const additions = [];
+            const published = new Set();
+            for (const section of sections) {
+                published.add(section.key);
+                const text = renderDomainText(section);
+                if (visible.get(section.key) === text)
+                    continue;
+                additions.push(domainMessage(section, text));
+            }
+            // 曾经注入过、这一轮没有内容的域 → 一条「已清空」；从没注入过的域什么都不用说。
+            const labelOf = new Map(domains.map((domain) => [domain.key, domain.label]));
+            for (const key of INJECT_DOMAIN_KEYS) {
+                if (published.has(key))
+                    continue;
+                const previous = visible.get(key);
+                if (previous === undefined)
+                    continue;
+                const label = labelOf.get(key) ?? key;
+                if (previous === clearedDomainText(key, label))
+                    continue;
+                additions.push(clearedMessage(key, label));
+            }
+            if (additions.length === 0)
+                return decision;
+            return { ...decision, messages: [...messagesOf(decision), ...additions] };
+        }
+        catch (error) {
+            // 注入是尽力而为：任何异常都不能把这一步弄失败。
+            log('context injection failed: ' + String((error && error.message) || error));
+            return decision;
+        }
+    });
+    return {
+        dispose: () => { try {
+            if (typeof stop === 'function')
+                stop();
+        }
+        catch { /* ignore */ } },
+    };
+}
+function messagesOf(decision) {
+    const messages = decision && decision.messages;
+    return Array.isArray(messages) ? messages : [];
+}
+function domainMessage(section, text) {
+    const source = { kind: INJECT_KIND_OF[section.key], form: section.form };
+    if (section.form === 'snapshot')
+        source.sections = [{ name: section.name, text: section.text }];
+    return createUserMessage({
+        content: [{ type: 'text', text }],
+        source,
+    });
+}
+function clearedMessage(key, label) {
+    return createUserMessage({
+        content: [{ type: 'text', text: clearedDomainText(key, label) }],
+        source: { kind: INJECT_KIND_OF[key], form: 'notice', summary: `${label}已清空` },
+    });
+}

package/lib/hub.js

@@ -1,23 +1,33 @@
-// dsh-plugin-tool-management —— 统一数据目录（v0.4「一个 hub」）。
+// dsh-plugin-tool-management —— 统一数据目录（v0.4「一个 hub」，v0.9.0 名称按域对齐）。
 //
 // 用户在 2026-09-13 提出：插件产生的文件夹/文件全部收在 `$DSH_HOME/tool-management/`
 // 一个目录里，方便统一备份与查看。此前它们散在四处：
 //
 //   $DSH_HOME/scene-memory/                记忆真源            → tool-management/memories/
 //   $DSH_HOME/tool-management/             侧车（索引/回收站）  → 就地（hub 根）
-//   $DSH_HOME/subagents/                   人设                → tool-management/agents/
-//   <插件目录>/data/agents-md-presets/     AGENTS.md 预设库     → tool-management/agents-md/
+//   $DSH_HOME/subagents/                   人设                → tool-management/subagents/
+//   <插件目录>/data/agents-md-presets/     AGENTS.md 预设库     → tool-management/prompts/
 //
-// 最终布局：
+// 2026-09-16 用户又提出两点：① 根目录下还漏着几个以插件名开头的侧车与日志（`$DSH_HOME/
+// dsh-plugin-tool-management-*.json` / `.log`）+ 改 MCP 配置前的 patch 备份，都该收进 hub；
+// ② hub 内的名字要与**当前代码的域命名**一致（界面「提示词」+ 工具 `prompt_manager_*`，
+// 目录却叫 `agents-md`；域早就叫「记忆」，索引还叫 `rules-index.json`）。于是统一为：
 //
 //   ~/.dsh/tool-management/
-//   ├─ memories/<场景>/<名>.md | <场景>/<名>/SKILL.md   记忆正文（真源）
-//   ├─ agents/<人设>.md                                  子智能体人设
-//   ├─ agents-md/<预设 id>/AGENTS.md                     全局指令基线预设库
-//   ├─ skills/                                           插件新建的技能（可写根）
-//   ├─ trash/rules-trash/<id>/                           记忆回收站
-//   ├─ rules-index.json                                  启停/顺序/场景记录/档案/模式
-//   └─ config.json                                       插件设置
+//   ├─ memories/<场景>/<名>.md | <场景>/<名>/<名>.md   记忆正文（真源）
+//   ├─ subagents/<人设>.md                               子智能体人设
+//   ├─ prompts/<预设 id>/AGENTS.md                       提示词预设库（全局指令基线）
+//   ├─ skills/                                           插件新建/导入的技能（可写根）
+//   ├─ memories-index.json                               记忆启停/顺序 + 场景记录/档案/模式
+//   ├─ subagents-index.json                              人设启停集合
+//   ├─ skills-state.json                                 技能启停 / 首选 / 自定义目录
+//   ├─ mcp-disabled-tools.json | mcp-known-tools.json | mcp-notes.json | mcp-settings.json | mcp-export.json
+//   ├─ tool-management.log                               插件日志（滚动 .1）
+//   ├─ backups/cordis.patch.yml.bak-<时间戳>             改宿主 patch 前的备份
+//   └─ trash/{skills,subagents,prompts,scenes,memories}-trash/<id>/
+//
+// 留在 `$DSH_HOME` 根下的两个文件**不是**插件的：`AGENTS.md`（宿主每轮读取的全局基线，
+// 插件只是按场景/预设写它）与 `cordis.patch.yml`（宿主加载插件的配置入口）。
 //
 // 搬运纪律（三条，全部为了「不丢数据」）：
 //   1. **只搬不删**——源目录里的文件被 `rename` 走后，空壳目录保留；
@@ -25,8 +35,9 @@
 //   2. **绝不覆盖**——目标已存在同名项时跳过该项，保留目标。
 //   3. **每进程一次**——迁移是启动期的一次性动作，失败也不阻断服务（旧目录仍可读）。
 import { cp, lstat, mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
-import { join, dirname } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { resolveDshHome } from './skills/core.js';
 /** hub 根目录名（`$DSH_HOME` 下）。 */
 export const HUB_DIR = 'tool-management';
@@ -38,6 +49,127 @@ export function hubRoot() {
 export function hubPath(...segments) {
     return join(hubRoot(), ...segments);
 }
+/** patch 备份目录（`hub/backups/`）：宿主 patch 的 `.bak-<时间戳>` 都收在这里。 */
+export function hubBackupDir(home = resolveDshHome()) {
+    return join(home, HUB_DIR, 'backups');
+}
+// ── 一次性布局迁移（v0.9.0：根目录收编 + 按域改名）────────────────────────────
+//
+// 旧名 → 新名（hub 内相对路径）。`readIndex` 之类的读取端只用新名，所以迁移必须在任何
+// 读取之前完成 —— 由 `apply()` 在启动期同步跑一次（见 index.ts），不参与并发。
+const HUB_RENAMES = [
+    ['agents-md', 'prompts'],
+    ['rules-index.json', 'memories-index.json'],
+    ['rules-trash', 'memories-trash'],
+    ['agents', 'subagents'],
+    ['agents-index.json', 'subagents-index.json'],
+    ['state.json', 'skills-state.json'],
+    // 回收站分类目录（`trash/<域>-trash/`）
+    ['trash/agents-md-trash', 'trash/prompts-trash'],
+    ['trash/agents-trash', 'trash/subagents-trash'],
+];
+/** `$DSH_HOME` 根下由插件产生、要收进 hub 的文件（旧名 → hub 内新名）。 */
+const ROOT_FILE_MOVES = [
+    ['dsh-plugin-tool-management-disabled-tools.json', 'mcp-disabled-tools.json'],
+    ['dsh-plugin-tool-management-mcp-tools.json', 'mcp-known-tools.json'],
+    ['dsh-plugin-tool-management-notes.json', 'mcp-notes.json'],
+    ['dsh-plugin-tool-management-settings.json', 'mcp-settings.json'],
+    ['dsh-plugin-tool-management-export.json', 'mcp-export.json'],
+    ['dsh-plugin-tool-management.log', 'tool-management.log'],
+    ['dsh-plugin-tool-management.log.1', 'tool-management.log.1'],
+    // 更早的前缀（插件曾叫 dsh-skill-mcp-manager）
+    ['skill-mcp-manager-disabled-tools.json', 'mcp-disabled-tools.json'],
+    ['skill-mcp-manager-notes.json', 'mcp-notes.json'],
+    ['skill-mcp-manager-settings.json', 'mcp-settings.json'],
+    ['skill-mcp-manager-export.json', 'mcp-export.json'],
+];
+/** 宿主 patch 的备份名（`cordis.patch.yml.bak-<时间戳>`）。 */
+export function isPatchBackupName(name) {
+    return /^cordis\.patch\.yml\.bak-\d{8}-\d{6}$/.test(basename(name));
+}
+/**
+ * 布局迁移（同步、幂等、只搬不删、绝不覆盖）。**必须在任何读盘之前调用一次**：
+ *   ① hub 内旧名 → 新名（`agents-md/` → `prompts/` 等）；
+ *   ② `$DSH_HOME` 根下的插件侧车 / 日志 → hub（原来它们躺在宿主目录里）；
+ *   ③ 宿主 patch 的 `.bak-*` → `hub/backups/`；
+ *   ④ 技能回收站条目 `trash/<id>/` → `trash/skills-trash/<id>/`（与其余四类的命名对齐）。
+ * 任一步失败只跳过该项（下次启动再试），绝不抛错、绝不删除源数据。
+ */
+export function migrateHubLayoutSync(home = resolveDshHome()) {
+    const hubDir = join(home, HUB_DIR);
+    const move = (from, to) => {
+        try {
+            if (from === to || !existsSync(from) || existsSync(to))
+                return false;
+            mkdirSync(dirname(to), { recursive: true });
+            try {
+                renameSync(from, to);
+            }
+            catch {
+                cpSync(from, to, { recursive: true, force: true });
+                rmSync(from, { recursive: true, force: true });
+            }
+            return true;
+        }
+        catch {
+            return false; // 单项失败不阻断其余项（文件被占用 → 下次启动再试）
+        }
+    };
+    // ① 更早的 hub 目录名（插件叫 dsh-skill-mcp-manager 的时期）：**先**逐项并入 hub，
+    //    让下面 ② 的改名也覆盖从旧目录搬进来的那些（同名保留 hub 里已有的那份）。
+    for (const legacyHub of ['dsh-plugin-tool-management', 'skill-mcp-manager']) {
+        const from = join(home, legacyHub);
+        try {
+            if (!existsSync(from))
+                continue;
+            for (const name of readdirSync(from))
+                move(join(from, name), join(hubDir, name));
+        }
+        catch { /* 列举失败：下次启动再试 */ }
+    }
+    // ② hub 内旧名 → 新名
+    for (const [oldName, newName] of HUB_RENAMES)
+        move(join(hubDir, oldName), join(hubDir, newName));
+    // ③ `$DSH_HOME` 根下的插件侧车 / 日志 → hub
+    for (const [oldName, newName] of ROOT_FILE_MOVES)
+        move(join(home, oldName), join(hubDir, newName));
+    // 技能回收站：`trash/` 直属的条目目录（其余 `<域>-trash/` 已在上面搬过）。
+    try {
+        const trashDir = join(hubDir, 'trash');
+        if (existsSync(trashDir)) {
+            for (const entry of readdirSync(trashDir, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name.endsWith('-trash'))
+                    continue;
+                move(join(trashDir, entry.name), join(trashDir, 'skills-trash', entry.name));
+            }
+        }
+    }
+    catch { /* 列举失败：下次启动再试 */ }
+    // 宿主 patch 备份：根下的直接搬；`profiles/<名字>/` 下的带上层级后缀（否则与全局撞名）。
+    try {
+        const backups = hubBackupDir(home);
+        for (const name of existsSync(home) ? readdirSync(home) : []) {
+            if (isPatchBackupName(name))
+                move(join(home, name), join(backups, name));
+        }
+        const profilesDir = join(home, 'profiles');
+        if (existsSync(profilesDir)) {
+            for (const prof of readdirSync(profilesDir)) {
+                const dir = join(profilesDir, prof);
+                try {
+                    for (const name of readdirSync(dir)) {
+                        if (!isPatchBackupName(name))
+                            continue;
+                        const tag = 'profile-' + prof.replace(/[^A-Za-z0-9._-]/g, '_');
+                        move(join(dir, name), join(backups, name.replace(/^cordis\.patch\.yml/, 'cordis.patch.yml.' + tag)));
+                    }
+                }
+                catch { /* 单个 profile 目录读不动就跳过 */ }
+            }
+        }
+    }
+    catch { /* 同上 */ }
+}
 /** 路径是否存在（不跟随符号链接）。 */
 export async function pathExists(path) {
     try {
@@ -93,6 +225,15 @@ export async function relocateEntries(from, to, filter) {
     }
     return moved;
 }
+/**
+ * 老 manifest 里写着的 kind 值（v0.9.0 按域改名前的）：读盘时一并认，否则升级后
+ * 老条目会「列不出来、恢复不了」——目录搬对了名字，manifest 里的字段值还在说旧名。
+ */
+const LEGACY_TRASH_KINDS = {
+    prompts: ['agents-md'],
+    subagents: ['agents'],
+    scenes: [],
+};
 /** 某一类回收站的根目录：`hub/trash/<kind>-trash`。 */
 export function trashKindDir(kind) {
     return hubPath('trash', `${kind}-trash`);
@@ -119,7 +260,8 @@ async function readManifest(kind, id) {
         const parsed = JSON.parse(await readFile(join(dir, 'manifest.json'), 'utf8'));
         if (parsed === null || typeof parsed !== 'object')
             return null;
-        if (String(parsed.kind) !== kind || String(parsed.id) !== id)
+        const accepted = [kind, ...LEGACY_TRASH_KINDS[kind]];
+        if (!accepted.includes(String(parsed.kind)) || String(parsed.id) !== id)
             return null;
         return {
             v: Number(parsed.v) || 1,

package/lib/imports/upload.js

@@ -166,8 +166,9 @@ const MAX_BUNDLE_ATTACH_TOTAL = 16 * 1024 * 1024;
 /**
  * 记忆落点：
  * - 裸 `.md` → 落到 defaultScene（空串 = 全局：任何对话都注入）；zip 内带目录 → 目录路径即场景/分组。
- * - zip 内 `<场景路径>/<名>/SKILL.md` → bundle 记忆（目录末段是记忆名，其余前缀是场景）；同层非 `.md`
- *   文件作为附件一并带入（`.md` 不带——bundle 是叶子，塞进去不会被发现，静默降级反而误导）。
+ * - zip 内 `<场景路径>/<名>/<名>.md` → bundle 记忆（目录末段是记忆名，正文文件名与目录名一致，
+ *   其余前缀是场景）；同层非 `.md` 文件作为附件一并带入（`.md` 不带——bundle 是叶子，塞进去不会被发现，
+ *   静默降级反而误导）。旧导出包里正文可能仍叫 `SKILL.md`，也认（只读兼容）。
  * - zip 根层的裸 `SKILL.md` 没有目录名可当记忆名 → 跳过并回报；`SKILL.md` 的大小写变体也跳过
  *   （发现层只认精确 `SKILL.md`，NTFS 大小写不敏感下两者不能共存）。
  */
@@ -180,18 +181,39 @@ export function planMemoryImport(entries, defaultScene) {
         const idx = path.lastIndexOf('/');
         return { dir: idx >= 0 ? path.slice(0, idx) : '', base: path.slice(idx + 1) };
     };
-    // pass 1：认 bundle 目录（精确 SKILL.md；大小写变体只报跳过，不当 bundle 也不当 flat）。
+    // pass 1：认 bundle 目录（`<目录名>.md` 是正文；旧导出包的 `SKILL.md` 也认，只读兼容）。
     const bundleDocs = new Map();
+    const consumed = new Set(); // 已被 pass 1 认领（或已回报）的条目路径，pass 3 不再当 flat 处理
     for (const entry of entries) {
         const { dir, base } = split(entry.path);
-        if (base !== 'SKILL.md' && base.toLowerCase() !== 'skill.md')
-            continue;
-        if (base !== 'SKILL.md') {
+        const dirName = dir === '' ? '' : dir.slice(dir.lastIndexOf('/') + 1);
+        const isLegacyCaseVariant = base.toLowerCase() === 'skill.md' && base !== 'SKILL.md';
+        if (isLegacyCaseVariant) {
             problems.push({ name: entry.path, reason: 'SKILL.md 大小写变体不导入（发现层只认精确 SKILL.md，且与 NTFS 大小写不敏感冲突），已跳过' });
+            consumed.add(entry.path);
             continue;
         }
-        if (dir === '') {
+        // 一级目录恒为场景（与发现层 `discover`/`probeSceneFilesSync` 同口径）：`1/1.md` 是
+        // 「场景 1 的记忆 1」的 flat 正文，**不是**根层 bundle「1」——bundle 只认目录至少两段
+        // （`<场景>/<名>/<名>.md`）。认错会写出发现层根本读不到、且会把整个场景目录吃成叶子的形态。
+        const isRootSkill = base === 'SKILL.md' && dir === '';
+        if (isRootSkill) {
+            // zip 根层的裸 SKILL.md：没有目录名可作记忆名。
             problems.push({ name: entry.path, reason: 'SKILL.md 在 zip 根层，没有目录名可作记忆名，已跳过' });
+            consumed.add(entry.path);
+            continue;
+        }
+        const isLegacyDoc = base === 'SKILL.md' && dir.includes('/');
+        const isNamedDoc = dir.includes('/') && base === `${dirName}.md`;
+        if (!isLegacyDoc && !isNamedDoc)
+            continue;
+        consumed.add(entry.path);
+        const existing = bundleDocs.get(dir);
+        if (existing) {
+            // 同一目录里同时出现 `<目录名>.md` 与旧的 `SKILL.md`（少见）：`<目录名>.md` 优先。
+            const { base: existingBase } = split(existing.path);
+            if (isNamedDoc && existingBase !== `${dirName}.md`)
+                bundleDocs.set(dir, entry);
             continue;
         }
         bundleDocs.set(dir, entry);
@@ -206,7 +228,7 @@ export function planMemoryImport(entries, defaultScene) {
         if (!bundleDir)
             continue;
         if (dir !== bundleDir) {
-            problems.push({ name: entry.path, reason: 'bundle 只支持一层附件（SKILL.md 同层），子目录条目已跳过' });
+            problems.push({ name: entry.path, reason: 'bundle 只支持一层附件（正文同层），子目录条目已跳过' });
             continue;
         }
         if (!entry.bytes.length) {
@@ -231,7 +253,7 @@ export function planMemoryImport(entries, defaultScene) {
         list.push({ name, bytes: entry.bytes });
         attachments.set(bundleDir, list);
     }
-    // pass 3：先规划 bundle 目标（含 SKILL.md 同层 .md 的明确跳过），再走 flat。
+    // pass 3：先规划 bundle 目标（含正文同层 .md 的明确跳过），再走 flat。
     for (const [dir, doc] of bundleDocs) {
         const segs = dir.split('/');
         const name = segs[segs.length - 1];
@@ -256,12 +278,10 @@ export function planMemoryImport(entries, defaultScene) {
         const { dir, base } = split(entry.path);
         if (!base.toLowerCase().endsWith('.md'))
             continue;
-        if (base === 'SKILL.md')
-            continue;
-        if (base.toLowerCase() === 'skill.md')
-            continue; // pass 1 已回报
+        if (consumed.has(entry.path))
+            continue; // pass 1 已认领为 bundle 正文，或已回报为大小写变体/根层裸 SKILL.md
         if ([...bundleDocs.keys()].some((d) => dir === d || dir.startsWith(d + '/'))) {
-            problems.push({ name: entry.path, reason: 'bundle 目录内的非 SKILL.md 的 .md 不导入（bundle 是叶子，放进去不会被发现），已跳过' });
+            problems.push({ name: entry.path, reason: 'bundle 目录内的非正文 .md 不导入（bundle 是叶子，放进去不会被发现），已跳过' });
             continue;
         }
         const name = base.slice(0, -3); // 去掉 .md