dsh-plugin-tool-management 0.20.0 → 0.20.2

package/lib/ops/trash.js

@@ -34,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))
@@ -56,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` 的删除前断言同一道闸。
@@ -74,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')
@@ -102,7 +135,14 @@ 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>/trash/memories-trash/<trashId>/`（`rulesRemove` 移入，

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 };
 }

package/lib/scene-prompt-sync.js

@@ -173,30 +173,47 @@ export function createScenePromptSync(deps) {
         }
         return complete ? out : null;
     }
+    /**
+     * 进场景的第一笔写入之前，把当时的基线记下来（已有待恢复的基线就不覆盖：连续切场景时
+     * 基线始终是「进场景之前」那一份）。
+     * @returns 需要让用户知道的原因（写不进去 / 记下来是空的）；一切正常返回 undefined。
+     */
+    async function captureBaseline(scene) {
+        const saved = await readBaseline();
+        if (saved && saved.content !== null)
+            return undefined;
+        const cur = await deps.prompts.getCurrent();
+        const content = cur && cur.ok && cur.exists ? String(cur.content) : null;
+        const failed = await writeBaseline({
+            v: 1,
+            at: Date.now(),
+            presetId: cur && cur.ok && cur.presetId ? String(cur.presetId) : null,
+            content,
+        });
+        // 基线写不进去 = 退出场景时恢复不回来。**照旧进场景**（那是用户的要求），
+        // 但必须当场说出来，别让用户以为还能退回去（审查 F14）。
+        if (failed !== null) {
+            return `进场景前的提示词基线没能写入（${failed}）：AGENTS.md 已切到场景「${scene}」绑定的预设，但退出场景时恢复不回原来的内容（${deps.baselineFile}）。`;
+        }
+        // 记下来的是**空的**（进场景时 AGENTS.md 就不存在、或读不出来）：退出场景时没有正文
+        // 可写回，AGENTS.md 会留在场景态。与「写失败」是两件事，后果一样，同样当场说
+        // （2026-10-15 smoke-test P0-2：这一种此前要等到退出之后，才被误报成「快照损坏」）。
+        if (content === null) {
+            return `进场景前的 AGENTS.md 没有内容可记（文件不存在或读不出来）：退出场景时恢复不回原来的状态，AGENTS.md 会留在场景「${scene}」绑定的预设上。`;
+        }
+        return undefined;
+    }
     async function sync() {
         const current = await state();
         if (!current)
             return { unchanged: true };
         if (drives(current)) {
-            if (current.duplicate)
-                return { applied: current.presetId, unchanged: true };
-            // 进场景的第一笔写入之前，先记下当时的基线（已有快照就不覆盖：连续切场景时
-            // 基线始终是"进场景之前"那一份）。
-            let baselineError;
-            const saved = await readBaseline();
-            if (!saved || saved.content === null) {
-                const cur = await deps.prompts.getCurrent();
-                const failed = await writeBaseline({
-                    v: 1,
-                    at: Date.now(),
-                    presetId: cur && cur.ok && cur.presetId ? String(cur.presetId) : null,
-                    content: cur && cur.ok && cur.exists ? String(cur.content) : null,
-                });
-                // 基线写不进去 = 退出场景时恢复不回来。**照旧进场景**（那是用户的要求），
-                // 但必须当场说出来，别让用户以为还能退回去（审查 F14）。
-                if (failed !== null) {
-                    baselineError = `进场景前的提示词基线没能写入（${failed}）：AGENTS.md 已切到场景「${current.scene}」绑定的预设，但退出场景时恢复不回原来的内容（${deps.baselineFile}）。`;
-                }
+            // 基线必须在 `duplicate` 早退**之前**记（2026-10-15 smoke-test P0-2）：早退省的只是
+            // 「AGENTS.md 不用再写一遍」，不是「不用留退路」。原先这一句在早退之后，于是
+            // 「进一个内容已经等于该预设的场景」完全不记基线 —— 退出时恢复不回原内容。
+            const baselineError = await captureBaseline(current.scene);
+            if (current.duplicate) {
+                return { applied: current.presetId, unchanged: true, ...(baselineError ? { baselineError } : {}) };
             }
             const res = await deps.prompts.apply(current.presetId);
             if (res && res.ok === false)
@@ -205,16 +222,24 @@ export function createScenePromptSync(deps) {
         }
         // 没有场景驱动 → 如果刚从驱动态退出，把进场景前的基线写回去。
         const saved = await readBaseline();
-        if (!saved || saved.content === null) {
-            // 「没有快照」是常态（没进过场景）；「快照文件在、但读不出来」是**故障** ——
-            // 那意味着恢复目标丢了，AGENTS.md 的提示词基线会悄悄留在场景态。这里曾经一律
-            // 静默 `unchanged`，用户看到的是"没场景驱动所以什么都没做"（审查 P2-16）。
+        // 「快照文件在、但读不出来」是**故障** —— 那意味着恢复目标丢了，AGENTS.md 的提示词基线
+        // 会悄悄留在场景态。这里曾经一律静默 `unchanged`，用户看到的是"没场景驱动所以什么都没做"
+        // （审查 P2-16）。但两种"没有正文"必须分开（2026-10-15 smoke-test P0-2）：
+        //   · `saved === null`         → 文件缺失 / 半截 JSON / 解析失败；
+        //   · `saved.content === null` → 下面 `writeBaseline({presetId:null, content:null})` 写下的
+        //     「没有待恢复基线」哨兵，是**正常终态**（每次正常退出场景之后都会留下它）。
+        // 原先两者共用 `!saved || saved.content === null` 一个条件，于是每次正常退出之后，下一次
+        // 无场景驱动的同步都把哨兵判成损坏，报一句假 WARN —— 而假 WARN 长得和真故障一样，
+        // 反过来把"恢复目标真丢了"这条信号淹掉。
+        if (saved === null) {
             if (await baselineExists()) {
                 warn(`scene-prompt: baseline snapshot exists but is unreadable: ${deps.baselineFile}`);
                 return { error: `基线快照读不出来（文件可能损坏），未能恢复 AGENTS.md：${deps.baselineFile}` };
             }
             return { unchanged: true };
         }
+        if (saved.content === null)
+            return { unchanged: true };
         const res = await deps.prompts.restore(saved.content);
         if (res && res.ok === false)
             return { error: String(res.error || '恢复 AGENTS.md 失败') };

package/lib/scenes/candidates.js

@@ -155,8 +155,11 @@ export function createCandidates(deps) {
         }
     }
     /**
-     * 记忆候选（档案编辑器第 4 段「记忆」）：`[{ id, scene, name, description }]`。
+     * 记忆候选（档案编辑器第 4 段「记忆」）：`[{ id, scene, name, description, attach? }]`。
      * 只读、不读正文（勾选集只存 id）；任何异常降级为空列表，不让档案弹窗崩掉。
+     *
+     * `attach` 是宿主在 `rules-list` 里给 bundle 记忆补的附件摘要，这里原样带过去 ——
+     * 场景编辑器要在行上标一枚回形针，让用户看见"勾这条会连带把参考资料一起带进场景"。
      */
     async function memoryCandidates() {
         try {
@@ -170,6 +173,7 @@ export function createCandidates(deps) {
                 scene: String(x.group || ''),
                 name: String(x.name || ''),
                 description: String(x.description || ''),
+                ...(x.attach ? { attach: x.attach } : {}),
             }));
         }
         catch {

package/lib/sessions/workspace.js

@@ -544,16 +544,6 @@ var ArchiveWorkspaceRegistry = class {
         }
         return { attached, attachSkipped };
     }
-    /**
-     * 归档委托宿主。官方 UI 不经过本方法，而由 domain/changed 事件
-     * 同步归档时刻；重复归档不重置保留期。
-     */
-    async archiveSession(sessionId) {
-        // 委托宿主原生入口；宿主没有原生入口时走本门面的适配路径（能力探测决定）。
-        this.bridge.checkWorkspace("archive");
-        await this.registry.archiveSession(sessionId);
-        await this.reconcileArchiveLedger();
-    }
     /**
      * 列出已归档会话的展示元数据：sessionId / createdAt / cwd / title / archivedAt。
      * title 经投影缓存 best-effort 读取（cachedSnapshot 的标题行，旧格式记录退

package/lib/skills/catalog.js

@@ -93,17 +93,22 @@ export function renderSkillCatalog(data, maxEntries = SKILL_CATALOG_MAX_ENTRIES,
 export function createSkillCatalog(deps, opts = {}) {
     const ttlMs = opts.ttlMs ?? 30_000;
     const now = opts.now ?? (() => Date.now());
-    let value = '';
+    // 缓存的是**清单数据**而不是渲染结果：清单本体只依赖磁盘（一次读盘），而尾句要不要点名那个
+    // 查询工具取决于**这个 agent 手里有没有它**。渲染是纯字符串操作，代价可忽略；这个布尔就
+    // 两档，于是"每个 step 同步渲染"退化成一次查表（与人设目录按深度缓存同一手法）。
+    let data = null;
     let loadedAt = Number.NEGATIVE_INFINITY;
     let inflight = null;
+    let rendered = null;
     const recompute = async () => {
         try {
             const result = await deps.state();
             if (result && result.ok !== false) {
-                value = renderSkillCatalog(result.data ?? result, opts.maxEntries, opts.maxDescription, deps.listToolVisible ? deps.listToolVisible() : true);
+                data = result.data ?? result;
+                rendered = null;
             }
         }
-        catch { /* 保留上一次的值；首次失败则维持 '' */ }
+        catch { /* 保留上一次的值；首次失败则维持 null */ }
         loadedAt = now();
     };
     const revalidate = () => {
@@ -113,10 +118,17 @@ export function createSkillCatalog(deps, opts = {}) {
         return inflight;
     };
     return {
-        text: () => {
+        text: (agent) => {
             if (now() - loadedAt > ttlMs)
                 void revalidate();
-            return value;
+            if (data === null)
+                return '';
+            const visible = deps.listToolVisible ? deps.listToolVisible(agent) : true;
+            if (rendered && rendered.visible === visible)
+                return rendered.text;
+            const out = renderSkillCatalog(data, opts.maxEntries, opts.maxDescription, visible);
+            rendered = { visible, text: out };
+            return out;
         },
         refresh: () => {
             loadedAt = Number.NEGATIVE_INFINITY;

package/lib/skills/core.js

@@ -17,6 +17,9 @@ import { promises as fs, } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { discoverReadonlyEntries, validDiscoveryName, } from "./readonly-discovery.js";
 import { isSameOrDescendant } from "../paths.js";
+// 回收站条目 id（与 hub / 记忆 / 人设 / 场景 / 提示词共用一个生成器）。不能引 `../hub.js` ——
+// 那边引了本文件的 resolveDshHome，引回去就是环；所以生成器放在 `../trash-id.js` 这一叶上。
+import { newTrashId } from "../trash-id.js";
 import { OFFICE_SKILL_NAMES, OFFICIAL_SOURCE_KEY, officialOfficeRuntimeSection, } from "./official.js";
 import { parseSkillDoc, toKebab, unquote } from "./frontmatter.js";
 // 拆出去的公开函数照旧挂在 core.js 上（tools/skills.ts 引 toKebab，memories/* 与 ops/memory.ts
@@ -49,7 +52,7 @@ import { checkedWritableRootDefinition, movePathWithFallback, safeExistingEntryP
 // ./core.js 引），照旧再出口一次。
 export { customRootsFromState, effectiveSkillPolicy, entryOf, groupLoadableSkillsByName, parseBoolValue, readManagerState, scanEntries, state, writeManagerState, } from "./manager-state.js";
 import { CUSTOM_ROOT_KEY_RE, PROJECT_ROOT_KEY_RE, customRootsFromState, effectiveSkillPolicy, entryOf, groupLoadableSkillsByName, isInsideResolvedRoot, readManagerState, scanDeduplicatedRoots, writeFileAtomically, writeManagerState, } from "./manager-state.js";
-import { KEBAB_RE, pathsOverlap, } from "./upload-pipeline.js";
+import { KEBAB_RE, normalizeUploadPath, pathsOverlap, uploadError, writeUploadedEntries, } from "./upload-pipeline.js";
 import { customRootKey, dshRootPath, isDefaultSkillSource, managerHomePath, managerStatePath, projectIdentity, projectRoots, projectSourceSafe, readonlyError, resolvedPath, rootByKey, rootDefinition, trashRootPath, userRoots, } from "./skill-roots.js";
 import { codedError, entryPath, lstatOrNull, renameWithRetry, pathIdentity, temporaryPath, TRANSIENT_RENAME_CODES, } from "./core-util.js";
 const USER_DSH_POLICY_RANK = 399;
@@ -713,6 +716,24 @@ export async function markSkillsDisabled(entries, log) {
         return invalidManagerStateWrite();
     let dirty = false;
     for (const e of clean) {
+        /*
+         * 同一张表里的两个名单**互斥**（`disabledSkills` = 显式关、`enabledSkills` = 显式开，
+         * 见 manager-state 的 validManagerStateDocument）。名字进了 disabled 就必须从 enabled 摘掉。
+         *
+         * 少了这一步，「显式启用过 → 删除 → 从回收站恢复」这条链会把同一个名字同时留在两份名单
+         * 上（删除不清策略、恢复又要默认停用），整份状态随即被判非法 —— 插件 fail-closed 停用
+         * **所有**技能，而且 `writable` 一并变 false，用户在界面上连一个开关都按不动，等于被锁死在
+         * 一份自己造不出来的状态上（用户 2026-10-14 实测踩到）。
+         *
+         * 摘除要放在下面那个 `continue` **之前**：名字已经在 disabled 里、却还挂在 enabled 上
+         * （就是被锁死的那份文件的形状）时，`continue` 会把清理一并跳过去。
+         */
+        const explicit = current.state.enabledSkills[e.root] || [];
+        const keptExplicit = explicit.filter((name) => name !== e.name);
+        if (keptExplicit.length !== explicit.length) {
+            current.state.enabledSkills[e.root] = keptExplicit;
+            dirty = true;
+        }
         const prev = current.state.disabledSkills[e.root] || [];
         if (prev.indexOf(e.name) >= 0)
             continue;
@@ -873,7 +894,11 @@ export async function deleteSkill(root, name, log, options = {}) {
             params: { name },
         };
     const targets = await safeExistingEntryPaths(definition.path, name);
-    const id = `${Date.now()}-${randomUUID()}`;
+    // 回收站条目 id 走五个域共用的那个生成器（2026-10-15 smoke-test P1-7）：此前这里另写了一套
+    // `${Date.now()}-${randomUUID()}`，于是同一次操作里记忆/人设/场景/提示词拿到 `mv8faxqe-…`
+    // 这种形状、技能拿到 `1792001296466-62d3d393-…`。模型按 `action=list` 的 id 跨域 restore，
+    // 两种长相只会让它多猜一层。读侧只校验单个合法路径段，旧条目照旧能列、能恢复。
+    const id = newTrashId();
     const trashRoot = trashRootPath();
     const stage = join(trashRoot, `.stage-${randomUUID()}`);
     const finalPath = join(trashRoot, id);
@@ -972,11 +997,12 @@ function yamlString(value) {
     return JSON.stringify(String(value));
 }
 export async function createSkill(input, log, options = {}) {
-    // v0.4：默认落点由「DSH 技能目录」改为 hub 内的 `tool-management/skills/`；
-    // 调用方显式传 options.root（如项目根）时仍以调用方为准。
+    // 默认落点是「DSH 技能目录」（用户裁定 2026-10-15 改回）：v0.4-v0.20.0 期间这里是 hub。
+    // hub（`tool-management/skills/`）现在只服务「导入技能」功能 —— 那边走
+    // `skillCreateRootPath()`，不经这里。调用方显式传 options.root（如项目根）时仍以调用方为准。
     const requestedRoot = Object.prototype.hasOwnProperty.call(options, "root")
         ? options.root
-        : rootByKey("hub") || rootByKey("dsh");
+        : rootByKey("dsh") || rootByKey("hub");
     const definition = await checkedWritableRootDefinition(requestedRoot);
     if (definition && definition.ok === false)
         return definition;
@@ -1020,6 +1046,31 @@ export async function createSkill(input, log, options = {}) {
         };
     if (description.length > 500 || body.length > 1 << 18)
         return { ok: false, error: "技能内容过长", code: "error.create.tooLarge" };
+    // 附件的闸一律复用导入那条链（normalizeUploadPath + writeUploadedEntries 里的 32 MiB /
+    // 64 MiB / 1000 条），不另立规矩：界面上新建的技能与导入的技能带同一份 `references/`
+    // 时，落盘形态必须一致。SKILL.md 是本次要写的正文，不能被附件占用。
+    const files = Array.isArray(input && input.files) ? input.files : [];
+    try {
+        for (const item of files) {
+            const rel = normalizeUploadPath(item?.path).path;
+            if (/(^|\/)skill\.md$/i.test(rel))
+                return {
+                    ok: false,
+                    error: `附件不能占用 SKILL.md（正文由本次创建写入）: ${rel}`,
+                    code: "error.create.reservedPath",
+                    params: { path: rel },
+                };
+        }
+    }
+    catch (error) {
+        return uploadError(error);
+    }
+    if (files.length && form === "flat")
+        return {
+            ok: false,
+            error: "单文件技能不能带附件：附件需要目录形态",
+            code: "error.create.filesWithFlat",
+        };
     if (await safeExistingEntryPaths(root, name).then((items) => items.length > 0))
         return {
             ok: false,
@@ -1043,10 +1094,18 @@ export async function createSkill(input, log, options = {}) {
     try {
         await fs.mkdir(stage);
         await fs.writeFile(join(stage, "SKILL.md"), content, "utf8");
+        // 附件写进**同一个临时目录**再整体改名到位：中途失败时目标路径根本不存在，
+        // 不会留下「有 SKILL.md 没有 references」的半截技能（下方 catch 顺手把 stage 清掉）。
+        if (files.length)
+            await writeUploadedEntries(stage, files);
         await renameWithRetry(stage, target);
     }
     catch (error) {
         await fs.rm(stage, { recursive: true, force: true }).catch(() => undefined);
+        // 带附件时把失败收拢成结果对象：路径非法 / 超限这些都是用户输入问题，抛出去只会
+        // 让界面拿到一句英文堆栈。不带附件时照旧抛（与改动前一字不差）。
+        if (files.length)
+            return uploadError(error);
         throw error;
     }
     if (log)
@@ -1146,6 +1205,59 @@ export async function updateSkill(input, log, options = {}) {
         log("update", `更新 ${existingDoc}`);
     return { name, path: existingDoc, root: definition.key };
 }
+/** 详情弹窗列出的 bundle 附件上限：再多就不是给人看的清单了（2026-10-16）。 */
+const MAX_DETAIL_ATTACHMENTS = 200;
+const MAX_DETAIL_ATTACHMENT_DEPTH = 6;
+/**
+ * 列出 bundle 目录里除顶层 `SKILL.md` 之外的普通文件（相对路径 + 字节数）。
+ *
+ * 走 lstat 并跳过符号链：这份清单会原样列进详情弹窗、也会打印给模型看，
+ * 里面混一条指向目录树之外的链就是误导。深度与条数都有上限，超了如实标 truncated。
+ */
+async function listBundleAttachments(dir) {
+    const files = [];
+    let truncated = false;
+    async function walk(base, prefix, depth) {
+        let items;
+        try {
+            items = await fs.readdir(base, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const item of items) {
+            const rel = prefix ? `${prefix}/${item.name}` : item.name;
+            if (depth === 0 && item.name.toLowerCase() === "skill.md")
+                continue;
+            const abs = join(base, item.name);
+            let stat;
+            try {
+                stat = await fs.lstat(abs);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                if (depth + 1 >= MAX_DETAIL_ATTACHMENT_DEPTH)
+                    continue;
+                await walk(abs, rel, depth + 1);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            if (files.length >= MAX_DETAIL_ATTACHMENTS) {
+                truncated = true;
+                return;
+            }
+            files.push({ path: rel, size: stat.size });
+        }
+    }
+    await walk(dir, "", 0);
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, truncated };
+}
 export async function skillDetail(keyOrRoot, name, options = {}) {
     const scopedRoots = await projectRoots(options.projectCwds);
     // 支持传 key 或 definition（自定义来源由 service 层解析后传入）。
@@ -1183,6 +1295,8 @@ export async function skillDetail(keyOrRoot, name, options = {}) {
     }
     const doc = parseSkillDoc(raw);
     const summary = entryOf(name, entry.kind, entry.docPath, doc);
+    // bundle 才有附件；flat 是单文件，给 null 让调用方分清"没有目录"与"目录是空的"。
+    const attachments = entry.kind === "bundle" ? await listBundleAttachments(dirname(entry.docPath)) : null;
     return {
         root: root.key,
         name,
@@ -1197,6 +1311,8 @@ export async function skillDetail(keyOrRoot, name, options = {}) {
         diagnostics: summary.diagnostics,
         loadable: summary.loadable,
         sourceReadOnly: !root.mutable,
+        attachments: attachments ? attachments.files : null,
+        attachmentsTruncated: attachments ? attachments.truncated : false,
     };
 }
 /**

package/lib/skills/frontmatter.js

@@ -94,3 +94,34 @@ export function unquote(v) {
     }
     return s;
 }
+// ── 声明名改写（退号落盘后同步 frontmatter）─────────────────────────────────
+/** frontmatter 整块（开栏 / 字段区 / 闭栏三段各自成组，便于逐字回拼）。 */
+const DECLARED_NAME_BLOCK_RE = /^(?<open>(?:\uFEFF)?[^\S\r\n]*---[^\S\r\n]*(?:\r\n|\n))(?<fields>[\s\S]*?)(?<close>^[^\S\r\n]*---[^\S\r\n]*(?:\r\n|\n|$))/m;
+/** 顶格的 `name:` 行；缩进的嵌套字段（块标量的续行等）不匹配。 */
+const DECLARED_NAME_LINE_RE = /^name[^\S\r\n]*:[^\r\n]*/m;
+/**
+ * 把 frontmatter 的 `name:` 行改写成新名字，其余逐字节保留（连 CRLF 都不动）；
+ * 认不出形态（没有 frontmatter / 没有 `name:` 行 / 改完不变）时返回 null。
+ *
+ * **调用方保证 `name` 过 KEBAB_RE**（只含 `[a-z0-9-]`，无需转义；本模块不引
+ * upload-pipeline 的 KEBAB_RE —— 那边引了本模块，引回来就成了环）。
+ *
+ * 退号落盘后必须调用（导入撞名、回收站恢复）：`canonicalSkillName` 取的是
+ * 声明名而不是条目名，只改目录会"看着叫 foo-1、其实还是 foo"—— 两份同名
+ * 技能在「同名首选」里被并成一组，而那颗开关挑的是来源，按下去什么都不会变。
+ * 没有 `name:` 行的文档返回 null 是**良性**的：声明名为空时 canonicalSkillName
+ * 回落到条目名，退号后的目录名就是它的名字。
+ */
+export function rewriteDeclaredName(text, name) {
+    const match = DECLARED_NAME_BLOCK_RE.exec(text);
+    if (!match || !match.groups)
+        return null;
+    const fields = match.groups.fields;
+    // 函数式替换：字段区里可能带 `$&` / `$'` 之类字面量，字符串式替换会把它们当占位符展开。
+    const rewritten = fields.replace(DECLARED_NAME_LINE_RE, () => `name: ${name}`);
+    if (rewritten === fields)
+        return null;
+    const open = match.groups.open;
+    const close = match.groups.close;
+    return text.replace(DECLARED_NAME_BLOCK_RE, () => `${open}${rewritten}${close}`);
+}

package/lib/skills/manager-state.js

@@ -451,6 +451,30 @@ export function normalizeManagerState(value) {
         if (forgotten.length)
             normalized.removedSources = normalized.removedSources.filter((key) => !forgotten.includes(key));
     }
+    /*
+     * 自愈：同一个名字不许同时挂在 `disabledSkills` 与 `enabledSkills` 上 —— 那是
+     * `validManagerStateDocument` 判整份文档非法的一种形状。
+     *
+     * 为什么这里**自愈**而不是照旧报错：`readManagerState` 碰到非法文档会 fail-closed 停用
+     * **所有**技能，并且把 `writable` 一起置 false —— 用户在界面上连一个开关都按不动，等于被
+     * 锁死在一份自己造不出来的状态里（用户 2026-10-14 实测踩到，出这条冲突的链是
+     * 「显式启用 → 删除 → 从回收站恢复」，写入侧已在 `markSkillsDisabled` 修掉）。
+     * 而这条不一致本身是无害的：两份名单都只是"用户显式说过什么"，选哪边都能让插件正常工作。
+     * 这与本函数既有的自愈口径一致（指向未知来源的首选、非法的自定义来源条目都是逐条丢掉）。
+     *
+     * 收敛方向取**保守的那一边**：保留 disabled、摘掉 enabled。反向（让 enabled 赢）会静默把
+     * 一个技能打开并送进模型上下文 —— 那才是危险方向；而"关着"用户看得见，翻一下开关就好。
+     * 这也正是 v0.8.5「新建 / 导入 / 恢复默认停用」本来要的落点。
+     */
+    for (const [key, disabled] of Object.entries(normalized.disabledSkills)) {
+        const enabled = normalized.enabledSkills[key];
+        if (!Array.isArray(disabled) || !disabled.length)
+            continue;
+        if (!Array.isArray(enabled) || !enabled.length)
+            continue;
+        const off = new Set(disabled);
+        normalized.enabledSkills[key] = enabled.filter((name) => !off.has(name));
+    }
     return normalized;
 }
 export function normalizeCustomRoots(value) {
@@ -630,6 +654,17 @@ export function markWinners(items, options = {}) {
                     name: winner.entry.name,
                     enabled: winnerEnabled,
                 };
+            /*
+             * 契约：`shadowedBy.root === item.root.key` ⟺ 撞名发生在**同一个来源目录内部**
+             * （两个文件夹都写着 `name: X`），而不是"同一个技能在两个来源里各有一份"。
+             *
+             * 两者必须分得开，因为界面能采取的动作完全不同：跨来源时那颗「启用这个」写的是
+             * `preferredSkills[名] = 来源 key`（真的能换掉生效的那一份）；同来源内部则怎么写都
+             * 指不出区别 —— 首选表的值就是来源 key，两份都在同一个来源里。用户 2026-10-14 报的
+             * 正是这颗**按下去什么都不会变**的假按钮（技能页把它摆在两份同名之间）。
+             * 界面按这个判据收掉按钮（见 client 的 `renderSkill`），但**保留"被覆盖"这个标记**：
+             * 同来源里的落选那份确实不会被加载，如实说比什么都不说好。
+             */
         }
         if (options.markWinner !== false)
             winner.view.winner = true;
@@ -716,8 +751,12 @@ export async function state(options = {}) {
             });
             continue;
         }
-        // 即使项目 .dsh/skills 尚不存在，也要把可写根返回给创建表单；只读项目根仍按实际存在性展示。
-        if (root.scope === "project" && !exists && root.kind !== "project-dsh")
+        // 项目来源只在真的有技能条目时才注册（skill-roots.ts 的 projectRoots，用户
+        // 2026-10-15 裁定「无技能的项目来源不注册」）；走到这里还不存在的项目根没有可显示的
+        // 内容，跳过。旧实现曾反过来 —— 「即使 .dsh/skills 不存在也把可写根返给创建表单」，
+        // 而创建落点 2026-10-15 已收敛到用户级目录（createRoots 排除 scope=project），
+        // 那条 carve-out 只剩把空来源泵进场景切换的副作用，故删。
+        if (root.scope === "project" && !exists)
             continue;
         if (truncated)
             result.warnings.push({