dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/skills/core.js

@@ -13,302 +13,47 @@
 // 文件写入错误由路由返回给调用方。
 import { homedir } from "node:os";
 import { join, basename, dirname, resolve, isAbsolute, } from "node:path";
-import { promises as fs, existsSync, mkdirSync, readdirSync, copyFileSync, rmSync, statSync, } from "node:fs";
-import { createRequire } from "node:module";
-import { createHash, randomUUID } from "node:crypto";
-import { unzipSync } from "fflate";
+import { promises as fs, } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { discoverReadonlyEntries, validDiscoveryName, } from "./readonly-discovery.js";
-import { isSameOrDescendant, isValidSegment } from "../paths.js";
-const KEBAB_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const PROJECT_ROOT_KEY_RE = /^project-(?:dsh|agents):[a-f0-9]{16}$/;
-const CUSTOM_ROOT_KEY_RE = /^custom-[a-f0-9]{16}$/;
+import { isSameOrDescendant } from "../paths.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
+// 引 parseSkillDoc / unquote，契约测试也按 lib/skills/core.js 取它们）。
+export { parseSkillDoc, toKebab, unquote } from "./frontmatter.js";
+// 官方内置技能段与 home 解析拆到同目录的 official.ts / homes.ts 后，core.js 的公开面照旧
+// （hub.ts、memories/*、subagents/service.ts 都按 ../skills/core.js 引 resolveDshHome）。
+export { resolveAgentsHome, resolveDshHome } from "./homes.js";
+// 业务错误码 / 条目路径谓词 / 可恢复 rename 的重试这一层 2026-10-01 剥到 ./core-util.js：
+// 这几件被导入链路与技能读写**两侧同时**用到，留在本文件里就意味着任何搬出去的段都要反过来
+// 引 core —— 那是运行时环。搬到这里，两侧都只向下引这一层。公开面照旧：entryPath 与
+// renameWithRetry 仍有外部引方（index.ts 按 ./skills/core.js 引 renameWithRetry）。
+export { entryPath, renameWithRetry } from "./core-util.js";
+// 来源与路径底座（四来源 / 项目级来源 / root-state-trash 路径 / 路径比较口径）2026-10-01
+// 剥到 ./skill-roots.js。那一层只向下引 ./official.js / ./homes.js / ./core-util.js，
+// 不回引本文件；userRoots / projectRoots / trashRootPath 有外部引方（service.ts、
+// system-trash.ts），而 core.js 的公开面里还挂着另外四件 —— 全部照旧从 core.js 出口走。
+export { customRootKey, isDefaultSkillSource, managerHomePath, managerStatePath, projectRoots, trashRootPath, userRoots, } from "./skill-roots.js";
+// 上传落盘链路（Base64 目录 / ZIP 校成来源、写进技能根目录）2026-10-01 剥到
+// ./upload-pipeline.js；它向下引 core-util / import-pipeline / skill-roots 三层，不回引本文件。
+// service.ts 按 ./core.js 引这两件，公开面照旧再出口一次。
+export { importSkill, importUploadedSkill } from "./upload-pipeline.js";
+// 技能回收站（可写根判定 / 移进移出 / 清单读写）2026-10-01 剥到 ./skill-trash.js。
+// 四件本来在 core.js 的出口上（外部按 ./core.js 引），照旧再出口一次。
+export { listTrash, permanentlyDeleteTrash, readTrashMetadata, restoreTrash } from "./skill-trash.js";
+import { checkedWritableRootDefinition, movePathWithFallback, safeExistingEntryPaths, trashRootMetadata, } from "./skill-trash.js";
+// manager 状态层（状态文档与归一 / 启停策略 / 来源扫描去重）2026-10-01 剥到 ./manager-state.js：
+// 那三件事共用一份进程内 singleton state，拆成两层就得让一层去引另一层的私有状态，等于没拆。
+// readManagerState / effectiveSkillPolicy / entryOf 等本来挂在 core.js 的出口上（兄弟模块按
+// ./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 { 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;
-const WINDOWS_DEVICE_NAME_RE = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
-const MAX_SOURCE_DEPTH = 64;
-const MAX_ENTRY_NAME_LENGTH = 128;
 const MAX_BROWSE_ENTRIES = 500;
-const MAX_UPLOAD_ARCHIVE_BYTES = 32 << 20;
-const MAX_UPLOAD_ENTRY_BYTES = 32 << 20;
-const MAX_UPLOAD_TOTAL_BYTES = 64 << 20;
-const MAX_UPLOAD_ENTRIES = 1000;
-const MAX_UPLOAD_PATH_LENGTH = 512;
-const TRANSIENT_RENAME_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
-// ── 业务错误码 ────────────────────────────────────────────────────────────────
-/** 构造带 code/params 的业务 Error，供导入链路 throw 后透传到失败明细。 */
-function codedError(message, code, params) {
-    const error = new Error(message);
-    error.code = code;
-    error.params = params;
-    return error;
-}
-/** 把业务 Error 的 code/params 附加到失败明细；系统异常（ENOENT 等，非 error.* 前缀）保持原文。 */
-function attachCode(item, error) {
-    // 透传并回写任意失败明细对象（形状由各调用点决定），故按 any 处理。
-    const coded = error;
-    if (coded && typeof coded.code === "string" && /^error\./.test(coded.code))
-        item.code = coded.code;
-    if (coded && coded.params)
-        item.params = coded.params;
-    return item;
-}
-// ── 路径解析 ────────────────────────────────────────────────────────────────
-export function resolveDshHome() {
-    return process.env.DSH_HOME || join(homedir(), ".dsh");
-}
-export function resolveAgentsHome() {
-    return process.env.DSH_AGENTS_HOME || join(homedir(), ".agents");
-}
-// ── 官方内置技能来源（随宿主注入会话上下文的内置技能）──────────────────────
-//
-// 宿主按形态注入不同的官方技能（官方源码逐一核对，2026-09-30）：
-//   - 桌面版 4 个：office-docx / office-pptx / office-xlsx（dsh-skill-office 只在桌面
-//     宿主装配，assetRoot 指到 `<resources>/runtime/office-skills`）+ diagnose-windows-
-//     sandbox-acl（dsh-sandbox-local 的门控是 `process.platform === "win32"`，rank 600）。
-//   - web 版：沙盒诊断技能由宿主注入（门控只看 win32 —— 用户 2026-09-30 截图实锤，
-//     0.16.5 按「web 不注入」的误判把 web 挡在门外，导致页面不显示、宿主照注）；office
-//     插件 web 宿主不装配、不注入，但用户裁定（2026-09-30）技能页照样把这三个暴露出来
-//     统一管理（npm 包自带完整 assets，接管后可启停）。
-//
-// 它们或住在官方 asar 里、或由官方 provider 复制进临时目录自管，插件直接扫描/接管有两个
-// 坑：宿主子进程里对 asar 的 promises 读法与拦截器解析都出现过时灵时不灵（同机两次启动
-// 一组 4/1、一组全 0，实测）；沙盒技能的脚本要交给 PowerShell 子进程，asar 路径读不了。
-//
-// 因此这里把来源**物化**成插件自有的一份真实目录，**每种宿主形态各一份**
-// （`$DSH_HOME/tool-management/official-skills/<desktop|web>/`）：每次宿主启动从官方源头
-// 整目录覆盖拷贝（与官方 provider 的「私有资源副本」同一做法），扫描、启停、overlay、
-// 脚本执行全部落在真实文件上。599 压过宿主 provider 的 600，停用即不注入。分形态是竞态
-// 教训：0.16.5 之前共用一份目录，web 启动把它解析到的沙盒技能盖进去，桌面物化好的
-// 4 个只剩 1 个（实测）；改成各写各的子目录，互不清对方的账。共享布局的残留（旧条目
-// 直接躺在 official-skills/ 下）按已知名单清理。
-//
-//   - 预设参考技能（dsh-agent-preset/skills）不注入会话上下文，不列入（用户裁定）。
-//
-// 单个来源、随 DSH 技能之后排列，来源层语义同默认来源（不可移除、无来源开关）。
-const OFFICIAL_SOURCE_KEY = "official";
-/** electron 的 resources 目录；非桌面宿主（web 等普通 node 进程）没有这个属性。 */
-function resourcesDir() {
-    const resources = process.resourcesPath;
-    return typeof resources === "string" && resources !== "" ? resources : null;
-}
-/** 桌面版官方 asar 里的包内目录（同步 fs 对 asar 的支持经过实测可靠）。 */
-function desktopPackageDir(packageName, subpath) {
-    const resources = resourcesDir();
-    if (resources === null)
-        return null;
-    const dir = join(resources, "app.asar", "dsh", "node_modules", ...packageName.split("/"), ...subpath.split("/"));
-    return existsSync(dir) ? dir : null;
-}
-/**
- * 从插件自身的解析链找官方包内目录（web 等非桌面宿主的途径；宿主进程里的裸名
- * 解析由官方模块拦截器路由到宿主副本）。包不可解析（旧宿主 / 单测环境）返回 null。
- */
-function resolvedPackageDir(packageName, subpath) {
-    try {
-        const require = createRequire(import.meta.url);
-        let manifest;
-        try {
-            manifest = require.resolve(`${packageName}/package.json`);
-        }
-        catch {
-            // exports 未暴露 ./package.json 的包：从入口文件向上找同名 manifest。
-            manifest = "";
-            let dir = dirname(require.resolve(packageName));
-            for (let i = 0; i < 6; i += 1) {
-                const candidate = join(dir, "package.json");
-                if (existsSync(candidate)) {
-                    manifest = candidate;
-                    break;
-                }
-                const parent = dirname(dir);
-                if (parent === dir)
-                    break;
-                dir = parent;
-            }
-            if (manifest === "")
-                return null;
-        }
-        const dir = join(dirname(manifest), ...subpath.split("/"));
-        return existsSync(dir) ? dir : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * office 技能源头。桌面版由宿主挂载：运行时真实目录优先（官方 assetRoot），其次 asar
- * 包内 assets。web 宿主不装配 office 插件（不注入），但 npm 包自带完整 assets —— 用户
- * 裁定（2026-09-30）技能页照样暴露这三个技能，走宿主进程解析链取包内一份。解析不到
- * 一律 null —— 不把拿不到真实文件的技能凭空列出来。
- */
-function officialOfficeSource() {
-    const resources = resourcesDir();
-    if (resources !== null) {
-        const runtimeDir = join(resources, "runtime", "office-skills");
-        if (existsSync(join(runtimeDir, "office-docx")))
-            return runtimeDir;
-        const asarDir = desktopPackageDir("@deepseek-ai/dsh-skill-office", "assets");
-        if (asarDir !== null && existsSync(join(asarDir, "office-docx")))
-            return asarDir;
-    }
-    return resolvedPackageDir("@deepseek-ai/dsh-skill-office", "assets");
-}
-/** 沙盒诊断技能源头（桌面 asar 直连优先，其次宿主进程解析链；宿主门控仅看 win32，web/桌面皆注入）。 */
-function officialSandboxSource() {
-    if (process.platform !== "win32")
-        return null;
-    return (desktopPackageDir("@deepseek-ai/dsh-sandbox-windows-acl", "assets/diagnose-windows-sandbox-acl") ??
-        resolvedPackageDir("@deepseek-ai/dsh-sandbox-windows-acl", "assets/diagnose-windows-sandbox-acl"));
-}
-// ── office 技能的「Installed LibreOffice Kit」段 ────────────────────────────
-//
-// 官方 dsh-office provider 在 get 时给三个 office 技能的正文**追加**一段
-// 「Installed LibreOffice Kit」：SKILL.md 明文要求「使用这段提供的 libreofficeKit.node
-// 与 .cli 绝对路径，禁止自行搜索/猜测」。我们以 599 接管后官方 provider 不再被问到，
-// 这段必须由我们补上 —— 否则模型拿到的 office 技能缺执行 LibreOffice 命令所需的全部
-// 路径（这个缺口 0.16.5 在桌面上就已存在）。文案与 JSON 形状逐字取自官方
-// dsh-skill-office lib/index.js 的 officeRuntime()；node/cli 的落点按宿主形态各自核实：
-//   - 桌面：官方明确要求 packaged 应用必须给**独立 node**（electron 本体不行）。
-//     实测桌面把运行时装在 `<resources>/runtime/primary-runtime/`（DSH_PRIMARY_RUNTIME
-//     指向它，SDK 部署可被同名环境变量改写），node 在其 dependencies/node/bin 下；cli
-//     必须用 `app.asar.unpacked` 里的真实文件 —— 独立 node 读不了 asar 内部。
-//   - web：官方默认 process.execPath（宿主是普通 node 进程），cli 从宿主进程解析链取。
-// 任一路径不是真实文件 → 用官方口径的「已停用」文案（SKILL.md 自有降级分支，模型不会
-// 去猜路径），绝不给一个跑不起来的路径。
-const OFFICE_SKILL_NAMES = new Set([
-    "office-docx",
-    "office-pptx",
-    "office-xlsx",
-]);
-const OFFICE_RUNTIME_DISABLED = "\n\nLibreOffice Kit is disabled in this deployment.";
-let officeRuntimeSectionCache;
-/** 官方 provider 在 get 时追加的 LibreOffice Kit 段（每进程算一次，路径不随会话变）。 */
-function officialOfficeRuntimeSection() {
-    if (officeRuntimeSectionCache === undefined)
-        officeRuntimeSectionCache = computeOfficeRuntimeSection();
-    return officeRuntimeSectionCache;
-}
-function computeOfficeRuntimeSection() {
-    const resources = resourcesDir();
-    let node;
-    let cli;
-    const runtimeRoot = process.env.DSH_PRIMARY_RUNTIME || process.env.DSH_BUNDLED_PRIMARY_RUNTIME;
-    if (runtimeRoot) {
-        // SDK / 容器部署：官方配置从运行时根推导（cordis 装配逐字核对）。
-        node = join(resolve(runtimeRoot), "dependencies", "node", "bin", process.platform === "win32" ? "node.exe" : "node");
-        cli = resolvedPackageDir("@deepseek-ai/libreoffice-kit", "lib/cli.js");
-    }
-    else if (resources !== null) {
-        node = join(resources, "runtime", "primary-runtime", "dependencies", "node", "bin", process.platform === "win32" ? "node.exe" : "node");
-        // 桌面的 cli 只认 unpacked 真实文件（独立 node 读不了 asar；electron 的 fs 补丁
-        // 会让 existsSync 对 asar 内部也返回真，所以这里不用解析链兜底）。
-        cli = join(resources, "app.asar.unpacked", "dsh", "node_modules", "@deepseek-ai", "libreoffice-kit", "lib", "cli.js");
-    }
-    else {
-        node = process.execPath;
-        cli = resolvedPackageDir("@deepseek-ai/libreoffice-kit", "lib/cli.js");
-    }
-    const usable = (path) => {
-        try {
-            return isAbsolute(path) && statSync(path).isFile();
-        }
-        catch {
-            return false;
-        }
-    };
-    if (!usable(node) || cli === null || !usable(cli))
-        return OFFICE_RUNTIME_DISABLED;
-    return `\n\n## Installed LibreOffice Kit\n\nUse these absolute paths for every LibreOffice Kit command. Pass the CLI entry as the first argument to Node.\n\n${JSON.stringify({ libreofficeKit: { node, cli } }, null, 2)}`;
-}
-function copyDirectorySync(from, to) {
-    mkdirSync(to, { recursive: true });
-    for (const entry of readdirSync(from, { withFileTypes: true })) {
-        const source = join(from, entry.name);
-        const target = join(to, entry.name);
-        if (entry.isDirectory())
-            copyDirectorySync(source, target);
-        else if (entry.isFile())
-            copyFileSync(source, target);
-    }
-}
-/**
- * 物化官方内置技能到插件自有目录，返回该目录；无可用源头或拷贝失败返回 null。
- * 每次宿主启动整目录重建（官方包只随宿主更新变化，宿主更新必然重启宿主）。
- */
-let officialRootCache;
-/** 宿主形态子目录名：桌面（有 process.resourcesPath）与 web 等普通 node 进程各物化一份。 */
-function officialFormName() {
-    return resourcesDir() === null ? "web" : "desktop";
-}
-/**
- * 0.16.5 之前各形态共用一份目录（旧条目直接躺在 official-skills/ 下）；分形态目录后
- * 这些残留只会变成幽灵条目，按这份已知名单清掉。只清名单内的名字，绝不碰旁边的
- * `<form>/` 子目录 —— 那是另一种形态物化的现役目录。
- */
-const LEGACY_OFFICIAL_ENTRY_NAMES = Object.freeze([
-    "office-docx",
-    "office-pptx",
-    "office-xlsx",
-    "scripts",
-    "diagnose-windows-sandbox-acl",
-]);
-function cleanupLegacyOfficialLayout(root) {
-    for (const name of LEGACY_OFFICIAL_ENTRY_NAMES) {
-        try {
-            rmSync(join(root, name), { recursive: true, force: true });
-        }
-        catch {
-            /* 残留清理失败不影响物化，下轮启动再试 */
-        }
-    }
-}
-function materializeOfficialSkills() {
-    const office = officialOfficeSource();
-    const sandbox = officialSandboxSource();
-    if (office === null && sandbox === null)
-        return null;
-    // 每种宿主形态只整目录重建**自己**这份（竞态教训见上方块注释）；对方形态的子目录
-    // 与共享层残留清理互不干涉。
-    const root = join(resolveDshHome(), "tool-management", "official-skills", officialFormName());
-    try {
-        rmSync(root, { recursive: true, force: true });
-        // office：整个 assets 根拷进来（office-*/ 与 scripts/ 的相对结构必须保留 ——
-        // SKILL.md 用 `<skill-directory>/../scripts/check_office.py` 引用检查脚本）。
-        if (office !== null)
-            copyDirectorySync(office, root);
-        if (sandbox !== null) {
-            copyDirectorySync(sandbox, join(root, basename(sandbox)));
-        }
-        cleanupLegacyOfficialLayout(dirname(root));
-        return root;
-    }
-    catch (error) {
-        console.error("[dsh-plugin-tool-management] official skills materialization failed:", String((error && error.message) || error));
-        return null;
-    }
-}
-function officialSkillRoot() {
-    if (officialRootCache !== undefined)
-        return officialRootCache;
-    const dir = materializeOfficialSkills();
-    officialRootCache =
-        dir === null
-            ? null
-            : {
-                key: OFFICIAL_SOURCE_KEY,
-                path: dir,
-                label: "官方内置",
-                localeKey: "official",
-                mutable: false,
-                deletable: false,
-                // 来源层无开关（同默认来源），单个技能可启停；overlay 以 599 压过官方
-                // provider 的 600，脚本从物化副本的真实路径执行。
-                toggleable: true,
-                native: false,
-                scope: "user",
-                rank: 599,
-            };
-    return officialRootCache;
-}
 /**
  * DSH 与外部 Agent 的用户级技能目录（4 个来源；外部来源由 manager provider 接入）。
  *
@@ -317,70 +62,6 @@ function officialSkillRoot() {
  * DSH 之后紧随官方内置来源（随宿主注入会话的内置技能，见 materializeOfficialSkills；
  * 无可用源头时自然缺席）。
  */
-export function userRoots() {
-    const official = officialSkillRoot();
-    return [
-        {
-            key: "dsh",
-            path: join(resolveDshHome(), "skills"),
-            label: "DSH 技能",
-            mutable: true,
-            // 默认来源：路径不可移除、不可停用（必须读取），但里面的技能可删（见 isDefaultSkillSource）。
-            deletable: true,
-            // 注意：`toggleable` 指的是「这个来源里的**单个技能**能否启停」，与来源开关无关 ——
-            // 来源层的启停/移除由 isDefaultSkillSource 判定，两者别混。
-            toggleable: true,
-            native: true,
-            rank: 400,
-        },
-        // 官方内置紧随 DSH 技能之后（用户裁定）：同为一眼要看的来源，排在导入技能之前。
-        ...(official === null ? [] : [official]),
-        {
-            // v0.4：插件**新建/导入**的技能落到 hub 内（用户要求：插件产生的文件收在
-            // $DSH_HOME/tool-management/）。rank 高于 DSH 技能，同名时 hub 版本遮蔽官方目录里的；
-            // 官方 ~/.dsh/skills/ 仍作为可切换来源列出（不搬走、不删）。
-            //
-            // 界面名「导入技能」：它是插件导入/新建技能的落点，不是"管理器自己的一类技能"。
-            // 与 dsh 同为默认来源：路径必须读取（不可移除、不可停用），里面的技能可删。
-            key: "hub",
-            path: join(resolveDshHome(), "tool-management", "skills"),
-            label: "导入技能",
-            localeKey: "hub",
-            mutable: true,
-            deletable: true,
-            toggleable: true,
-            native: false,
-            rank: 350,
-        },
-        {
-            key: "agents",
-            path: join(resolveAgentsHome(), "skills"),
-            label: "公共 Agent",
-            mutable: false,
-            toggleable: true,
-            native: true,
-            rank: 450,
-        },
-        {
-            key: "codex",
-            path: join(process.env.DSH_CODEX_HOME || join(homedir(), ".codex"), "skills"),
-            label: "Codex",
-            mutable: false,
-            toggleable: true,
-            native: false,
-            rank: 520,
-        },
-        {
-            key: "claude",
-            path: join(process.env.DSH_CLAUDE_HOME || join(homedir(), ".claude"), "skills"),
-            label: "Claude",
-            mutable: false,
-            toggleable: true,
-            native: false,
-            rank: 530,
-        },
-    ];
-}
 /**
  * 默认来源：插件自己的读写根 —— `dsh`（官方技能目录）与 `hub`（新建/导入落点）。
  *
@@ -396,18 +77,7 @@ export function userRoots() {
  *
  * 一句话记法：**`mutable` 与 `deletable` 同向，`removable` 与 `mutable` 反向。**
  */
-const DEFAULT_SOURCE_KEYS = Object.freeze(["dsh", "hub", OFFICIAL_SOURCE_KEY]);
 /** 是否为默认来源。接受 root 对象或 key 字符串；`dsh` / `hub` / `official` 的所有特判都走这里。 */
-export function isDefaultSkillSource(rootOrKey) {
-    const key = rootOrKey && typeof rootOrKey === "object"
-        ? rootOrKey.key
-        : rootOrKey;
-    return DEFAULT_SOURCE_KEYS.includes(key);
-}
-function projectIdentity(path) {
-    const canonical = pathIdentity(path);
-    return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
-}
 // ── 自定义技能目录（用户在管理页添加的任意只读来源）─────────────────────────
 //
 // 存储在 manager 状态文件的 customRoots 数组：{ key, path, label? }。
@@ -416,41 +86,7 @@ function projectIdentity(path) {
 // 通道），启停走 sources 全局开关，停用某个技能走 disabledSkills 策略，
 // 均不改源文件。
 /** 由目录路径派生稳定的自定义来源 key。 */
-export function customRootKey(path) {
-    return "custom-" + projectIdentity(path);
-}
 /** 从状态值解析自定义来源定义；非法条目静默丢弃，key 与 path 不匹配的不信任。 */
-export function customRootsFromState(stateValue) {
-    const state = stateValue;
-    const list = state && Array.isArray(state.customRoots) ? state.customRoots : [];
-    const out = [];
-    for (const item of list) {
-        if (!item || typeof item !== "object")
-            continue;
-        const path = typeof item.path === "string" ? item.path : "";
-        const key = typeof item.key === "string" ? item.key : "";
-        if (!isAbsolute(path) || !CUSTOM_ROOT_KEY_RE.test(key))
-            continue;
-        if (key !== customRootKey(path))
-            continue;
-        out.push({
-            key,
-            path,
-            label: typeof item.label === "string" && item.label.trim()
-                ? item.label.trim().slice(0, 64)
-                : "自定义目录",
-            // 用户加进来的来源（相对「按约定发现」的 dsh / hub / agents / codex / claude）：
-            // 界面据此决定要不要给「永久删除」——只有自定义来源能真正从插件里删掉记录。
-            custom: true,
-            mutable: false,
-            toggleable: true,
-            native: false,
-            scope: "user",
-            rank: 600,
-        });
-    }
-    return out;
-}
 /**
  * 添加自定义技能目录：要求绝对路径、真实存在的目录、与任何已知来源
  * （用户根 + 现有自定义根）不重叠——重叠来源会绕过停用策略。
@@ -553,140 +189,11 @@ export async function removeCustomRoot(key, log) {
         log("custom-remove", `移除自定义技能目录 ${target.path} (${clean})`);
     return { key: clean, path: target.path };
 }
-async function nearestProjectRoot(cwd) {
-    if (typeof cwd !== "string" || !isAbsolute(cwd))
-        return null;
-    let start;
-    try {
-        start = await fs.realpath(resolve(cwd));
-        if (!(await fs.stat(start)).isDirectory())
-            return null;
-    }
-    catch (error) {
-        // 目录不存在（会话还开着、项目已被删）是最常见的一类：带上系统错误码，
-        // 调用方对 ENOENT 静默跳过 —— 报警留给真正读不了的目录。
-        const code = error && typeof error === "object" && "code" in error
-            ? String(error.code)
-            : undefined;
-        return { unavailable: true, cwd, ...(code ? { code } : {}) };
-    }
-    let current = start;
-    for (;;) {
-        try {
-            await fs.lstat(join(current, ".git"));
-            return { root: current, cwd: start };
-        }
-        catch {
-            /* 继续向上查找最近的项目根 */
-        }
-        const parent = dirname(current);
-        if (parent === current)
-            return null;
-        current = parent;
-    }
-}
-async function projectSourceSafe(definition) {
-    // 只读来源允许目录链接，但重叠来源会绕过用户根的停用策略。
-    if (definition.kind === "project-agents")
-        return !(await overlapsUserSkillRoot(definition.path));
-    const container = join(definition.projectRoot, definition.kind === "project-dsh" ? ".dsh" : ".agents");
-    for (const path of [container, definition.path]) {
-        const st = await lstatOrNull(path);
-        if (st && (!st.isDirectory() || st.isSymbolicLink()))
-            return false;
-    }
-    return !(await overlapsUserSkillRoot(definition.path));
-}
 /**
  * 从活动 Session cwd 推导项目技能根。只接受宿主上可解析的绝对目录，
  * 同一项目的多个 Session 会折叠到同一组稳定 key，避免跨 workspace 合并同名技能。
  */
-export async function projectRoots(projectCwds = [], diagnostics) {
-    const projects = new Map();
-    for (const cwd of Array.isArray(projectCwds) ? projectCwds : []) {
-        const found = await nearestProjectRoot(cwd);
-        if (!found || !found.root) {
-            // 目录不存在（ENOENT）= 会话开着、项目已删：这是常态而不是故障，静默跳过。
-            // 报警只留给真实读不了的目录（权限、损坏的链接等）。
-            if (found && found.unavailable && found.code === "ENOENT")
-                continue;
-            if (found &&
-                found.unavailable &&
-                Array.isArray(diagnostics) &&
-                typeof cwd === "string" &&
-                isAbsolute(cwd)) {
-                diagnostics.push({
-                    code: "warning.project.unavailable",
-                    params: { path: cwd },
-                    error: `活动会话的项目目录不可访问，项目技能未显示: ${cwd}`,
-                });
-            }
-            continue;
-        }
-        const identity = pathIdentity(found.root);
-        const existing = projects.get(identity) || {
-            root: found.root,
-            cwds: new Set(),
-        };
-        existing.cwds.add(found.cwd);
-        projects.set(identity, existing);
-    }
-    const roots = [];
-    for (const project of [...projects.values()].sort((a, b) => a.root.localeCompare(b.root))) {
-        const id = projectIdentity(project.root);
-        const common = {
-            mutable: false,
-            // 未知/只读来源（外部 Agent 与自定义绝对路径）一律不可删；用户级 dsh / hub
-            // 与本仓库的项目级 .dsh/skills 都是可删的（见上方两处 `deletable: true`）。
-            deletable: false,
-            toggleable: false,
-            native: true,
-            scope: "project",
-            projectRoot: project.root,
-            projectName: basename(project.root) || project.root,
-            workspaceCwds: [...project.cwds].sort(),
-        };
-        const candidates = [
-            {
-                ...common,
-                key: `project-dsh:${id}`,
-                kind: "project-dsh",
-                localeKey: "projectDsh",
-                path: join(project.root, ".dsh", "skills"),
-                label: "Project DSH",
-                rank: 100,
-                mutable: true,
-                deletable: true,
-                toggleable: true,
-            },
-            {
-                ...common,
-                key: `project-agents:${id}`,
-                kind: "project-agents",
-                localeKey: "projectAgents",
-                path: join(project.root, ".agents", "skills"),
-                label: "Project Agent",
-                rank: 200,
-                toggleable: true,
-            },
-        ];
-        for (const candidate of candidates) {
-            if (await projectSourceSafe(candidate))
-                roots.push(candidate);
-        }
-    }
-    return roots;
-}
-export function managerHomePath() {
-    return join(resolveDshHome(), "tool-management");
-}
-export function managerStatePath() {
-    return join(managerHomePath(), "skills-state.json");
-}
 /** 技能回收站：与其余四类同形（`hub/trash/<域>-trash/`）。 */
-export function trashRootPath() {
-    return join(managerHomePath(), "trash", "skills-trash");
-}
 /** 插件日志（滚动 `.1`）：收在 hub 内，不再躺在 `$DSH_HOME` 根下。 */
 export function logPath() {
     return join(managerHomePath(), "tool-management.log");
@@ -788,29 +295,11 @@ export async function browseDirectories(inputPath) {
     }
     return { path: canonical, home: homedir(), crumbs, entries, truncated };
 }
-function dshRootPath() {
-    // userRoots() 恒含 dsh 来源（见上方列表），断言只为让类型收敛。
-    return userRoots().find((root) => root.key === "dsh").path;
-}
 /**
  * v0.4 新建/导入技能的落点：hub 内 `tool-management/skills/`（用户要求插件产物集中）。
  * hub 根缺失（旧版本状态文件/异常）时退回官方 DSH 技能目录，保证创建功能永不因布局变化而失效。
  */
-function skillCreateRootPath() {
-    const hub = userRoots().find((root) => root.key === "hub");
-    return hub && hub.path ? hub.path : dshRootPath();
-}
 /** 只读来源的拒绝结果；action 为可翻译语义值（toggle/delete）。 */
-function readonlyError(action) {
-    return {
-        ok: false,
-        code: "error.root.readonly",
-        params: { action },
-        error: action === "delete"
-            ? "该技能来源不允许删除"
-            : "该技能来源不允许启用或停用",
-    };
-}
 /**
  * 来源可写但**没有删除权**时的拒绝结果 —— 防御性分支。
  *
@@ -849,332 +338,16 @@ function reservedSourceError(root) {
         error: `${origin}：不能停用或移除（里面的技能可以删除）`,
     };
 }
-function rootDefinition(root) {
-    if (root && typeof root === "object" && typeof root.key === "string")
-        return root;
-    if (typeof root !== "string")
-        return null;
-    const resolved = resolve(root);
-    return userRoots().find((item) => resolve(item.path) === resolved) || null;
-}
-function rootByKey(key) {
-    return userRoots().find((item) => item.key === key) || null;
-}
 /** 只允许用户 DSH 根 / hub 根，或由活动 Session 推导出的项目 DSH 根参与文件写入。 */
-function writableRootDefinition(root) {
-    const definition = rootDefinition(root);
-    if (!definition || definition.mutable !== true)
-        return null;
-    if (definition.key === "dsh")
-        return resolve(definition.path) === resolve(dshRootPath())
-            ? rootByKey("dsh")
-            : null;
-    // v0.4：hub 内技能目录同为用户级可写根（插件新建/导入的落点）。
-    if (definition.key === "hub")
-        return resolve(definition.path) === resolve(skillCreateRootPath())
-            ? rootByKey("hub")
-            : null;
-    if (definition.scope !== "project" ||
-        definition.kind !== "project-dsh" ||
-        typeof definition.projectRoot !== "string" ||
-        !isAbsolute(definition.projectRoot) ||
-        definition.key !==
-            `project-dsh:${projectIdentity(definition.projectRoot)}` ||
-        resolve(definition.path) !==
-            resolve(join(definition.projectRoot, ".dsh", "skills")))
-        return null;
-    return definition;
-}
-async function checkedWritableRootDefinition(root) {
-    const definition = writableRootDefinition(root);
-    if (!definition || definition.scope !== "project")
-        return definition;
-    if (await overlapsUserSkillRoot(definition.path)) {
-        return {
-            ok: false,
-            error: `项目技能目录与用户技能目录重叠，拒绝写入: ${definition.path}`,
-            code: "error.root.unsafe",
-            params: { path: definition.path },
-        };
-    }
-    // 项目仓库内容不可信；拒绝通过 .dsh 或 skills 链接把写入重定向到项目之外。
-    // definition.scope === "project" 时 projectRoot 必有值（见 ProjectSource），断言只为让类型收敛。
-    for (const path of [
-        join(definition.projectRoot, ".dsh"),
-        definition.path,
-    ]) {
-        const st = await lstatOrNull(path);
-        if (st && (!st.isDirectory() || st.isSymbolicLink())) {
-            return {
-                ok: false,
-                error: `项目技能目录不安全，拒绝写入: ${path}`,
-                code: "error.root.unsafe",
-                params: { path },
-            };
-        }
-    }
-    return definition;
-}
 /** 解析真实路径；中间若有目录链接，按落地目录比较重叠。 */
-async function resolvedPath(path) {
-    try {
-        return await fs.realpath(path);
-    }
-    catch {
-        return resolve(path);
-    }
-}
 /** 即使末级路径尚不存在，也解析最近既存祖先中的链接，供权限域重叠判断。 */
-async function comparisonPath(path) {
-    let current = resolve(path);
-    const missing = [];
-    for (;;) {
-        try {
-            return resolve(await fs.realpath(current), ...missing);
-        }
-        catch {
-            const parent = dirname(current);
-            if (parent === current)
-                return resolve(path);
-            missing.unshift(basename(current));
-            current = parent;
-        }
-    }
-}
-async function overlapsUserSkillRoot(path) {
-    const candidate = await comparisonPath(path);
-    for (const root of userRoots()) {
-        const userPath = await comparisonPath(root.path);
-        if (isSameOrDescendant(candidate, userPath) ||
-            isSameOrDescendant(userPath, candidate))
-            return true;
-    }
-    return false;
-}
 /** 两个路径重叠时，覆盖导入可能删除自身来源，必须拒绝。 */
-async function pathsOverlap(a, b) {
-    const left = await resolvedPath(a);
-    const right = await resolvedPath(b);
-    return isSameOrDescendant(left, right) || isSameOrDescendant(right, left);
-}
 /** 预解析技能根后的根内校验，供逐条目扫描复用同一次 realpath，减少重复 IO。 */
-async function isInsideResolvedRoot(rootReal, path) {
-    return isSameOrDescendant(rootReal, await resolvedPath(path));
-}
-function pathIdentity(path) {
-    const canonical = resolve(path);
-    return process.platform === "win32" ? canonical.toLowerCase() : canonical;
-}
-async function lstatOrNull(path) {
-    try {
-        return await fs.lstat(path);
-    }
-    catch {
-        return null;
-    }
-}
-/** 名称只允许一个普通路径段；不把既有技能名称限制为 kebab-case。 */
-export function entryPath(root, name) {
-    // 段名谓词收敛到 paths.js（此前与 rules / subagents / imports 各写一套，口径不一）。
-    // 原实现里 `basename(name) !== name` 那条已被谓词的「不含路径分隔符」覆盖。
-    if (!isValidSegment(name, MAX_ENTRY_NAME_LENGTH))
-        return null;
-    const rootPath = resolve(root);
-    const path = resolve(rootPath, name);
-    return isSameOrDescendant(rootPath, path) && rootPath !== path ? path : null;
-}
 function isDshRoot(root) {
     return typeof root === "string" && resolve(root) === resolve(dshRootPath());
 }
-// ── 命名规整 ────────────────────────────────────────────────────────────────
-/** 尽量把任意名称规整为 kebab-case；无法生成合法名称时返回空串。 */
-export function toKebab(s) {
-    let t = String(s).trim();
-    if (t === "")
-        return "";
-    t = t.replace(/([a-z0-9])([A-Z])/g, "$1-$2"); // camelCase 边界
-    t = t.toLowerCase();
-    t = t.replace(/[\s_.]+/g, "-");
-    t = t.replace(/[^a-z0-9-]/g, "-");
-    t = t.replace(/-+/g, "-").replace(/^-+|-+$/g, "");
-    return t;
-}
-// ── frontmatter 解析 / 序列化（宽松 YAML 对象，保留键序）────────────────────
-/** 剥离 UTF-8 BOM（Windows 工具常写入，不剥离会导致开头 --- 失配）。 */
-function stripBom(text) {
-    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
-}
-/** 解析 SKILL.md 的 frontmatter。返回 { fields, map, body }，map 保留键序。
- *  只识别顶层 key: value；缩进嵌套字段（如 metadata.source）不进入 map。 */
-export function parseSkillDoc(text) {
-    const src = stripBom(String(text));
-    const lines = src.split(/\r?\n/);
-    const map = Object.create(null);
-    const fields = [];
-    let body = src;
-    let hasFrontmatter = false;
-    if (lines.length > 0 && lines[0].trim() === "---") {
-        let end = -1;
-        for (let i = 1; i < lines.length; i++) {
-            if (lines[i].trim() === "---") {
-                end = i;
-                break;
-            }
-        }
-        if (end >= 0) {
-            hasFrontmatter = true;
-            for (let i = 1; i < end; i++) {
-                const m = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(lines[i]);
-                if (m) {
-                    fields.push({ key: m[1], raw: m[2] });
-                    const block = /^([>|])[-+]?\s*$/.exec(m[2]);
-                    if (block) {
-                        const content = [];
-                        while (i + 1 < end &&
-                            (/^\s/.test(lines[i + 1]) || lines[i + 1] === "")) {
-                            i++;
-                            content.push(lines[i]);
-                        }
-                        const indentation = content
-                            .filter((line) => line.trim() !== "")
-                            .reduce((min, line) => Math.min(min, (/^\s*/.exec(line) || [""])[0].length), Infinity);
-                        const normalized = content.map((line) => Number.isFinite(indentation)
-                            ? line.slice(Math.min(indentation, line.length))
-                            : line);
-                        map[m[1]] =
-                            block[1] === ">"
-                                ? normalized.join(" ").replace(/\s+/g, " ").trim()
-                                : normalized.join("\n").trim();
-                    }
-                    else {
-                        map[m[1]] = decodeYamlScalar(m[2]);
-                    }
-                }
-            }
-            body = lines.slice(end + 1).join("\n");
-        }
-    }
-    return { fields, map, body, hasFrontmatter };
-}
-/** 读取 YAML 标量的显示值；不依赖第三方 YAML 解析器。 */
-function decodeYamlScalar(v) {
-    const s = String(v == null ? "" : v).trim();
-    if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') {
-        try {
-            const value = JSON.parse(s);
-            if (typeof value === "string")
-                return value;
-        }
-        catch {
-            /* 保留无法解析的原始内容 */
-        }
-    }
-    if (s.length >= 2 && s[0] === "'" && s[s.length - 1] === "'")
-        return s.slice(1, -1).replace(/''/g, "'");
-    return s;
-}
-export function unquote(v) {
-    const s = String(v == null ? "" : v).trim();
-    if (s.length >= 2 &&
-        ((s[0] === '"' && s[s.length - 1] === '"') ||
-            (s[0] === "'" && s[s.length - 1] === "'"))) {
-        return s.slice(1, -1);
-    }
-    return s;
-}
-/** 同目录临时文件加 rename，避免写入中断时截断原 SKILL.md。 */
-/** Windows 上杀毒软件或索引器可能短暂占用目录；只重试明确可恢复的 rename 错误。 */
-export async function renameWithRetry(source, destination, options = {}) {
-    const rename = typeof options.rename === "function" ? options.rename : fs.rename;
-    // Number.isInteger/isFinite 不收窄类型，故断言成 number 以保持既有比较表达式。
-    const maxAttempts = Number.isInteger(options.maxAttempts) && options.maxAttempts > 0
-        ? options.maxAttempts
-        : 6;
-    const delayMs = Number.isFinite(options.delayMs) && options.delayMs >= 0
-        ? options.delayMs
-        : 40;
-    for (let attempt = 1;; attempt++) {
-        try {
-            return await rename(source, destination);
-        }
-        catch (error) {
-            // 系统 rename 异常按可选 code 读取，保持既有重试判定。
-            if (!TRANSIENT_RENAME_CODES.has(error && error.code) ||
-                attempt >= maxAttempts)
-                throw error;
-            await new Promise((resolvePromise) => setTimeout(resolvePromise, delayMs * attempt));
-        }
-    }
-}
-async function removeMovedPath(path) {
-    const st = await lstatOrNull(path);
-    if (!st)
-        return;
-    if (st.isDirectory() && !st.isSymbolicLink())
-        await fs.rm(path, { recursive: true, force: false });
-    else
-        await fs.unlink(path);
-}
 /** rename 跨盘返回 EXDEV 时：先完整复制，再在源盘原子隐藏源条目，最后清理隐藏副本。 */
-async function movePathWithFallback(source, destination, options = {}) {
-    try {
-        await renameWithRetry(source, destination, options);
-        return { copied: false, cleanupError: null };
-    }
-    catch (error) {
-        // 系统异常按可选 code 读取，保持既有 EXDEV 判定。
-        if (!error || error.code !== "EXDEV")
-            throw error;
-    }
-    const quarantine = join(dirname(source), `.${basename(source)}.dssm-move-${randomUUID()}`);
-    try {
-        await fs.cp(source, destination, {
-            recursive: true,
-            dereference: false,
-            errorOnExist: true,
-            force: false,
-            verbatimSymlinks: true,
-        });
-        // 源与 quarantine 位于同一目录；成功后原技能名立即消失，避免递归删除留下半份可见条目。
-        await renameWithRetry(source, quarantine, options);
-    }
-    catch (error) {
-        await removeMovedPath(destination).catch(() => undefined);
-        throw error;
-    }
-    let cleanupError = null;
-    try {
-        await removeMovedPath(quarantine);
-    }
-    catch (error) {
-        // 调用方按可选 message 读取该清理异常，保持既有告警文案。
-        cleanupError = error;
-    }
-    return { copied: true, cleanupError, quarantine };
-}
-async function writeFileAtomically(path, content) {
-    const temp = join(dirname(path), `.${basename(path)}.dssm-${randomUUID()}.tmp`);
-    try {
-        await fs.writeFile(temp, content, "utf8");
-        // Windows 上目标文件会被杀软/索引器短暂占住（EPERM/EACCES/EBUSY）——
-        // 场景模式进出时这里写的是技能来源/策略状态，rename 被撞 = 运行时已切、
-        // 状态没落盘。与 memories-index.json 同一处理：重试瞬时占用，全失败才抛。
-        await renameWithRetry(temp, path);
-    }
-    catch (error) {
-        await fs.rm(temp, { force: true }).catch(() => undefined);
-        throw error;
-    }
-}
 /** 解析布尔字段值；合法布尔返回 true/false，非法返回 undefined。 */
-export function parseBoolValue(raw) {
-    const v = unquote(raw).trim().toLowerCase();
-    if (v === "true" || v === "yes" || v === "on" || v === "1")
-        return true;
-    if (v === "false" || v === "no" || v === "off" || v === "0")
-        return false;
-    return undefined;
-}
 // ── 条目定位 / 扫描 ─────────────────────────────────────────────────────────
 /** 按名称解析条目（bundle 优先，其次 flat）。找不到返回 null。 */
 export async function resolveEntry(root, name) {
@@ -1240,175 +413,8 @@ export async function resolveEntry(root, name) {
         return null;
     }
 }
-function entryOf(name, kind, docPath, doc) {
-    const declaredName = doc.map.name !== undefined ? unquote(doc.map.name) : "";
-    const description = doc.map.description !== undefined ? unquote(doc.map.description) : "";
-    const modelValue = parseBoolValue(doc.map["disable-model-invocation"]);
-    const userValue = parseBoolValue(doc.map["user-invocable"]);
-    const modelDisabled = modelValue === true;
-    const userDisabled = userValue === false;
-    const invocationPolicyValid = (doc.map["disable-model-invocation"] === undefined ||
-        modelValue !== undefined) &&
-        (doc.map["user-invocable"] === undefined || userValue !== undefined);
-    const diagnostics = [];
-    if (!doc.hasFrontmatter)
-        diagnostics.push({
-            level: "error",
-            code: "diagnostic.frontmatter.missing",
-        });
-    if (doc.hasFrontmatter && !declaredName)
-        diagnostics.push({ level: "error", code: "diagnostic.name.missing" });
-    else if (declaredName && !KEBAB_RE.test(declaredName))
-        diagnostics.push({
-            level: "error",
-            code: "diagnostic.name.invalid",
-            params: { name: declaredName },
-        });
-    if (doc.hasFrontmatter && !description)
-        diagnostics.push({
-            level: "error",
-            code: "diagnostic.description.missing",
-        });
-    if (!invocationPolicyValid)
-        diagnostics.push({ level: "error", code: "diagnostic.invocation.invalid" });
-    return {
-        name,
-        declaredName,
-        kind,
-        docPath,
-        description,
-        modelInvocable: !modelDisabled,
-        userInvocable: !userDisabled,
-        invocationPolicyValid,
-        hasFrontmatter: doc.hasFrontmatter,
-        // 调用策略值异常可以由 manager 本地策略覆盖；结构本身合法即可加载。
-        loadable: doc.hasFrontmatter && KEBAB_RE.test(declaredName) && description !== "",
-        diagnostics,
-    };
-}
 /** 只读来源递归发现；可写 DSH 根维持顶层扫描及链接写边界。 */
-export async function scanEntries(root, options = {}) {
-    const definition = rootDefinition(root);
-    if (definition && !definition.mutable) {
-        const discovered = await discoverReadonlyEntries(definition.path);
-        // metadataOnly 时条目的摘要字段由调用方按需读取（见 visibleEntryForRoot）。
-        if (options.metadataOnly)
-            return discovered;
-        const entries = [];
-        for (const entry of discovered.entries) {
-            try {
-                entries.push({
-                    ...entryOf(entry.name, entry.kind, entry.docPath, parseSkillDoc(await fs.readFile(entry.realDocPath, "utf8"))),
-                    ...entry,
-                });
-            }
-            catch {
-                /* 忽略已失效或不可读技能。 */
-            }
-        }
-        return { ...discovered, entries };
-    }
-    // 传入 definition 对象时取它的 path；其余情况按 key 字符串处理。
-    root = definition ? definition.path : root;
-    const rootStat = await lstatOrNull(resolve(root));
-    if (!rootStat || !rootStat.isDirectory() || rootStat.isSymbolicLink())
-        return { exists: false, entries: [] };
-    let items;
-    try {
-        items = await fs.readdir(root, { withFileTypes: true });
-    }
-    catch {
-        return { exists: false, entries: [] };
-    }
-    const byName = new Map();
-    const rootReal = await resolvedPath(root);
-    for (const it of items) {
-        try {
-            if (it.isSymbolicLink())
-                continue;
-            if (it.isDirectory() && entryPath(root, it.name) !== null) {
-                const docPath = join(root, it.name, "SKILL.md");
-                const st = await lstatOrNull(docPath);
-                if (!st ||
-                    !st.isFile() ||
-                    st.isSymbolicLink() ||
-                    !(await isInsideResolvedRoot(rootReal, docPath)))
-                    continue;
-                const doc = options.metadataOnly
-                    ? { map: {}, hasFrontmatter: false }
-                    : parseSkillDoc(await fs.readFile(docPath, "utf8"));
-                byName.set(it.name, {
-                    ...entryOf(it.name, "bundle", docPath, doc),
-                    entryPath: join(root, it.name),
-                    realDocPath: await fs.realpath(docPath),
-                    realEntryPath: await fs.realpath(join(root, it.name)),
-                    linked: false,
-                });
-            }
-            else if (it.isFile() &&
-                it.name.toLowerCase().endsWith(".md") &&
-                it.name.toLowerCase() !== "skill.md" &&
-                entryPath(root, it.name.slice(0, -3)) !== null) {
-                const skillName = it.name.slice(0, -3);
-                if (byName.has(skillName))
-                    continue;
-                const docPath = join(root, it.name);
-                if (!(await isInsideResolvedRoot(rootReal, docPath)))
-                    continue;
-                const doc = options.metadataOnly
-                    ? { map: {}, hasFrontmatter: false }
-                    : parseSkillDoc(await fs.readFile(docPath, "utf8"));
-                const realDocPath = await fs.realpath(docPath);
-                byName.set(skillName, {
-                    ...entryOf(skillName, "flat", docPath, doc),
-                    entryPath: docPath,
-                    realDocPath,
-                    realEntryPath: realDocPath,
-                    linked: false,
-                });
-            }
-        }
-        catch {
-            /* 跳过不可读条目 */
-        }
-    }
-    const entries = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-    return { exists: true, entries };
-}
 /** 同一真实技能优先归属直接 SSOT；同类条目再按来源 rank 决胜。 */
-async function scanDeduplicatedRoots(roots = userRoots(), options = {}) {
-    const results = await Promise.all(roots.map(async (root) => [
-        root,
-        await scanEntries(root, options),
-    ]));
-    const scans = new Map();
-    const groups = new Map();
-    for (const [root, scan] of results) {
-        scans.set(root.key, scan);
-        for (const entry of scan.entries) {
-            const identity = pathIdentity(entry.realEntryPath || entry.entryPath || entry.docPath);
-            const group = groups.get(identity) || [];
-            group.push({ root, entry });
-            groups.set(identity, group);
-        }
-    }
-    const winners = new Set();
-    for (const group of groups.values()) {
-        group.sort((left, right) => Number(left.entry.linked) - Number(right.entry.linked) ||
-            left.root.rank - right.root.rank);
-        const winner = group[0];
-        winner.entry.providerRank = Math.min(...group.map((item) => item.root.rank));
-        winner.entry.policyAliases = group.map((item) => ({
-            rootKey: item.root.key,
-            name: item.entry.name,
-        }));
-        winners.add(winner.entry);
-    }
-    for (const scan of scans.values()) {
-        scan.entries = scan.entries.filter((entry) => winners.has(entry));
-    }
-    return scans;
-}
 /** 详情与列表共享路径去重，扫描定位信息时不读取无关技能正文。 */
 async function visibleEntryForRoot(root, name) {
     if (!validDiscoveryName(name))
@@ -1421,195 +427,12 @@ async function visibleEntryForRoot(root, name) {
     return (scans.get(root.key)?.entries.find((entry) => entry.name === name) || null);
 }
 // ── Manager 本地策略（外部源只读，启停状态写入 DSH_HOME）────────────────────
-function defaultManagerState() {
-    const sources = Object.create(null);
-    const disabledSkills = Object.create(null);
-    const enabledSkills = Object.create(null);
-    for (const root of userRoots()) {
-        // 默认来源（dsh / hub）没有来源开关，所以不落进 sources 表 —— 它们永远「读取」。
-        // 旧版本可能往这里写过 hub 的 false，normalizeManagerState 会顺手丢掉。
-        if (!isDefaultSkillSource(root.key))
-            sources[root.key] = true;
-        disabledSkills[root.key] = [];
-        enabledSkills[root.key] = [];
-    }
-    return {
-        version: 1,
-        sources,
-        disabledSkills,
-        enabledSkills,
-        customRoots: [],
-        // 同名技能「首选来源」：技能名 → 来源 key。缺键 = 按来源 rank 取最高优先级者。
-        preferredSkills: Object.create(null),
-        // 用户从技能页「移除」的来源：插件**不再读取**这些目录（技能不出现在列表里，
-        // 也不参与 provider 候选）。与「停用来源」不同——停用仍列出技能、只是不可调用。
-        // 源文件一个字节都不动；清空这个数组即可恢复。
-        removedSources: [],
-    };
-}
-function validStateSkillName(name) {
-    return validDiscoveryName(name);
-}
 /**
  * 首选表的键是技能**声明名**（不是文件名）——声明名允许大小写与空格（此时技能本身带
  * name.invalid 诊断，但仍可被选择）。这里只做「能当 JSON 键、不像路径」的宽松校验，
  * 避免一个脏键把整份状态文件判为非法（那会让全部技能 fail-closed 停用）。
  */
-function validPreferredSkillName(name) {
-    return (typeof name === "string" &&
-        name.length > 0 &&
-        name.length <= MAX_ENTRY_NAME_LENGTH &&
-        !name.includes("\0") &&
-        !name.includes("/") &&
-        !name.includes("\\"));
-}
 /** 状态文件已存在但不可用时一律关闭外部来源，避免损坏配置重新暴露技能。 */
-function failClosedManagerState() {
-    const state = defaultManagerState();
-    for (const key of Object.keys(state.sources))
-        state.sources[key] = false;
-    return state;
-}
-function validPolicyLists(value, allowMissing = false) {
-    if (value === undefined && allowMissing)
-        return true;
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    for (const [key, list] of Object.entries(value)) {
-        if (!userRoots().some((root) => root.key === key) &&
-            !PROJECT_ROOT_KEY_RE.test(key))
-            continue;
-        if (!Array.isArray(list) || list.some((name) => !validStateSkillName(name)))
-            return false;
-    }
-    return true;
-}
-function validManagerStateDocument(value) {
-    if (!value ||
-        typeof value !== "object" ||
-        Array.isArray(value) ||
-        value.version !== 1)
-        return false;
-    if (!value.sources ||
-        typeof value.sources !== "object" ||
-        Array.isArray(value.sources))
-        return false;
-    if (!validPolicyLists(value.disabledSkills) ||
-        !validPolicyLists(value.enabledSkills, true))
-        return false;
-    // 自定义来源列表：可选字段；容器必须是数组（条目级合法性由 normalize 逐条裁剪）。
-    if (value.customRoots !== undefined && !Array.isArray(value.customRoots))
-        return false;
-    // 已移除的来源：可选字段；数组里的每一项必须能当来源 key 用。
-    if (value.removedSources !== undefined) {
-        if (!Array.isArray(value.removedSources) ||
-            value.removedSources.some((key) => typeof key !== "string" || key.length === 0 || key.length > 128))
-            return false;
-    }
-    // 同名首选表：可选字段；只校验容器与值类型，键值逐条在 normalize 里裁剪（见 validPreferredSkillName）。
-    if (value.preferredSkills !== undefined) {
-        if (!value.preferredSkills ||
-            typeof value.preferredSkills !== "object" ||
-            Array.isArray(value.preferredSkills))
-            return false;
-        for (const key of Object.values(value.preferredSkills))
-            if (typeof key !== "string")
-                return false;
-    }
-    for (const root of userRoots()) {
-        if (isDefaultSkillSource(root.key))
-            continue;
-        if (typeof value.sources[root.key] !== "boolean")
-            return false;
-        const list = value.disabledSkills[root.key];
-        if (!Array.isArray(list) || list.some((name) => !validStateSkillName(name)))
-            return false;
-    }
-    const enabledSkills = value.enabledSkills || {};
-    for (const key of new Set([
-        ...Object.keys(value.disabledSkills),
-        ...Object.keys(enabledSkills),
-    ])) {
-        const disabled = new Set(value.disabledSkills[key] || []);
-        if ((enabledSkills[key] || []).some((name) => disabled.has(name)))
-            return false;
-    }
-    return true;
-}
-function normalizeManagerState(value) {
-    const normalized = defaultManagerState();
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return normalized;
-    // 自定义来源先归一，其 sources/policy 键才有归属。
-    normalized.customRoots = normalizeCustomRoots(value.customRoots);
-    const customKeys = new Set(normalized.customRoots.map((root) => root.key));
-    for (const root of userRoots()) {
-        // 默认来源不接收 sources 标志：旧版本写过的 `sources.hub = false` 在这里被丢弃，
-        // 于是「曾经把 hub 停用掉」的用户升级后自动回到必须读取的状态（技能不丢，只是策略位作废）。
-        if (!isDefaultSkillSource(root.key) &&
-            value.sources &&
-            typeof value.sources[root.key] === "boolean")
-            normalized.sources[root.key] = value.sources[root.key];
-        const list = value.disabledSkills && value.disabledSkills[root.key];
-        if (Array.isArray(list))
-            normalized.disabledSkills[root.key] = [
-                ...new Set(list.filter((name) => validStateSkillName(name))),
-            ].sort();
-        const enabled = value.enabledSkills && value.enabledSkills[root.key];
-        if (Array.isArray(enabled))
-            normalized.enabledSkills[root.key] = [
-                ...new Set(enabled.filter((name) => validStateSkillName(name))),
-            ].sort();
-    }
-    if (value.sources && typeof value.sources === "object" && !Array.isArray(value.sources)) {
-        for (const [key, flag] of Object.entries(value.sources)) {
-            if (customKeys.has(key) && typeof flag === "boolean")
-                normalized.sources[key] = flag;
-        }
-    }
-    for (const field of ["disabledSkills", "enabledSkills"]) {
-        const source = value[field];
-        if (source && typeof source === "object" && !Array.isArray(source)) {
-            for (const [key, list] of Object.entries(source)) {
-                if (!PROJECT_ROOT_KEY_RE.test(key) && !customKeys.has(key))
-                    continue;
-                if (!Array.isArray(list))
-                    continue;
-                normalized[field][key] = [
-                    ...new Set(list.filter(validStateSkillName)),
-                ].sort();
-            }
-        }
-    }
-    // 同名首选表：键必须是技能声明名、值必须指向一个已知来源（用户级 / 自定义 / 项目级），
-    // 否则丢弃该条（源目录被移除后残留的首选会自然失效）。
-    const preferred = value.preferredSkills;
-    if (preferred && typeof preferred === "object" && !Array.isArray(preferred)) {
-        for (const [name, rootKey] of Object.entries(preferred)) {
-            if (!validPreferredSkillName(name) || typeof rootKey !== "string")
-                continue;
-            if (!userRoots().some((root) => root.key === rootKey) &&
-                !customKeys.has(rootKey) &&
-                !PROJECT_ROOT_KEY_RE.test(rootKey))
-                continue;
-            normalized.preferredSkills[name] = rootKey;
-        }
-    }
-    // 已移除的来源：只保留「确实是已知来源 key」的条目，其余丢弃（避免脏键让整份状态非法）。
-    {
-        const raw = Array.isArray(value.removedSources) ? value.removedSources : [];
-        const known = new Set([
-            ...userRoots().map((root) => root.key),
-            ...customKeys,
-        ]);
-        normalized.removedSources = [
-            ...new Set(raw.filter((key) => typeof key === "string" &&
-                known.has(key) &&
-                !isDefaultSkillSource(key))),
-        ].sort();
-    }
-    return normalized;
-}
 /**
  * 参与扫描的来源 = 全部来源 − 用户已移除的。
  *
@@ -1624,27 +447,6 @@ export function activeUserRoots(stateValue) {
     return userRoots().filter((root) => !removed.has(root.key));
 }
 /** 裁剪自定义来源列表：非法条目丢弃，key/path 绑定校验，label 规整。 */
-function normalizeCustomRoots(value) {
-    if (!Array.isArray(value))
-        return [];
-    const out = [];
-    const seen = new Set();
-    for (const item of value) {
-        if (!item || typeof item !== "object")
-            continue;
-        const path = typeof item.path === "string" ? item.path : "";
-        const key = typeof item.key === "string" ? item.key : "";
-        if (!isAbsolute(path) || !CUSTOM_ROOT_KEY_RE.test(key))
-            continue;
-        if (key !== customRootKey(path) || seen.has(key))
-            continue;
-        seen.add(key);
-        out.push(typeof item.label === "string" && item.label.trim()
-            ? { key, path, label: item.label.trim().slice(0, 64) }
-            : { key, path });
-    }
-    return out;
-}
 /**
  * 读状态文件。
  *
@@ -1652,118 +454,11 @@ function normalizeCustomRoots(value) {
  * 校验器要求每个 `userRoots()` 来源都在 `sources` 里有布尔值、在 `disabledSkills` 里有数组，
  * 而来源列表会随版本增加（v0.4 加了 `hub` 来源）。于是**版本升级本身**就会把一份完好的旧
  * 状态文件判成「非法」，紧接着 fail-closed：所有来源停用、写入锁定，Skills 页弹
- * 「状态文件不可读，已拒绝覆盖」。文件其实一个字节都没坏。
- *
- * 归一化会把缺失的键补成默认值（新来源默认启用），所以「我们后来加过键」与「文件真的坏了」
- * 由此区分开：前者修复后通过，后者（不是对象、version 不是 1、字段类型不对）仍然拒绝。
- */
-export async function readManagerState() {
-    try {
-        const raw = await fs.readFile(managerStatePath(), "utf8");
-        const parsed = JSON.parse(raw);
-        // 版本号在归一化时不会被保留（恒为 1），所以要在解析结果上直接判：
-        // 缺失按 1 处理（更早的文档没有这个字段），存在但不是 1 才判非法。
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)
-            && parsed.version !== undefined && parsed.version !== 1)
-            throw codedError("invalid manager state schema", "error.state.invalid");
-        // 结构守卫：字段**可以缺**（旧文档），但**一旦存在就必须形状正确**。
-        // 少了这道守卫，归一化会把「类型写错」当成「键缺失」一起补默认值——于是 `sources: []`
-        // 或 `disabledSkills: { dsh: "x" }` 这种真损坏反而被自愈放行，静默丢掉文件里的策略。
-        // 契约：**缺键自愈（我们后来加过的东西），类型错必须报错。**
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            for (const field of ["sources", "disabledSkills", "enabledSkills"]) {
-                const value = parsed[field];
-                if (value === undefined)
-                    continue;
-                if (value === null || typeof value !== "object" || Array.isArray(value))
-                    throw codedError("invalid manager state schema", "error.state.invalid");
-                // 策略表的每个桶必须是数组（条目级合法性仍由 normalize 逐条裁剪）。
-                if (field === "disabledSkills" || field === "enabledSkills") {
-                    for (const bucket of Object.values(value))
-                        if (!Array.isArray(bucket))
-                            throw codedError("invalid manager state schema", "error.state.invalid");
-                }
-            }
-        }
-        const normalized = normalizeManagerState(parsed);
-        if (!validManagerStateDocument(normalized))
-            throw codedError("invalid manager state schema", "error.state.invalid");
-        return {
-            state: normalized,
-            warning: null,
-            writable: true,
-        };
-    }
-    catch (error) {
-        // 系统异常按可选 code 读取，保持既有 ENOENT 判定。
-        if (error && error.code === "ENOENT")
-            return { state: defaultManagerState(), warning: null, writable: true };
-        return {
-            state: failClosedManagerState(),
-            writable: false,
-            warning: {
-                code: "warning.state.invalid",
-                params: { path: managerStatePath() },
-                error: `技能管理器状态文件不可读，所有技能已安全停用且状态写入已锁定: ${managerStatePath()}`,
-            },
-        };
-    }
-}
-async function writeManagerState(value) {
-    await fs.mkdir(managerHomePath(), { recursive: true });
-    await writeFileAtomically(managerStatePath(), `${JSON.stringify(normalizeManagerState(value), null, 2)}\n`);
-}
-function managerSkillOverride(policy, rootKey, name, policyAliases = []) {
-    if ((policy.enabledSkills[rootKey] || []).includes(name))
-        return true;
-    if ((policy.disabledSkills[rootKey] || []).includes(name))
-        return false;
-    let inheritedEnable = false;
-    for (const alias of policyAliases) {
-        if (alias.rootKey === rootKey && alias.name === name)
-            continue;
-        if ((policy.disabledSkills[alias.rootKey] || []).includes(alias.name))
-            return false;
-        if ((policy.enabledSkills[alias.rootKey] || []).includes(alias.name))
-            inheritedEnable = true;
-    }
-    if (inheritedEnable)
-        return true;
-    return undefined;
-}
-function effectiveSkillPolicy(policyResult, root, entry) {
-    const override = managerSkillOverride(policyResult.state, root.key, entry.name, entry.policyAliases);
-    const sourceEnabled = isDefaultSkillSource(root) ||
-        root.scope === "project" ||
-        policyResult.state.sources[root.key] !== false;
-    if (policyResult.writable === false || !sourceEnabled || override === false) {
-        return {
-            override,
-            sourceEnabled,
-            modelInvocable: false,
-            userInvocable: false,
-            enabled: false,
-        };
-    }
-    if (override === true) {
-        return {
-            override,
-            sourceEnabled,
-            modelInvocable: true,
-            userInvocable: true,
-            enabled: true,
-        };
-    }
-    const modelInvocable = entry.invocationPolicyValid && entry.modelInvocable;
-    const userInvocable = entry.invocationPolicyValid && entry.userInvocable;
-    return {
-        override,
-        sourceEnabled,
-        modelInvocable,
-        userInvocable,
-        enabled: modelInvocable && userInvocable,
-    };
-}
+ * 「状态文件不可读，已拒绝覆盖」。文件其实一个字节都没坏。
+ *
+ * 归一化会把缺失的键补成默认值（新来源默认启用），所以「我们后来加过键」与「文件真的坏了」
+ * 由此区分开：前者修复后通过，后者（不是对象、version 不是 1、字段类型不对）仍然拒绝。
+ */
 function invalidManagerStateWrite() {
     return {
         ok: false,
@@ -2019,37 +714,28 @@ export async function setPreferredSkill(root, name, preferred, log) {
         log(preferred === false ? "skill-unprefer" : "skill-prefer", preferred === false
             ? `取消同名首选 ${canonicalName}`
             : `同名首选 ${canonicalName} → ${definition.key}`);
-    return { name: canonicalName, root: preferred === false ? null : definition.key };
-}
-async function safeExistingEntryPaths(root, name) {
-    const paths = [];
-    const bundle = entryPath(root, name);
-    if (bundle === null)
-        return paths;
-    const flat = resolve(root, `${name}.md`);
-    const bundleStat = await lstatOrNull(bundle);
-    if (bundleStat && (bundleStat.isDirectory() || bundleStat.isSymbolicLink()))
-        paths.push({ path: bundle, fileName: name, recursive: true });
-    const flatStat = await lstatOrNull(flat);
-    if (flatStat && (flatStat.isFile() || flatStat.isSymbolicLink()))
-        paths.push({ path: flat, fileName: `${name}.md`, recursive: false });
-    return paths;
-}
-async function readTrashMetadata(id) {
-    if (entryPath(trashRootPath(), id) === null)
-        return null;
-    try {
-        const value = JSON.parse(await fs.readFile(join(trashRootPath(), id, "metadata.json"), "utf8"));
-        if (!value ||
-            value.id !== id ||
-            typeof value.name !== "string" ||
-            !Array.isArray(value.entries))
-            return null;
-        return value;
-    }
-    catch {
-        return null;
-    }
+    // 首选**可以**指向停用来源：这个写操作只记录一次选择，不启停任何东西，所以照旧写成功。
+    // 但「记录成功」不等于「已经生效」—— 停用不参与选赢家、且停用赢家仍要挡住低优先级副本
+    // （见 listProviderCandidates），于是首选来源自己停用时，同名两份**都不生效**。
+    // 这里如实回话：调用方（含模型，`skill-prefer` 是模型可调的）不能以为「已改为生效」。
+    // 不返回 ok:false —— 那会让界面的「启用这个」（prefer 之后紧跟 enable）在 enable 之前就中断。
+    const effective = effectiveSkillPolicy(current, definition, {
+        ...summary,
+        ...resolved,
+    });
+    const base = {
+        name: canonicalName,
+        root: preferred === false ? null : definition.key,
+    };
+    if (preferred === false || effective.enabled)
+        return base;
+    return {
+        ...base,
+        effective: false,
+        warning: `已记录同名首选，但它不会生效：${canonicalName}（${definition.label || definition.key}）` +
+            `当前处于停用状态，而它仍然挡住同名的其他副本 —— 两份都不生效。` +
+            `启用其中一份即可（启用这份，或改用另一份）。`,
+    };
 }
 /**
  * Windows Defender / 索引器可能持续占用刚写入的 stage 目录，导致容器目录 rename
@@ -2101,52 +787,6 @@ async function publishTrashStage(stage, finalPath, metadata, renameOptions = {})
  * 所以这里必须按 scope 分岔：早先只特判 `dsh`，hub 会被记成项目级、`projectRoot`
  * 为 undefined，恢复时被判「原项目当前不在活动工作区中」—— 删除进去就再也拿不回来。
  */
-function trashRootMetadata(definition) {
-    if (definition.scope !== "project")
-        return { key: definition.key, scope: "user", label: definition.label };
-    return {
-        key: definition.key,
-        scope: "project",
-        kind: "project-dsh",
-        projectRoot: definition.projectRoot,
-        projectName: definition.projectName,
-        label: definition.label,
-    };
-}
-async function restoreRootDefinition(metadata, options = {}) {
-    // version 1 entries predate scoped Trash and always belong to $DSH_HOME/skills.
-    if (!metadata.root)
-        return rootByKey("dsh");
-    // 用户级来源按 key 重新解析：路径来自 userRoots()，不信元数据里记住的 path
-    // （DSH_HOME 换过之后，旧路径可能已经不在读取范围内了）。
-    if (metadata.root.scope === "user")
-        return rootByKey(metadata.root.key);
-    if (metadata.root.scope !== "project" ||
-        metadata.root.kind !== "project-dsh" ||
-        typeof metadata.root.key !== "string" ||
-        typeof metadata.root.projectRoot !== "string" ||
-        !isAbsolute(metadata.root.projectRoot))
-        return {
-            ok: false,
-            error: `回收站条目来源非法: ${metadata.id}`,
-            code: "error.trash.invalid",
-            params: { id: metadata.id },
-        };
-    const roots = await projectRoots(options.projectCwds);
-    const normalizedProjectRoot = pathIdentity(metadata.root.projectRoot);
-    const root = roots.find((item) => item.key === metadata.root.key &&
-        item.kind === "project-dsh" &&
-        pathIdentity(item.projectRoot) === normalizedProjectRoot);
-    if (!root) {
-        return {
-            ok: false,
-            error: `原项目当前不在活动工作区中，无法恢复: ${metadata.root.projectRoot}`,
-            code: "error.trash.projectUnavailable",
-            params: { path: metadata.root.projectRoot },
-        };
-    }
-    return checkedWritableRootDefinition(root);
-}
 /** 把项目级 DSH 根中的单个技能移入 manager-owned 回收站。 */
 export async function deleteSkill(root, name, log, options = {}) {
     const definition = await checkedWritableRootDefinition(root);
@@ -2222,662 +862,45 @@ export async function deleteSkill(root, name, log, options = {}) {
         throw error;
     }
 }
-export async function listTrash() {
-    let items;
-    try {
-        items = await fs.readdir(trashRootPath(), { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const result = [];
-    for (const item of items) {
-        if (!item.isDirectory() || item.name.startsWith("."))
-            continue;
-        const metadata = await readTrashMetadata(item.name);
-        if (metadata)
-            result.push(metadata);
-    }
-    return result.sort((a, b) => String(b.deletedAt).localeCompare(String(a.deletedAt)));
-}
-export async function restoreTrash(id, log, options = {}) {
-    const metadata = await readTrashMetadata(id);
-    if (!metadata)
-        return {
-            ok: false,
-            error: `回收站条目不存在: ${id}`,
-            code: "error.trash.notFound",
-            params: { id },
-        };
-    const definition = await restoreRootDefinition(metadata, options);
-    if (!definition || definition.ok === false)
-        return definition || readonlyError("restore");
-    const root = definition.path;
-    const conflicts = await safeExistingEntryPaths(root, metadata.name);
-    if (conflicts.length)
-        return {
-            ok: false,
-            error: `无法恢复，同名技能已存在: ${metadata.name}`,
-            code: "error.trash.conflict",
-            params: { name: metadata.name },
-        };
-    await fs.mkdir(root, { recursive: true });
-    const itemRoot = join(trashRootPath(), id);
-    const moved = [];
-    try {
-        for (const fileName of metadata.entries) {
-            const source = join(itemRoot, fileName);
-            const destination = join(root, fileName);
-            if (!isSameOrDescendant(itemRoot, source) ||
-                !isSameOrDescendant(root, destination))
-                throw codedError("回收站条目路径非法", "error.trash.invalid", { id });
-            await movePathWithFallback(source, destination, options.renameOptions);
-            moved.push({ source, destination });
-        }
-        await fs.rm(itemRoot, { recursive: true, force: true });
-        if (log)
-            log("restore", `从回收站恢复 ${metadata.name} -> ${root}`);
-        return { id, name: metadata.name, root: trashRootMetadata(definition) };
-    }
-    catch (error) {
-        for (const item of moved.reverse())
-            await movePathWithFallback(item.destination, item.source, options.renameOptions).catch(() => undefined);
-        throw error;
-    }
-}
-export async function permanentlyDeleteTrash(id, log) {
-    const metadata = await readTrashMetadata(id);
-    if (!metadata)
-        return {
-            ok: false,
-            error: `回收站条目不存在: ${id}`,
-            code: "error.trash.notFound",
-            params: { id },
-        };
-    await fs.rm(join(trashRootPath(), id), { recursive: true, force: true });
-    if (log)
-        log("trash-delete", `永久删除回收站条目 ${metadata.name} (${id})`);
-    return { id, name: metadata.name };
-}
 // ── 导入 ────────────────────────────────────────────────────────────────────
 /** 分析来源：单 skill 目录 / 单 .md 文件 / 批量目录。 */
-async function analyzeSource(source) {
-    let st;
-    try {
-        st = await fs.lstat(source);
-    }
-    catch {
-        return {
-            kind: "none",
-            error: `路径不存在: ${source}`,
-            code: "error.source.notFound",
-            params: { path: source },
-        };
-    }
-    if (st.isSymbolicLink())
-        return {
-            kind: "none",
-            error: `不支持包含符号链接的 skill 来源: ${source}`,
-            code: "error.source.symlink",
-            params: { path: source },
-        };
-    if (st.isDirectory()) {
-        const sk = join(source, "SKILL.md");
-        const skSt = await lstatOrNull(sk);
-        // 预检与实际导入口径一致：SKILL.md 本身是链接时直接拒绝，避免 dry-run 通过、正式导入才失败。
-        if (skSt && skSt.isSymbolicLink())
-            return {
-                kind: "none",
-                error: `不支持包含符号链接的 skill 来源: ${sk}`,
-                code: "error.source.symlink",
-                params: { path: sk },
-            };
-        if (skSt && skSt.isFile()) {
-            return {
-                kind: "single",
-                rawName: basename(source),
-                kebab: toKebab(basename(source)),
-                source,
-                isDir: true,
-                skillFile: sk,
-            };
-        }
-        return { kind: "batch", rawName: basename(source), source, isDir: true };
-    }
-    if (st.isFile() && source.toLowerCase().endsWith(".md")) {
-        if (basename(source).toLowerCase() === "skill.md") {
-            const parent = dirname(source);
-            return {
-                kind: "single",
-                rawName: basename(parent),
-                kebab: toKebab(basename(parent)),
-                source: parent,
-                isDir: true,
-                skillFile: source,
-            };
-        }
-        const rawName = basename(source).slice(0, -3);
-        return {
-            kind: "single",
-            rawName,
-            kebab: toKebab(rawName),
-            source,
-            isDir: false,
-            skillFile: source,
-        };
-    }
-    return {
-        kind: "none",
-        error: `无法识别的 skill 来源: ${source}`,
-        code: "error.source.unrecognized",
-        params: { path: source },
-    };
-}
-async function collectCandidates(dir) {
-    const items = await fs.readdir(dir, { withFileTypes: true });
-    const out = [];
-    for (const it of items) {
-        if (it.isSymbolicLink())
-            throw codedError(`不支持包含符号链接的 skill 来源: ${join(dir, it.name)}`, "error.source.symlink", { path: join(dir, it.name) });
-        if (it.isDirectory()) {
-            const sk = join(dir, it.name, "SKILL.md");
-            // lstatOrNull 吞掉 IO 异常（返回 null 即跳过）；symlink 必须抛出，不能被“跳过”逻辑掩盖。
-            const st = await lstatOrNull(sk);
-            if (st && st.isSymbolicLink())
-                throw codedError(`不支持包含符号链接的 skill 来源: ${sk}`, "error.source.symlink", { path: sk });
-            if (st && st.isFile()) {
-                out.push({
-                    source: join(dir, it.name),
-                    kebab: toKebab(it.name),
-                    rawName: it.name,
-                    isDir: true,
-                });
-            }
-        }
-        else if (it.isFile() &&
-            it.name.toLowerCase().endsWith(".md") &&
-            it.name.toLowerCase() !== "skill.md") {
-            out.push({
-                source: join(dir, it.name),
-                kebab: toKebab(it.name.slice(0, -3)),
-                rawName: it.name.slice(0, -3),
-                isDir: false,
-            });
-        }
-    }
-    return out;
-}
 /** 导入内容不接受符号链接，避免把目标目录外的内容带入技能目录。 */
-async function assertNoSymbolicLinks(source) {
-    const pending = [
-        { path: source, depth: 0 },
-    ];
-    while (pending.length) {
-        // while 条件保证栈非空，断言只为让类型收敛。
-        const current = pending.pop();
-        if (current.depth > MAX_SOURCE_DEPTH)
-            throw codedError(`skill 来源目录层级超过 ${MAX_SOURCE_DEPTH} 层: ${source}`, "error.source.tooDeep", { depth: MAX_SOURCE_DEPTH, path: source });
-        const st = await fs.lstat(current.path);
-        if (st.isSymbolicLink())
-            throw codedError(`不支持包含符号链接的 skill 来源: ${current.path}`, "error.source.symlink", { path: current.path });
-        if (!st.isDirectory())
-            continue;
-        const items = await fs.readdir(current.path, { withFileTypes: true });
-        for (const item of items) {
-            const path = join(current.path, item.name);
-            if (item.isSymbolicLink())
-                throw codedError(`不支持包含符号链接的 skill 来源: ${path}`, "error.source.symlink", { path });
-            if (item.isDirectory())
-                pending.push({ path, depth: current.depth + 1 });
-        }
-    }
-}
-function temporaryPath(target, kind) {
-    return join(dirname(target), `.${basename(target)}.dssm-${kind}-${randomUUID()}`);
-}
 /** dry-run 预检执行与正式导入相同的符号链接/深度检查，预检失败即结论，不再进入覆盖确认。
  *  预检与实导之间来源被替换的竞态仍由实导阶段的复制后校验兜底。 */
-async function preflightCandidates(pending, conflicts, failed) {
-    for (const group of [pending, conflicts]) {
-        for (let i = group.length - 1; i >= 0; i--) {
-            const candidate = group[i];
-            try {
-                await assertNoSymbolicLinks(candidate.source);
-            }
-            catch (error) {
-                // 系统异常按可选 message 读取，保持既有失败明细文案。
-                failed.push(attachCode({
-                    source: candidate.source,
-                    error: String(error && error.message ? error.message : error),
-                }, error));
-                group.splice(i, 1);
-            }
-        }
-    }
-}
 /** 先复制到同目录临时路径，复制失败时不触碰现有技能。 */
-async function copyToTemporary(source, target, isDir) {
-    const temp = temporaryPath(target, "stage");
-    try {
-        await assertNoSymbolicLinks(source);
-        if (isDir)
-            await fs.cp(source, temp, { recursive: true, dereference: false });
-        else
-            await fs.copyFile(source, temp);
-        await assertNoSymbolicLinks(temp);
-        return temp;
-    }
-    catch (error) {
-        await fs.rm(temp, { recursive: true, force: true }).catch(() => undefined);
-        throw error;
-    }
-}
 /** 临时副本就绪后再替换；替换失败时尽力恢复旧条目。 */
-async function replaceWithCopy(source, dest, isDir, existing = []) {
-    const stage = await copyToTemporary(source, dest, isDir);
-    const backups = [];
-    // 三处 rename 一律走 `renameWithRetry`：瞬时占用（Windows 杀软 / 索引器 / 资源管理器）返回的
-    // EACCES / EBUSY / EPERM 正是它重试的那些码。此前只有 `:959` 的回滚用了带重试的版本，
-    // 而**发布与它的补偿回滚用的是裸 rename** —— 发布因瞬时锁抛错时，紧随其后的回滚在同一刻、
-    // 同一目录上大概率撞同一个句柄，于是留下"目标已空、真值还叫 backup"的半态（无自动恢复路径）。
-    // 保护覆盖不均不是取舍，是漏。
-    try {
-        for (const path of existing) {
-            const backup = temporaryPath(path, "backup");
-            await renameWithRetry(path, backup);
-            backups.push({ path, backup });
-        }
-        await renameWithRetry(stage, dest);
-    }
-    catch (error) {
-        // 系统异常按可选 message 读取，保持既有回滚失败明细。
-        await fs.rm(stage, { recursive: true, force: true }).catch(() => undefined);
-        const rollbackFailures = [];
-        for (const item of backups.reverse()) {
-            try {
-                await renameWithRetry(item.backup, item.path);
-            }
-            catch (rollbackError) {
-                rollbackFailures.push(item.backup);
-            }
-        }
-        if (rollbackFailures.length) {
-            const causeText = String(error && error.message ? error.message : error);
-            throw codedError(`${causeText}；覆盖导入回滚失败，备份保留在: ${rollbackFailures.join("、")}`, "error.import.rollbackFailed", { path: rollbackFailures.join("; "), error: causeText });
-        }
-        throw error;
-    }
-    const warnings = [];
-    for (const item of backups) {
-        try {
-            await fs.rm(item.backup, { recursive: true, force: true });
-        }
-        catch (error) {
-            // 系统异常按可选 message 读取，保持既有告警文案。
-            warnings.push({
-                code: "warning.backupUncleaned",
-                params: {
-                    path: item.backup,
-                    error: String(error && error.message ? error.message : error),
-                },
-                error: `旧版本备份未清理: ${item.backup}（${String(error && error.message ? error.message : error)}）`,
-            });
-        }
-    }
-    return warnings;
-}
 /**
  * 导入技能到目标根。
  * options: { conflict: 'skip'|'overwrite', dryRun: boolean }
  * 成功返回 { kind, imported, skipped, failed }；失败返回 { ok:false, error }。
  */
-export async function importSkill(source, log, options = {}) {
-    const targetRoot = skillCreateRootPath();
-    const conflict = options.conflict === "overwrite" ? "overwrite" : "skip";
-    const dryRun = options.dryRun === true;
-    const analysis = await analyzeSource(source);
-    if (analysis.kind === "none")
-        return {
-            ok: false,
-            error: analysis.error || "无法识别的 skill 来源",
-            code: analysis.code || "error.source.unrecognized",
-            params: analysis.params,
-        };
-    if (await pathsOverlap(analysis.source, targetRoot))
-        return {
-            ok: false,
-            error: "导入来源不能与 DSH 技能目录相同、包含或位于其中",
-            code: "error.import.overlap",
-        };
-    let candidates = [];
-    if (analysis.kind === "single") {
-        candidates = [
-            {
-                source: analysis.source,
-                kebab: analysis.kebab,
-                rawName: analysis.rawName,
-                isDir: analysis.isDir,
-            },
-        ];
-    }
-    else {
-        try {
-            candidates = await collectCandidates(source);
-        }
-        catch (error) {
-            // 系统异常按可选 message 读取，保持既有失败明细文案。
-            return attachCode({
-                ok: false,
-                error: String(error && error.message ? error.message : error),
-            }, error);
-        }
-        if (candidates.length === 0)
-            return {
-                ok: false,
-                error: `目录下未找到任何 skill 条目（需含 SKILL.md 的子目录或 .md 文件）: ${source}`,
-                code: "error.import.emptySource",
-                params: { path: source },
-            };
-    }
-    const pending = [];
-    const conflicts = [];
-    const failed = [];
-    const imported = [];
-    const skipped = [];
-    const nameCount = new Map();
-    for (const candidate of candidates) {
-        if (candidate.kebab &&
-            KEBAB_RE.test(candidate.kebab) &&
-            entryPath(targetRoot, candidate.kebab) !== null)
-            nameCount.set(candidate.kebab, (nameCount.get(candidate.kebab) || 0) + 1);
-    }
-    function failureResult() {
-        return {
-            ok: false,
-            // 聚合失败明细的原文；前端优先展示已翻译的 failed 明细，此处仅作兜底。
-            error: failed.map((item) => item.error).join("；"),
-            code: "error.import.failed",
-            kind: analysis.kind,
-            imported,
-            skipped,
-            failed,
-        };
-    }
-    for (const c of candidates) {
-        if (!c.kebab ||
-            !KEBAB_RE.test(c.kebab) ||
-            entryPath(targetRoot, c.kebab) === null) {
-            failed.push({
-                source: c.source,
-                error: `无法生成合法 kebab-case 名称（原始名: ${c.rawName || basename(c.source)}）`,
-                code: "error.import.invalidName",
-                params: { name: c.rawName || basename(c.source) },
-            });
-            continue;
-        }
-        // 上方计数循环已为该 kebab 记数（合法名称且目标可写），断言只为让类型收敛。
-        if (nameCount.get(c.kebab) > 1) {
-            failed.push({
-                source: c.source,
-                error: `批量来源中存在多个同名插件: ${c.kebab}`,
-                code: "error.import.duplicateName",
-                params: { name: c.kebab },
-            });
-            continue;
-        }
-        const dest = c.isDir
-            ? join(targetRoot, c.kebab)
-            : join(targetRoot, `${c.kebab}.md`);
-        const paths = [
-            join(targetRoot, c.kebab),
-            join(targetRoot, `${c.kebab}.md`),
-        ];
-        const existing = [];
-        for (const path of paths) {
-            try {
-                await fs.stat(path);
-                existing.push(path);
-            }
-            catch { }
-        }
-        if (existing.length) {
-            conflicts.push({
-                name: c.kebab,
-                source: c.source,
-                isDir: c.isDir,
-                paths: existing,
-            });
-            continue;
-        }
-        pending.push({ name: c.kebab, source: c.source, isDir: c.isDir, dest });
-    }
-    if (pending.length === 0 && conflicts.length === 0)
-        return failureResult();
-    if (dryRun) {
-        // 预检即结论：与正式导入同口径执行符号链接/深度检查，避免预检通过、确认覆盖后实导才失败。
-        await preflightCandidates(pending, conflicts, failed);
-        if (pending.length === 0 && conflicts.length === 0)
-            return failureResult();
-        return { kind: analysis.kind, pending, conflicts, failed };
-    }
-    if (pending.length > 0 ||
-        (conflict === "overwrite" && conflicts.length > 0)) {
-        await fs.mkdir(targetRoot, { recursive: true });
-    }
-    for (const p of pending) {
-        try {
-            const warnings = await replaceWithCopy(p.source, p.dest, p.isDir);
-            imported.push({ name: p.name, overwritten: false, warnings });
-            if (log)
-                log("import", `导入 ${p.source} -> ${p.dest}`);
-        }
-        catch (e) {
-            // 系统异常按可选 message 读取，保持既有失败明细文案。
-            failed.push(attachCode({ source: p.source, error: String(e && e.message ? e.message : e) }, e));
-        }
-    }
-    if (conflict === "overwrite") {
-        for (const c of conflicts) {
-            try {
-                const dest = c.isDir
-                    ? join(targetRoot, c.name)
-                    : join(targetRoot, `${c.name}.md`);
-                const warnings = await replaceWithCopy(c.source, dest, c.isDir, c.paths);
-                imported.push({ name: c.name, overwritten: true, warnings });
-                if (log)
-                    log("import-overwrite", `覆盖导入 ${c.source} -> ${dest}`);
-            }
-            catch (e) {
-                // 系统异常按可选 message 读取，保持既有失败明细文案。
-                failed.push(attachCode({ source: c.source, error: String(e && e.message ? e.message : e) }, e));
-            }
-        }
-    }
-    else {
-        for (const c of conflicts)
-            skipped.push({ name: c.name, source: c.source });
-    }
-    if (failed.length && imported.length === 0)
-        return failureResult();
-    return { kind: analysis.kind, imported, skipped, failed };
-}
 // ── 浏览器上传导入 ──────────────────────────────────────────────────────────
+/**
+ * 一个上传路径段会不会被文件系统**改写**成别的东西。
+ *
+ * 为什么必须单判这一条（2026-09-30 审查 P2-17，实为路径逃逸而非口径分叉）：
+ * 下面的 `part === ".."` 只挡**恰好**是 `..` 的段，而 Windows 的路径归一化会把段尾的
+ * **点与空格**静默裁掉 —— `.. `（`..` 加一个空格）在 `CreateFileW` / `CreateDirectoryW`
+ * 眼里就是 `..`。于是 `join(contentRoot, ".. ", "x")` 看着在根内（`isSameOrDescendant`
+ * 也判在根内：它按字符串比，`".. "` 不等于 `".."`，`relative` 得到的 `".. /x"` 也不以
+ * `"../"` 开头），实际会写到**暂存目录之外**。同一条判据顺带覆盖 `...` / `. ` /
+ * `foo.`（最后一个不逃逸，但会让磁盘上的名字与界面显示的名字不一致 —— `paths.ts` 的
+ * `trailing-dot-or-space` 就是为这个存在的）。
+ *
+ * 只挡"会被改写"的形态，**不挡** `.gitignore` / `.DS_Store` 这类正常点文件：技能包带它们
+ * 是常态（macOS 解压出来的包必带 `.DS_Store`），一律拒绝会让正常技能导不进来。
+ * 注意 `../imports/upload.ts` 的 `normalizeEntryPath` 走的是更宽的一条（拒绝**所有**
+ * 点开头的段）—— 那里是历史口径，方向更保守，两边都安全，不必强行统一。
+ */
 /**
  * 校验浏览器或 ZIP 提供的相对路径。上传内容始终写成普通文件，不解释 ZIP 的链接元数据。
  * 这样既不依赖浏览器泄露本机绝对路径，也不会让归档跨出管理器暂存目录。
  */
-function normalizeUploadPath(input) {
-    const raw = String(input == null ? "" : input).replace(/\\/g, "/");
-    if (!raw ||
-        raw.length > MAX_UPLOAD_PATH_LENGTH ||
-        raw.includes("\0") ||
-        raw.startsWith("/") ||
-        /^[A-Za-z]:/.test(raw) ||
-        raw.startsWith("//")) {
-        throw codedError(`上传条目路径非法: ${raw}`, "error.upload.path", {
-            path: raw,
-        });
-    }
-    const directory = raw.endsWith("/");
-    const parts = raw
-        .split("/")
-        .filter((part, index, all) => directory && index === all.length - 1 ? false : true);
-    if (!parts.length ||
-        parts.length > MAX_SOURCE_DEPTH ||
-        parts.some((part) => !part ||
-            part === "." ||
-            part === ".." ||
-            part.length > MAX_ENTRY_NAME_LENGTH ||
-            WINDOWS_DEVICE_NAME_RE.test(part))) {
-        throw codedError(`上传条目路径非法: ${raw}`, "error.upload.path", {
-            path: raw,
-        });
-    }
-    return { path: parts.join("/"), directory };
-}
-function decodeUploadBase64(value, maxBytes, code = "error.upload.tooLarge") {
-    const raw = String(value == null ? "" : value);
-    const padding = raw.endsWith("==") ? 2 : raw.endsWith("=") ? 1 : 0;
-    const dataLength = raw.length - padding;
-    const firstPadding = raw.indexOf("=");
-    if (raw.length % 4 !== 0 ||
-        (firstPadding !== -1 && firstPadding !== dataLength)) {
-        throw codedError("上传内容不是合法 Base64", "error.upload.encoding");
-    }
-    const decodedLength = (raw.length / 4) * 3 - padding;
-    if (decodedLength > maxBytes)
-        throw codedError(`上传内容超过 ${maxBytes} 字节限制`, code, {
-            limit: maxBytes,
-        });
-    // 避免对数 MiB 字符串使用带重复分组的正则；V8 可能在合法大文件上耗尽调用栈。
-    for (let index = 0; index < dataLength; index += 1) {
-        const char = raw.charCodeAt(index);
-        if (!((char >= 65 && char <= 90) ||
-            (char >= 97 && char <= 122) ||
-            (char >= 48 && char <= 57) ||
-            char === 43 ||
-            char === 47)) {
-            throw codedError("上传内容不是合法 Base64", "error.upload.encoding");
-        }
-    }
-    const bytes = Buffer.from(raw, "base64");
-    return bytes;
-}
-function uploadError(error) {
-    // 按可选 message 读取抛出值，保持既有兜底文案。
-    const cause = error;
-    return attachCode({
-        ok: false,
-        error: String(cause && cause.message ? cause.message : error),
-    }, error);
-}
-async function writeUploadedEntries(contentRoot, entries) {
-    if (!Array.isArray(entries) || entries.length === 0)
-        throw codedError("上传内容为空", "error.upload.empty");
-    if (entries.length > MAX_UPLOAD_ENTRIES)
-        throw codedError(`上传条目超过 ${MAX_UPLOAD_ENTRIES} 个`, "error.upload.tooMany", { limit: MAX_UPLOAD_ENTRIES });
-    let total = 0;
-    const seen = new Set();
-    for (const entry of entries) {
-        const normalized = normalizeUploadPath(entry && entry.path);
-        const key = normalized.path.toLowerCase();
-        if (seen.has(key))
-            throw codedError(`上传内容包含重复路径: ${normalized.path}`, "error.upload.duplicate", { path: normalized.path });
-        seen.add(key);
-        if (normalized.directory)
-            continue;
-        const bytes = decodeUploadBase64(entry && entry.data, MAX_UPLOAD_ENTRY_BYTES);
-        total += bytes.length;
-        if (total > MAX_UPLOAD_TOTAL_BYTES)
-            throw codedError(`上传内容总大小超过 ${MAX_UPLOAD_TOTAL_BYTES} 字节`, "error.upload.tooLarge", { limit: MAX_UPLOAD_TOTAL_BYTES });
-        const target = join(contentRoot, ...normalized.path.split("/"));
-        if (!isSameOrDescendant(contentRoot, target))
-            throw codedError(`上传条目路径非法: ${normalized.path}`, "error.upload.path", { path: normalized.path });
-        await fs.mkdir(dirname(target), { recursive: true });
-        await fs.writeFile(target, bytes);
-    }
-}
-async function writeUploadedZip(contentRoot, encoded) {
-    const archive = decodeUploadBase64(encoded, MAX_UPLOAD_ARCHIVE_BYTES, "error.upload.archiveTooLarge");
-    let count = 0;
-    let total = 0;
-    let files;
-    try {
-        files = unzipSync(archive, {
-            filter(info) {
-                const normalized = normalizeUploadPath(info.name);
-                count += 1;
-                if (count > MAX_UPLOAD_ENTRIES)
-                    throw codedError(`ZIP 条目超过 ${MAX_UPLOAD_ENTRIES} 个`, "error.upload.tooMany", { limit: MAX_UPLOAD_ENTRIES });
-                if (!normalized.directory && info.originalSize > MAX_UPLOAD_ENTRY_BYTES)
-                    throw codedError(`ZIP 条目过大: ${normalized.path}`, "error.upload.tooLarge", { limit: MAX_UPLOAD_ENTRY_BYTES });
-                total += normalized.directory ? 0 : info.originalSize;
-                if (total > MAX_UPLOAD_TOTAL_BYTES)
-                    throw codedError(`ZIP 解压后总大小超过 ${MAX_UPLOAD_TOTAL_BYTES} 字节`, "error.upload.tooLarge", { limit: MAX_UPLOAD_TOTAL_BYTES });
-                return !normalized.directory;
-            },
-        });
-    }
-    catch (error) {
-        // 业务错误（我们抛的 error.* 前缀）透传；其余按 ZIP 解压失败处理。
-        if (error && /^error\./.test(String(error.code || "")))
-            throw error;
-        throw codedError(`ZIP 无法解压: ${String(error && error.message ? error.message : error)}`, "error.upload.zipInvalid");
-    }
-    const entries = Object.entries(files).map(([path, bytes]) => ({
-        path,
-        data: Buffer.from(bytes).toString("base64"),
-    }));
-    await writeUploadedEntries(contentRoot, entries);
-}
-async function prepareUploadedSource(sessionRoot, input) {
-    const contentRoot = join(sessionRoot, "content");
-    await fs.mkdir(contentRoot, { recursive: true });
-    if (input && input.zip !== undefined)
-        await writeUploadedZip(contentRoot, input.zip);
-    else
-        await writeUploadedEntries(contentRoot, input && input.entries);
-    const rootSkill = join(contentRoot, "SKILL.md");
-    const rootSkillStat = await lstatOrNull(rootSkill);
-    if (!rootSkillStat || !rootSkillStat.isFile())
-        return contentRoot;
-    const doc = parseSkillDoc(await fs.readFile(rootSkill, "utf8"));
-    const fallback = String((input && input.name) || "uploaded-skill")
-        .replace(/\.zip$/i, "")
-        .replace(/^skill\.md$/i, "uploaded-skill");
-    const skillName = toKebab(doc.map.name || fallback);
-    if (!skillName ||
-        !KEBAB_RE.test(skillName) ||
-        entryPath(contentRoot, skillName) === null) {
-        throw codedError(`无法生成合法 kebab-case 名称（原始名: ${doc.map.name || fallback}）`, "error.import.invalidName", { name: doc.map.name || fallback });
-    }
-    const batchRoot = join(sessionRoot, "batch");
-    const wrappedRoot = join(batchRoot, skillName);
-    await fs.mkdir(batchRoot, { recursive: true });
-    await renameWithRetry(contentRoot, wrappedRoot);
-    return batchRoot;
-}
+/** 浏览器上传来源入参（entries 或 zip 二者取一）。 */
 /**
  * 接收浏览器读取后的内容，在 manager 私有目录暂存并复用现有原子导入链路。
  * input: { name, entries:[{path,data(base64)}] } 或 { name, zip:base64 }。
  */
-export async function importUploadedSkill(input, log, options = {}) {
-    const uploadHome = join(managerHomePath(), "uploads");
-    const sessionRoot = join(uploadHome, `.upload-${randomUUID()}`);
-    try {
-        await fs.mkdir(sessionRoot, { recursive: true });
-        const source = await prepareUploadedSource(sessionRoot, input || {});
-        return await importSkill(source, log, options);
-    }
-    catch (error) {
-        return uploadError(error);
-    }
-    finally {
-        await fs
-            .rm(sessionRoot, { recursive: true, force: true })
-            .catch(() => undefined);
-    }
-}
 // ── 创建 / 详情 / Provider ─────────────────────────────────────────────────
 function yamlString(value) {
     return JSON.stringify(String(value));
@@ -3110,7 +1133,17 @@ export async function skillDetail(keyOrRoot, name, options = {}) {
         sourceReadOnly: !root.mutable,
     };
 }
-/** 生成 manager provider 候选：保留禁用候选以阻止低优先级重名副本意外激活。 */
+/**
+ * 生成 manager provider 候选：保留禁用候选以阻止低优先级重名副本意外激活。
+ *
+ * **同名首选必须传进分组**（2026-09-30 审查 F8）。此前这里调
+ * `groupLoadableSkillsByName(items)` 时没带 `preferred`，而管理页（`markWinners`）带了 ——
+ * 于是「同名首选」只在界面上生效：用户把 A 设为首选，界面把 A 标成「同名首选」、把 B 标成
+ * 「被覆盖」，模型侧却仍按 rank 拿到 B。**界面说的和模型用的不是同一份**，且没有任何一处报错。
+ *
+ * 分组函数本身是共用的（同一份排序规则），缺的只是这个参数；传进去两侧即同源。
+ * 未命中（键已失效 / 来源被移除）时分组函数自己退化为纯 rank 顺序，与界面一致。
+ */
 export async function listProviderCandidates(options = {}) {
     const policyResult = await readManagerState();
     const candidates = [];
@@ -3129,7 +1162,9 @@ export async function listProviderCandidates(options = {}) {
                 items.push({ root, entry });
         }
     }
-    for (const group of groupLoadableSkillsByName(items).values()) {
+    // 与管理页 markWinners 同一个 preferred 表、同一个分组函数 —— 界面与模型必须挑同一个赢家。
+    const preferredSkills = policyResult.state.preferredSkills || null;
+    for (const group of groupLoadableSkillsByName(items, preferredSkills).values()) {
         const { root, entry } = group[0];
         const project = root.scope === "project";
         const policyOnly = root.mutable;
@@ -3249,246 +1284,11 @@ export async function getProviderSkill(candidate, options = {}) {
     }
 }
 // ── 状态快照 ────────────────────────────────────────────────────────────────
-function canonicalSkillName(item) {
-    return item.entry.declaredName || item.entry.name;
-}
 /**
  * 真实路径去重后按声明名分组；管理页与当前工作区 provider 共用来源优先级。
  *
  * `preferred`（技能名 → 来源 key）是用户对同名技能的显式选择：命中的来源排到同名前，
  * 其余仍按来源 rank 排序；未命中（或键已失效）时退化为纯 rank 顺序。
  */
-export function groupLoadableSkillsByName(items, preferred) {
-    const preferredFor = (item) => {
-        if (!preferred)
-            return null;
-        const key = preferred[canonicalSkillName(item)];
-        return typeof key === "string" ? key : null;
-    };
-    const ordered = [...items].sort((a, b) => {
-        const rankA = preferredFor(a) === a.root.key ? 0 : 1;
-        const rankB = preferredFor(b) === b.root.key ? 0 : 1;
-        if (rankA !== rankB)
-            return rankA - rankB;
-        return a.root.rank - b.root.rank;
-    });
-    const groups = new Map();
-    for (const item of ordered) {
-        if (!item.entry.loadable)
-            continue;
-        const name = canonicalSkillName(item);
-        const group = groups.get(name) || [];
-        group.push(item);
-        groups.set(name, group);
-    }
-    return groups;
-}
-function markWinners(items, options = {}) {
-    const winners = new Map();
-    const preferred = options.preferred;
-    for (const [canonicalName, [winner, ...shadowed],] of groupLoadableSkillsByName(items, preferred)) {
-        winners.set(canonicalName, winner);
-        // 只有「首选命中且确实赢了」才算首选；来源被停用/移除时不谎报。
-        if (preferred && preferred[canonicalName] === winner.root.key)
-            winner.view.preferred = true;
-        if (options.markShadowed !== false) {
-            for (const item of shadowed)
-                item.view.shadowedBy = {
-                    root: winner.root.key,
-                    name: winner.entry.name,
-                };
-        }
-        if (options.markWinner !== false)
-            winner.view.winner = true;
-        winner.view.enabled = winner.policy.enabled;
-        winner.view.canonicalName = canonicalName;
-    }
-    return winners;
-}
 /** DSH、常见 Agent、自定义目录与活动 Session 项目根的技能快照。 */
-export async function state(options = {}) {
-    const policyResult = await readManagerState();
-    const removedKeys = new Set(Array.isArray(policyResult.state.removedSources)
-        ? policyResult.state.removedSources
-        : []);
-    // 已移除的来源仍然出现在 roots 里（界面要能显示「已移除」并允许恢复），但**不扫描**：
-    // 技能不入列表、不参与重名决胜 —— 这正是用户要的「不读取这个文件夹」。
-    // 注意这里必须用**全部**来源 + 自定义来源，不能只用 activeUserRoots()，
-    // 否则被移除的来源会连行都不剩，界面就无从提供「恢复读取」。
-    const user = [...userRoots(), ...customRootsFromState(policyResult.state)];
-    const scannable = user.filter((root) => !removedKeys.has(root.key));
-    const userScans = await scanDeduplicatedRoots(scannable);
-    const projectWarnings = [];
-    const scoped = await projectRoots(options.projectCwds, projectWarnings);
-    const trash = await listTrash();
-    const result = {
-        roots: [],
-        projects: [],
-        trash,
-        warnings: [
-            ...(policyResult.warning ? [policyResult.warning] : []),
-            ...projectWarnings,
-        ],
-    };
-    // 回收站没有自动清理：超龄条目通过 warnings 提示用户到 Skills 管理页处理，
-    // 避免静默删除用户可能还想恢复的内容。
-    const TRASH_STALE_DAYS = 30;
-    const staleTrashCount = trash.filter((item) => {
-        const deletedAt = Date.parse(String(item && item.deletedAt));
-        return Number.isFinite(deletedAt) && Date.now() - deletedAt > TRASH_STALE_DAYS * 86400000;
-    }).length;
-    if (staleTrashCount > 0)
-        result.warnings.push({
-            code: "warning.trash.stale",
-            params: { count: staleTrashCount, days: TRASH_STALE_DAYS },
-            error: `回收站中有 ${staleTrashCount} 个条目已超过 ${TRASH_STALE_DAYS} 天，建议到 Skills 管理页清理`,
-        });
-    const all = [];
-    for (const root of [...scoped, ...user]) {
-        const isRemoved = removedKeys.has(root.key);
-        const { exists, entries, truncated } = isRemoved
-            ? { exists: false, entries: [], truncated: false }
-            : root.scope === "project"
-                ? (await scanDeduplicatedRoots([root])).get(root.key)
-                : userScans.get(root.key);
-        if (isRemoved) {
-            // 已移除：登记一行（供界面显示与恢复），但没有任何技能。
-            result.roots.push({
-                key: root.key,
-                ...(root.kind ? { kind: root.kind } : {}),
-                ...(root.localeKey ? { localeKey: root.localeKey } : {}),
-                path: root.path,
-                label: root.label,
-                mutable: root.mutable,
-                deletable: root.deletable === true,
-                removable: !isDefaultSkillSource(root) && root.scope !== "project",
-                // 自定义来源（用户手加的目录）：只有它能「永久删除」——按约定发现的来源删不掉。
-                custom: root.custom === true,
-                // 默认来源（dsh / hub）：界面据此隐藏来源开关、只显示「可管理」标记。
-                defaultSource: isDefaultSkillSource(root),
-                toggleable: root.toggleable,
-                native: root.native,
-                rank: root.rank,
-                scope: root.scope || "user",
-                exists: false,
-                truncated: false,
-                removed: true,
-                enabled: false,
-                skills: [],
-            });
-            continue;
-        }
-        // 即使项目 .dsh/skills 尚不存在，也要把可写根返回给创建表单；只读项目根仍按实际存在性展示。
-        if (root.scope === "project" && !exists && root.kind !== "project-dsh")
-            continue;
-        if (truncated)
-            result.warnings.push({
-                code: "warning.scan.truncated",
-                params: { path: root.path },
-                error: `技能扫描达到遍历上限，部分技能未显示: ${root.path}`,
-            });
-        const skills = [];
-        for (const e of entries) {
-            const policy = effectiveSkillPolicy(policyResult, root, e);
-            const managerEnabled = policyResult.writable !== false &&
-                policy.sourceEnabled &&
-                policy.override !== false;
-            skills.push({
-                name: e.name,
-                declaredName: e.declaredName,
-                kind: e.kind,
-                description: e.description,
-                modelInvocable: e.modelInvocable,
-                userInvocable: e.userInvocable,
-                invocationPolicyValid: e.invocationPolicyValid,
-                hasFrontmatter: e.hasFrontmatter,
-                loadable: e.loadable,
-                managerEnabled,
-                managerOverride: policy.override === undefined ? null : policy.override,
-                effectiveModelInvocable: policy.modelInvocable,
-                effectiveUserInvocable: policy.userInvocable,
-                diagnostics: e.diagnostics,
-                path: e.docPath,
-            });
-            all.push({
-                root,
-                entry: e,
-                managerEnabled,
-                policy,
-                view: skills[skills.length - 1],
-            });
-        }
-        result.roots.push({
-            key: root.key,
-            ...(root.kind ? { kind: root.kind } : {}),
-            ...(root.localeKey ? { localeKey: root.localeKey } : {}),
-            path: root.path,
-            label: root.label,
-            mutable: root.mutable,
-            // 是否提供「删除」：dsh / hub / 项目级 .dsh/skills 为 true；
-            // 外部 Agent 与自定义绝对路径来源为 false（只读）。
-            deletable: root.deletable === true,
-            toggleable: root.toggleable,
-            native: root.native,
-            rank: root.rank,
-            scope: root.scope || "user",
-            ...(root.projectRoot
-                ? {
-                    projectRoot: root.projectRoot,
-                    projectName: root.projectName,
-                    workspaceCwds: root.workspaceCwds,
-                }
-                : {}),
-            exists,
-            truncated: truncated === true,
-            // 界面用：能否从管理器「移除」（不再读取）。dsh / hub / 项目级不可移除。
-            removable: !isDefaultSkillSource(root) && root.scope !== "project",
-            // 自定义来源（用户手加的目录）：只有它能「永久删除」——按约定发现的来源删不掉。
-            custom: root.custom === true,
-            // 默认来源（dsh / hub）：界面据此隐藏来源开关（它们不能停用），换成「可管理」标记。
-            defaultSource: isDefaultSkillSource(root),
-            removed: false,
-            enabled: policyResult.writable !== false &&
-                (root.scope === "project" ||
-                    isDefaultSkillSource(root) ||
-                    policyResult.state.sources[root.key] !== false),
-            skills,
-        });
-    }
-    const userItems = all.filter((item) => item.root.scope !== "project");
-    const preferredSkills = policyResult.state.preferredSkills || null;
-    markWinners(userItems, { preferred: preferredSkills });
-    const projectGroups = new Map();
-    for (const item of all.filter((candidate) => candidate.root.scope === "project")) {
-        const group = projectGroups.get(item.root.projectRoot) || [];
-        group.push(item);
-        projectGroups.set(item.root.projectRoot, group);
-    }
-    for (const projectItems of projectGroups.values()) {
-        // 用户级条目参与该 workspace 的优先级判定，但不把其全局视图标记为“被某项目覆盖”。
-        const userCopies = userItems.map((item) => ({
-            ...item,
-            view: { ...item.view },
-        }));
-        markWinners([...projectItems, ...userCopies], { preferred: preferredSkills });
-    }
-    const seenProjects = new Set();
-    for (const root of result.roots.filter((item) => item.scope === "project")) {
-        if (seenProjects.has(root.projectRoot))
-            continue;
-        seenProjects.add(root.projectRoot);
-        result.projects.push({
-            root: root.projectRoot,
-            name: root.projectName,
-            workspaceCwds: root.workspaceCwds,
-        });
-    }
-    result.summary = {
-        total: all.length,
-        enabled: all.filter((item) => item.view.enabled === true).length,
-        disabled: all.filter((item) => item.entry.loadable && item.policy.enabled === false).length,
-        issues: all.reduce((count, item) => count + item.entry.diagnostics.length + (item.view.shadowedBy ? 1 : 0), 0),
-    };
-    return result;
-}
 export { KEBAB_RE };