dsh-plugin-tool-management 0.19.1 → 0.20.1

package/lib/skills/upload-pipeline.js

@@ -12,8 +12,8 @@ import { promises as fs } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { unzipSync } from "fflate";
 import { isSameOrDescendant } from "../paths.js";
-import { parseSkillDoc, toKebab } from "./frontmatter.js";
-import { attachCode, codedError, entryPath, lstatOrNull, MAX_ENTRY_NAME_LENGTH, renameWithRetry, } from "./core-util.js";
+import { parseSkillDoc, rewriteDeclaredName, toKebab } from "./frontmatter.js";
+import { attachCode, codedError, entryPath, lstatOrNull, MAX_ENTRY_NAME_LENGTH, renameWithRetry, temporaryPath, } from "./core-util.js";
 import { analyzeSource, collectCandidates, MAX_SOURCE_DEPTH, preflightCandidates, replaceWithCopy, } from "./import-pipeline.js";
 import { managerHomePath, resolvedPath, skillCreateRootPath } from "./skill-roots.js";
 export const KEBAB_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -28,6 +28,37 @@ export async function pathsOverlap(a, b) {
     const right = await resolvedPath(b);
     return isSameOrDescendant(left, right) || isSameOrDescendant(right, left);
 }
+/** 目标根下已存在的条目路径：目录 `<name>` 或文件 `<name>.md`，两者都可能占。 */
+async function existingEntryPaths(root, name) {
+    const paths = [join(root, name), join(root, `${name}.md`)];
+    const existing = [];
+    for (const path of paths) {
+        try {
+            await fs.stat(path);
+            existing.push(path);
+        }
+        catch { }
+    }
+    return existing;
+}
+/**
+ * 退号取名：`foo` → `foo-1` → `foo-2`…（与 skill-trash 的 nextFreeSkillName、
+ * 界面 `uniqueName` 的 'dash' 档同一口径）。占用表 = 磁盘现有条目 + 本批次已定名
+ * （`claimed`：防先退号出来的名字又被同批后续候选占用）。候选本身不合法
+ * （entryPath 为 null，如超长）时直接放弃 —— 再往后试也不会变合法。
+ */
+async function nextFreeImportName(root, base, claimed) {
+    for (let i = 1; i <= 999; i += 1) {
+        const candidate = `${base}-${i}`;
+        if (claimed.has(candidate))
+            continue;
+        if (entryPath(root, candidate) === null)
+            return null;
+        if ((await existingEntryPaths(root, candidate)).length === 0)
+            return candidate;
+    }
+    return null;
+}
 export async function importSkill(source, log, options = {}) {
     const targetRoot = skillCreateRootPath();
     const conflict = options.conflict === "overwrite" ? "overwrite" : "skip";
@@ -88,6 +119,9 @@ export async function importSkill(source, log, options = {}) {
             entryPath(targetRoot, candidate.kebab) !== null)
             nameCount.set(candidate.kebab, (nameCount.get(candidate.kebab) || 0) + 1);
     }
+    // 本批次已定名的集合（含退号名）：批量内同名由上方的 nameCount 先拒掉，这里防的是
+    // 退号名与后续候选原名的交叉占用（`foo` 退号成 `foo-1`，同批又来个 `foo-1`）。
+    const claimed = new Set();
     function failureResult() {
         return {
             ok: false,
@@ -122,31 +156,39 @@ export async function importSkill(source, log, options = {}) {
             });
             continue;
         }
+        const existing = await existingEntryPaths(targetRoot, c.kebab);
+        let renamedFrom;
+        if (existing.length) {
+            // 上传导入撞名一律退号新增（用户 2026-10-15）：旧行为是静默跳过，结果里只多
+            // 一行"已跳过"，用户想要的那份根本没进来。`skill-import`（目录导入）不带
+            // dedupe，仍是 skip / overwrite 二选一。
+            if (options.dedupe !== true) {
+                conflicts.push({
+                    name: c.kebab,
+                    source: c.source,
+                    isDir: c.isDir,
+                    paths: existing,
+                });
+                continue;
+            }
+            const free = await nextFreeImportName(targetRoot, c.kebab, claimed);
+            if (!free) {
+                failed.push({
+                    source: c.source,
+                    error: `同名条目太多，无法生成退号名称: ${c.kebab}`,
+                    code: "error.import.renameExhausted",
+                    params: { name: c.kebab },
+                });
+                continue;
+            }
+            renamedFrom = c.kebab;
+            c.kebab = free;
+        }
         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 });
+        claimed.add(c.kebab);
+        pending.push({ name: c.kebab, source: c.source, isDir: c.isDir, dest, renamedFrom });
     }
     if (pending.length === 0 && conflicts.length === 0)
         return failureResult();
@@ -164,6 +206,31 @@ export async function importSkill(source, log, options = {}) {
     for (const p of pending) {
         try {
             const warnings = await replaceWithCopy(p.source, p.dest, p.isDir);
+            // 退号落盘后把声明名改成新名字：`canonicalSkillName` 取的是 frontmatter 的
+            // `name:`，只改目录会"看着叫 foo-1、其实还是 foo"—— 两份同名技能在「同名
+            // 首选」里被并成一组，而那颗开关挑的是来源，按下去什么都不会变（skill-trash.ts
+            // 的 retitleRestoredSkill 同一理由）。返回 null（没有 `name:` 行）是良性的：
+            // 声明名为空时 canonicalSkillName 回落到条目名，退号目录名就是它的名字。
+            // 写盘失败记一条 warning，不阻断导入 —— 技能已按退号名落盘。
+            if (p.renamedFrom) {
+                try {
+                    const docPath = p.isDir ? join(p.dest, "SKILL.md") : p.dest;
+                    const doc = await fs.readFile(docPath, "utf8");
+                    const content = rewriteDeclaredName(doc, p.name);
+                    if (content !== null) {
+                        const temp = temporaryPath(docPath, "retitle");
+                        await fs.writeFile(temp, content, "utf8");
+                        await renameWithRetry(temp, docPath);
+                    }
+                }
+                catch (e) {
+                    warnings.push({
+                        code: "warning.retitleFailed",
+                        params: { path: p.dest },
+                        error: String(e && e.message ? e.message : e),
+                    });
+                }
+            }
             imported.push({ name: p.name, overwritten: false, warnings });
             if (log)
                 log("import", `导入 ${p.source} -> ${p.dest}`);
@@ -337,8 +404,25 @@ export async function prepareUploadedSource(sessionRoot, input) {
         await writeUploadedEntries(contentRoot, input && input.entries);
     const rootSkill = join(contentRoot, "SKILL.md");
     const rootSkillStat = await lstatOrNull(rootSkill);
-    if (!rootSkillStat || !rootSkillStat.isFile())
-        return contentRoot;
+    if (!rootSkillStat || !rootSkillStat.isFile()) {
+        // 没有根级 SKILL.md：剩下的合法形态只有两种 —— 根级 .md（单文件技能）或子目录
+        // 带 SKILL.md（批量），与 importSkill 的 collectCandidates 收录口径一一对应。
+        // 两者都不占，这个包就打不开：此时说清缺的是 SKILL.md、以及是哪个包（用户
+        // 2026-10-15：老报错是 importSkill 的空来源错误，带着 uuid 临时目录路径、落在
+        // 通用「文件要求」段，认不出是谁、也看不出缺什么）。
+        const items = await fs.readdir(contentRoot, { withFileTypes: true });
+        for (const it of items) {
+            if (it.isFile() && it.name.toLowerCase().endsWith(".md"))
+                return contentRoot;
+            if (it.isDirectory()) {
+                const st = await lstatOrNull(join(contentRoot, it.name, "SKILL.md"));
+                if (st && st.isFile())
+                    return contentRoot;
+            }
+        }
+        const label = String((input && input.name) || "").trim() || "上传内容";
+        throw codedError(`${label} 中未找到 SKILL.md：需放在根目录，或放在某个子目录下`, "error.upload.noSkillMd", { name: label });
+    }
     const doc = parseSkillDoc(await fs.readFile(rootSkill, "utf8"));
     const fallback = String((input && input.name) || "uploaded-skill")
         .replace(/\.zip$/i, "")

package/lib/subagents/catalog.js

@@ -80,8 +80,10 @@ export function createSubagentCatalog(deps, opts = {}) {
     let allowed = [];
     let loadedAt = Number.NEGATIVE_INFINITY;
     let inflight = null;
-    // 渲染结果按**深度**缓存：过滤只依赖深度这一个整数，而实际出现的深度就 0/1/2 三档，
-    // 于是"每个 step 同步渲染"退化成一次查表。重算成功时清空。
+    // 渲染结果按**深度 + 尾句前提**缓存：过滤只依赖深度这一个整数（实际出现的深度就 0/1/2 三档），
+    // 而尾句点不点名 `subagent_manager_list` 取决于**这个 agent 手里有没有它**（2026-10-14
+    // 审查 P1-8：此前只按深度缓存，于是尾句用的是第一个来问的 agent 的答案）。
+    // 两维都是小枚举，于是"每个 step 同步渲染"退化成一次查表。重算成功时清空。
     const rendered = new Map();
     const recompute = async () => {
         try {
@@ -102,11 +104,13 @@ export function createSubagentCatalog(deps, opts = {}) {
             if (now() - loadedAt > ttlMs)
                 void revalidate();
             const depth = subagentDepthOf(agent);
-            const cached = rendered.get(depth);
+            const visible = deps.listToolVisible ? deps.listToolVisible(agent) : true;
+            const key = depth + '|' + (visible ? '1' : '0');
+            const cached = rendered.get(key);
             if (cached !== undefined)
                 return cached;
-            const out = renderSubagentCatalog(allowed.filter((p) => catalogInjectedAt(p, depth)), maxEntries, maxDescription, deps.listToolVisible ? deps.listToolVisible() : true);
-            rendered.set(depth, out);
+            const out = renderSubagentCatalog(allowed.filter((p) => catalogInjectedAt(p, depth)), maxEntries, maxDescription, visible);
+            rendered.set(key, out);
             return out;
         },
         catalogVisibleAt: (depth) => allowed.some((p) => catalogInjectedAt(p, depth)),

package/lib/subagents/service.js

@@ -196,6 +196,24 @@ export function createSubagentService(ctx, opts) {
                 : { ...res, stateSyncError: reason };
         }
     }
+    /**
+     * 目标目录里第一个空出来的退号名：`写作助手` → `写作助手（1）` → `写作助手（2）`…
+     * （全角括号，与界面 `uniqueName` 同一写法 —— 人设名就是文件名，不做任何归一化，
+     * `validPersonaName` 也放行全角括号）。
+     *
+     * 候选本身不合法（超长 / 空）时直接放弃：再往后试也不会变合法。
+     */
+    async function nextFreePersonaName(name) {
+        for (let i = 1; i <= 999; i += 1) {
+            const candidate = `${name}（${i}）`;
+            if (!validPersonaName(candidate))
+                return null;
+            const taken = await readFile(join(dir, candidate + '.md'), 'utf8').then(() => true).catch(() => false);
+            if (!taken)
+                return candidate;
+        }
+        return null;
+    }
     /** list() 输出统一附上 enabled：文件缺失 → 全 true；否则按集合。 */
     function withEnabled(docs, set) {
         if (set === null)
@@ -361,11 +379,30 @@ export function createSubagentService(ctx, opts) {
                 return { ok: false, error: `回收站条目不存在: ${id}` };
             if (!validPersonaName(entry.name))
                 return { ok: false, error: `回收站里的人设名不合法: ${entry.name}` };
-            const target = join(dir, entry.name + '.md');
-            const exists = await readFile(target, 'utf8').then(() => true).catch(() => false);
-            // 绝不覆盖：同名人设已经存在时如实拒绝，让人自己决定怎么办。
-            if (exists)
-                return { ok: false, error: `无法恢复，同名人设已存在: ${entry.name}` };
+            /*
+             * 同名先问一句（用户 2026-10-14）：撞名时**默认仍拒绝**（绝不覆盖），但把候选名字一起
+             * 回（`params.next`），界面弹窗才能如实写出"确认后会叫 `写作助手（1）`"；用户确认后带
+             * `dedupe: true` 重来，这一次真的按退号的名字落盘。
+             *
+             * `dedupe` 缺省即旧行为：这条 op 目前只有界面在用，但默认值必须是"拒" —— 一个默认
+             * 静默改名的恢复口，早晚会有人踩。
+             */
+            let name = entry.name;
+            const exists = await readFile(join(dir, name + '.md'), 'utf8').then(() => true).catch(() => false);
+            if (exists) {
+                const next = await nextFreePersonaName(name);
+                if (args?.dedupe !== true || !next) {
+                    // 专用错误码（四个回收站统一）：界面按它认出"这是撞名"并弹确认窗。
+                    return {
+                        ok: false,
+                        error: `已存在同名人设: ${name}`,
+                        code: 'error.dup.conflict',
+                        params: { name, ...(next ? { next } : {}) },
+                    };
+                }
+                name = next;
+            }
+            const target = join(dir, name + '.md');
             try {
                 await mkdir(dir, { recursive: true });
                 await moveOutOfTrash('subagents', id, 'persona.md', target);
@@ -375,8 +412,9 @@ export function createSubagentService(ctx, opts) {
             }
             await purgeTrashEntry('subagents', id);
             // v0.8.5：回收站恢复默认不启动（与新建/导入同口径）。
+            // 启停名单必须按**最终落盘的名字**写：退号恢复时它不是回收站里的原名。
             cache = null;
-            return withEnabledNote({ ok: true, name: entry.name }, () => materializeEnabledExcluding([entry.name]));
+            return withEnabledNote({ ok: true, name, renamed: name !== entry.name }, () => materializeEnabledExcluding([name]));
         },
         'subagent-trash-delete': async (args) => {
             const id = String((args && args.id) || '').trim();

package/lib/subagents/tools.js

@@ -15,11 +15,18 @@ export function text(v) {
  *      绑定的人设启用，见 archive-engine 的 applySubagentSwitches）。
  *   ② 场景绑定校验（设计 §3.3）：启用场景的 subagents 并集；空并集 = 全部可用。
  * 之前只有②：全局默认所有子智能体都进上下文，没有开关可言。
+ *
+ * `includeUnavailable`（2026-10-14 对抗性审查 P1-7）**只给 `subagent_manager_list` 的
+ * `all=true` 用**，两道闸一起放开：停用的人设此前**在任何地方都查不到** —— 注入目录只列可用的，
+ * `subagent_manager_switch` 又默认关着，于是模型既发现不了它、也就无从提示用户去启用。
+ * 另外三个 `*_list`（MCP / 技能 / 记忆）早就有 `all=true` 这个出口，人设是缺的那一个。
+ * 注意放开的只是**可见性**：`subagent_manager_run` 仍然按完整两道闸判"能不能委派"，
+ * 列出来 ≠ 可委派（回执里那句「人设不可用」照旧成立）。
  */
-export async function filterBySceneBinding(docs, enabledSceneLists) {
-    const live = docs.filter((d) => d.enabled !== false);
+export async function filterBySceneBinding(docs, enabledSceneLists, includeUnavailable = false) {
+    const live = includeUnavailable ? docs : docs.filter((d) => d.enabled !== false);
     const bound = new Set(enabledSceneLists.flat());
-    if (!bound.size)
+    if (includeUnavailable || !bound.size)
         return { allowed: live, reason: null };
     const allowed = live.filter((d) => bound.has(d.name));
     return { allowed, reason: allowed.length ? null : `当前启用场景的子智能体绑定: ${[...bound].join('、')}` };
@@ -27,19 +34,32 @@ export async function filterBySceneBinding(docs, enabledSceneLists) {
 export function defineSubagentManagerListTool(subagents) {
     return {
         name: 'subagent_manager_list',
-        description: 'List personas (pre-configured subagent profiles) with their descriptions. The「可委派的子智能体」reminder carries the same catalog; call this for the always-current full list.',
-        parameters: {},
+        // `depth-filtered` 删掉（2026-10-15 注入文本审查）：注入深度是**注入侧**的实现细节，
+        // 模型看到的是"目录里有哪些人设"，`catalogDepth` 那个词对它没有任何可操作性。
+        description: 'List personas (pre-configured subagent profiles) with their descriptions. The「当前子智能体」reminder carries a view of the same catalog; call this for the always-current full list, or pass all=true to include personas that are disabled or outside the active scene.',
+        parameters: {
+            all: { type: 'boolean', description: 'Include disabled personas and ones outside the active scene (default false). Listed ≠ delegable: `run` still refuses those.' },
+        },
         output: {
             schema: { type: 'string' },
             render: (_a, v) => text(String(v)),
         },
-        async execute(_args, exec) {
-            const { allowed, reason } = await filterBySceneBinding(await subagents.list(), await subagents.sceneLists());
+        async execute(args, exec) {
+            const includeUnavailable = Boolean(args?.all === true);
+            const docs = await subagents.list();
+            const { allowed, reason } = await filterBySceneBinding(docs, await subagents.sceneLists(), includeUnavailable);
             // 这里**不再按深度过滤**（2026-09-17 用户裁定，方案 A）：`catalogDepth` 只决定常驻目录
             // 注入到哪些会话，与"能不能委派"无关 —— 委派由官方决定（`dsh-tool-subagent` 默认能嵌套
             // 到 3 层）。此前按深度过滤等于把可用人设藏起来：目录不注入时模型只能靠这个工具查，
             // 而工具又不列全，结果是"明明能委派却查不到人设"。
-            const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(无描述)') + (p.continuable === true ? CONTINUABLE_MARK : ''));
+            // `all=true` 时**标出哪些不可用**：只列名字的话，模型照样分不清哪个能直接委派
+            // （与技能列表标 `shadowed-by:` 同一条理由 —— 列出来不等于能用）。
+            const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(无描述)') +
+                (p.continuable === true ? CONTINUABLE_MARK : '') +
+                (includeUnavailable ? (p.enabled === false ? '（已停用，需先启用）' : '') : ''));
+            // 默认口径下有多少个没列出来（停用的 + 不在启用场景里的）：不报的话，模型看到一份短名单
+            // 会当成"本机只有这些人设"。数量照报，与另外三个 list 的表头同一口径。
+            const hiddenCount = includeUnavailable ? 0 : docs.length - allowed.length;
             let notice = '';
             try {
                 notice = typeof subagents.noticeFor === 'function' ? await subagents.noticeFor(exec) : '';
@@ -47,7 +67,9 @@ export function defineSubagentManagerListTool(subagents) {
             catch {
                 notice = '';
             }
-            return '人设子智能体（' + allowed.length + '）：\n' + (lines.join('\n') || '(无)') + (reason ? '\n注意：' + reason : '') + notice;
+            const header = '人设子智能体（' + allowed.length + '）' +
+                (hiddenCount > 0 ? '（另有 ' + hiddenCount + ' 个停用或不在当前场景，传 all=true 查看）' : '') + '：\n';
+            return header + (lines.join('\n') || '(无)') + (reason ? '\n注意：' + reason : '') + notice;
         },
     };
 }
@@ -69,8 +91,13 @@ export function defineSubagentManagerRunTool(subagents) {
         // `how` 行（context-inject.ts 的 `DOMAIN_FRAME.subagents`）已经逐字说过一遍，而两份都在
         // 每轮上下文里 = 同一件事付两次 token。留注入那份（它出现在"正在选工具"的那一刻）。
         // 代价如实记下：子智能体域被关掉、或走压制型预设时上下文里没有那条 how 行，模型只剩本
-        // 描述与 `agent` 参数说明（"Persona name from subagent_manager_list"）—— 够它认出这条是
-        // 带人设的委派通道，但"没有人设贴合时才用官方那两个"这层分界就没人说了。
+        // 描述与 `agent` 参数说明 —— 够它认出这条是带人设的委派通道，但"没有人设贴合时才用官方
+        // 那两个"这层分界就没人说了。
+        //
+        // 2026-10-14（对抗性审查 P0-2）：`subagent_manager_list` 已移出出厂默认隐藏名单，所以
+        // `agent` 参数说明可以点名它（此前只能写"Persona name."，因为那条工具默认不在模型手里）。
+        // 注释里那句 "Persona name from subagent_manager_list" 从 2026-09-23 起就与代码逐字不符，
+        // 现在代码终于跟上了。
         //
         // 2026-09-23（用户裁定）：本工具的 `task` / `inherit` 两个参数说明与上面的 Modes 段
         // **逐字重复**，而工具表每轮都发 —— 同一件事付两次 token。实测 `subagent_manager_run`
@@ -78,11 +105,14 @@ export function defineSubagentManagerRunTool(subagents) {
         // 最贵的单个参数。收完两处重复后目标 ≈325 tok。判据是"删掉的那句在描述里已经有了吗"：
         // Modes 段留着（它是模型的入口），参数说明只留"这一段独有的信息"。
         // `inherit` 那句"轮中委派拿不到当前轮"必须留 —— 它是这条参数唯一会让人写错 task 的地方。
-        description: 'Run a named persona as a subagent: it gets the persona as its own system prompt, works on `task`, and returns only its final output. A persona marked「允许追问」instead returns an agent id and runs in the background — continue it with `send_message`.\n\nModes: by default a fresh child that cannot see this conversation, so `task` must be self-contained. With `inherit: true` it also gets this conversation\'s **finished** turns (like the host\'s `subagent_fork`) — the current turn is never included, so a mid-turn hand-off still needs a self-contained `task`.\n\n`task` = the goal plus the context it needs; leave method and output format to the persona.\n\nUse it when the work matches a persona in the「可委派的子智能体」reminder (a review, an investigation, a piece of writing) and the detail should not sit in your own context. Not for reading a file (Read), finding a definition (Grep/Glob), or touching two or three files.',
+        description: 'Run a named persona as a subagent: it gets the persona as its own system prompt, works on `task`, and returns only its final output. A persona marked「允许追问」instead returns an agent id and runs in the background — continue it with `send_message`.\n\nModes: by default a fresh child that cannot see this conversation, so `task` must be self-contained. With `inherit: true` it also gets this conversation\'s **finished** turns (like the host\'s `subagent_fork`) — the current turn is never included, so a mid-turn hand-off still needs a self-contained `task`.\n\n`task` = the goal plus the context it needs; leave method and output format to the persona.\n\nUse it when the work matches a persona in the「当前子智能体」reminder (a review, an investigation, a piece of writing) and the detail should not sit in your own context. Not for reading a file (Read), finding a definition (Grep/Glob), or touching two or three files.',
         parameters: {
-            agent: { type: 'string', required: true, description: 'Persona name.' },
-            task: { type: 'string', required: true, description: 'The task for the subagent. Self-contained by default; with inherit: true only state what is new.' },
-            inherit: { type: 'boolean', description: 'Let the subagent see this conversation\'s finished turns (the current turn is never included). Default false = a fresh child.' },
+            agent: { type: 'string', required: true, description: 'Persona name — see the「当前子智能体」reminder, or list personas with subagent_manager_list.' },
+            // `task` 的说明只留"这是什么"（2026-10-15 注入文本审查）：上面描述里那句
+            // "leave method and output format to the persona." 此前在这里**逐字重复**了一遍
+            // （57 字符），而模型填这个参数时两处都在手上 —— 同一件事付两次 token。
+            task: { type: 'string', required: true, description: 'The task for the subagent.' },
+            inherit: { type: 'boolean', description: 'Inherit this conversation\'s finished turns (current turn excluded). Default false.' },
         },
         output: {
             schema: { type: 'string' },

package/lib/tool-table-switch.js

@@ -3,8 +3,8 @@ import { addPreset, buildToolTableReport, DEFAULT_HIDDEN_TOOLS, dropPreset, migr
 export function createToolTableSwitch(deps) {
     // ---------- 模型工具表开关（侧车 `tool-table.json`，界面在「兼容」页）----------
     // 工具表按**每个请求**付钱：20 个工具的整份定义合计 ≈3,769 tok 每轮都在。关掉某几个，
-    // 它们整份不进请求（实测口径与取舍见 src/tools/table.ts 的文件头）。**出厂就已经关了十五条**
-    // （20 条里实发只剩 5 条）—— 名单、判据与代价在 `DEFAULT_HIDDEN_TOOLS`，只在这个人从没记过
+    // 它们整份不进请求（实测口径与取舍见 src/tools/table.ts 的文件头）。**出厂就已经关了十四条**
+    // （20 条里实发 6 条）—— 名单、判据与代价在 `DEFAULT_HIDDEN_TOOLS`，只在这个人从没记过
     // 选择时铺（见下面的 `toolTableSettingsFrom`）。
     //
     // 为什么放在目录之前：两个目录的「用 `X` 查」提示要跟着这份设置变（工具关掉后那句话
@@ -33,8 +33,8 @@ export function createToolTableSwitch(deps) {
         // 0.14.0 旧工具名迁移：读侧翻译一次并**回写盘**（幂等）。不迁移的话，用户"关掉了某条"
         // 的意图会在新名字上静默失效 —— 那条工具照旧每轮发出去，而界面上看不出来。
         // 写失败不回滚本次读取：内存里已经是迁移后的值，下次读会再试一次。
-        // 侧车不存在（`readJsonFile` 给 null）= 用户从没记过选择 ⇒ 用**出厂默认**（十五条不发，
-        // 实发 5 条；判据与代价见 tools/table.ts 的 DEFAULT_HIDDEN_TOOLS）。存过盘的
+        // 侧车不存在（`readJsonFile` 给 null）= 用户从没记过选择 ⇒ 用**出厂默认**（十四条不发，
+        // 实发 6 条；判据与代价见 tools/table.ts 的 DEFAULT_HIDDEN_TOOLS）。存过盘的
         // 一律照盘上那份，包括显式的 `hidden: []` —— 那是"我全都要"，不能被默认值盖掉。
         const migrated = migrateLegacyToolNames(toolTableSettingsFrom(raw));
         const value = migrated.settings;
@@ -59,7 +59,7 @@ export function createToolTableSwitch(deps) {
     }
     /**
      * 同步快照（热路径用：工具门禁每次调用、注入通道每个 step 都要问一句）。还没加载时先给
-     * **空集**并异步预热 —— 空集不是出厂默认（出厂关着五条），是刻意的：预热前的这一瞬与
+     * **空集**并异步预热 —— 空集不是出厂默认（出厂关着十四条），是刻意的：预热前的这一瞬与
      * 用户的选择可能不一致，但方向必须是安全的那一侧（不隐藏任何东西，绝不因为读盘慢而让
      * 工具凭空消失）。
      */
@@ -71,7 +71,7 @@ export function createToolTableSwitch(deps) {
         return toolTableCache.off;
     }
     const toolTableRows = () => [...toolTableSizes].map(([name, bytes]) => ({ name, bytes }));
-    const toolTableReport = (hidden = [...toolTableHidden()]) => buildToolTableReport(toolTableRows(), hidden);
+    const toolTableReport = (hidden = [...toolTableHidden()]) => buildToolTableReport(toolTableRows(), hidden, deps.carrierHiddenTools ? deps.carrierHiddenTools() : []);
     /** 落盘 + 同步内存缓存（三条写路径共用：改勾选 / 存方案 / 删方案）。 */
     async function writeToolTableSettings(next) {
         await deps.ensurePaths();

package/lib/tools/deps.js

@@ -21,3 +21,46 @@ export function toolNameList(list) {
     const head = list.slice(0, TOOL_NAME_LIST_CAP).join('、');
     return list.length > TOOL_NAME_LIST_CAP ? head + ' 等 ' + list.length + ' 项' : head;
 }
+/**
+ * 按名字找技能落在哪个来源（root）。
+ *
+ * 为什么需要它（2026-10-15 smoke-test P0-1）：`skill-create` 的默认落点是 **hub**
+ * （`tool-management/skills/`，与界面「创建技能」一致），而 `skill-enable` / `skill-disable` /
+ * `skill-prefer` / `skill-delete` 这些 op 的默认 root 是 **dsh**。于是「建完就启用」这条
+ * 最自然的链路必然报「技能不存在」—— 同一个动作在工具侧落 hub、在开关侧查 dsh。
+ * 默认值改哪边都不对（面板显式传 root，两边都依赖自己的默认），所以判定放到工具侧：
+ * **没给 root 就在全部来源里按名字找胜出副本**，找到哪个就用哪个。
+ *
+ * 选取口径与 `skill_manager_read` 同一套（`markWinners` 已标出影子副本）：先取没被
+ * `shadowedBy` 盖住的那一份（同名组里胜出的只有一个），都没有就取第一个。
+ */
+export async function locateSkillRoot(skillsOps, name) {
+    const wanted = String(name || '').trim();
+    if (wanted === '')
+        return { ok: true, root: null, roots: [] };
+    let state;
+    try {
+        state = await skillsOps['skill-state']({});
+    }
+    catch {
+        return { ok: false, root: null, roots: [] };
+    }
+    if (!state || state.ok === false)
+        return { ok: false, root: null, roots: [] };
+    const roots = [];
+    const hits = [];
+    for (const root of (state.data && state.data.roots) || []) {
+        roots.push(String(root.key || ''));
+        for (const skill of root.skills || []) {
+            // 与 list / read / save 同一套名字口径：`declaredName || name`，再比目录名。
+            if (String(skill.declaredName || skill.name || '') !== wanted && String(skill.name || '') !== wanted)
+                continue;
+            hits.push({
+                rootKey: String(root.key || ''),
+                shadowedBy: skill.shadowedBy && skill.shadowedBy.root ? String(skill.shadowedBy.root) : '',
+            });
+        }
+    }
+    const winner = hits.find((hit) => hit.shadowedBy === '') || hits[0];
+    return { ok: true, root: winner ? winner.rootKey : null, roots };
+}