dsh-plugin-tool-management 0.16.6 → 0.17.0

package/lib/scenes/candidates.js

@@ -13,6 +13,8 @@
 //
 // 依赖全部经 deps 显式传入。注意 \`toolKeyParts\` 留在 index.ts：场景档案引擎也在用它，
 // 放进本文件会让两个域互相引用。
+import { MCP_TOOL_PREFIX } from '../host-names.js';
+import { serverNameCandidates } from '../host-names.js';
 import { presetRosterOf } from '../compat/preset-reach.js';
 import { injectionFactsOf, readCompositionFacts, readCompositionText } from '../compat/preset-reach.js';
 /**
@@ -39,9 +41,25 @@ export function createCandidates(deps) {
             schemas = await tools.schemas();
         }
         catch { /* 无 live 工具 → 仅启停表 */ }
+        // 切分的候选 serverName 集合必须与 `serverKnownTools`（index.ts）同源 —— 同一批来源、
+        // 同一个 builder，否则「服务器名含 `__`」时两处会把同一个全名切成不同的 (server, tool)
+        // （2026-09-30 审查 N1）。三个来源里补丁那份是唯一与切分结果无关的（另两份是插件自己
+        // 写出来的：停用表键来自界面勾选、缓存键来自上一次切分），缺它会在首次遇到含 `__` 的名字时
+        // 切错并锁死。任一份读不到就退化为其余两份（少候选 = 少命中，不会多命中）。
+        let known = {};
+        try {
+            known = await mcp.readKnownMcpTools();
+        }
+        catch { /* 缓存不可读 → 仅停用表 */ }
+        let configured = [];
+        try {
+            configured = await mcp.configuredServerNames();
+        }
+        catch { /* 补丁读不到 → 仅另两份 */ }
+        const serverNames = serverNameCandidates(configured, disabled, known);
         const liveByServer = {};
         for (const s of schemas) {
-            const p = toolKeyParts(String((s && s.name) || ''));
+            const p = toolKeyParts(String((s && s.name) || ''), serverNames);
             if (!p)
                 continue;
             const list = liveByServer[p.server] || (liveByServer[p.server] = []);
@@ -214,7 +232,7 @@ export function createCandidates(deps) {
                         continue;
                     // MCP 工具名形如 `mcp__<server>__<tool>`：面向上百个条目，噪声大于价值 → 不进候选。
                     // 子代理照样能用当前在跑的 MCP —— 那份名单在 decideToolFilter 里运行时并进白名单。
-                    const names = (await presetToolNames(id)).filter((name) => !name.startsWith('mcp__'));
+                    const names = (await presetToolNames(id)).filter((name) => !name.startsWith(MCP_TOOL_PREFIX));
                     presets.push({
                         id,
                         name: String((p && (p.name || p.id)) || id),
@@ -236,7 +254,7 @@ export function createCandidates(deps) {
         }
         // 当前会话的工具即便没有任何预设可枚举，也要出现在候选里（否则选择器是空的）。
         for (const name of currentNames) {
-            if (name.startsWith('mcp__'))
+            if (name.startsWith(MCP_TOOL_PREFIX))
                 continue;
             const rec = byName.get(name) || { name, presets: new Set(), current: false };
             byName.set(name, rec);

package/lib/sessions/workspace.js

@@ -1056,8 +1056,11 @@ var ArchiveWorkspaceRegistry = class {
     /**
      * 永久删除一个会话及其全部痕迹（转录目录、工作区记账、归档标记、
      * 投影缓存行）。
+     *
+     * 级联只删**已归档**的子代理会话（审查 F10）；被保留的未归档子会话 id 通过
+     * `keptUnarchivedDescendants` 回给调用方，界面据此如实呈现，不假装整支都没了。
      * @param sessionId - 要删除的会话。
-     * @returns 持久化完成后的 `{ deleted: true }`。
+     * @returns `{ deleted: true }`，有被保留的未归档子会话时附带其 id。
      * @throws {@link ArchiveUnknownSessionError} 会话未知时抛出。
      */
     async deleteSession(sessionId) {
@@ -1144,7 +1147,9 @@ var ArchiveWorkspaceRegistry = class {
         await projCache?.whenIdle?.();
         if (projCache !== void 0)
             await projCache.delete(sessionId);
-        await this.deleteDescendants(sessionId, storedIndex);
+        // 级联只吃已归档的子会话；被保留（未归档）的 id 一路带回 op 层，让界面/模型
+        // 知道「父会话已删，但这一支没有全没」（审查 F10）。
+        const keptDescendants = await this.deleteDescendants(sessionId, storedIndex);
         await this.cleanSpill(sessionId);
         await this.removeTranscriptDirectory(sessionId);
         // 只有物理工件删除成功后才能提交记账清理；否则批量目标会因归档标记
@@ -1163,7 +1168,12 @@ var ArchiveWorkspaceRegistry = class {
         if (deletedHeader !== void 0)
             this.deletedIdentities.set(sessionId, headerIdentity(deletedHeader));
         this.publishDeletedSession(sessionId);
-        return { deleted: true };
+        return {
+            deleted: true,
+            ...(keptDescendants.length === 0
+                ? {}
+                : { keptUnarchivedDescendants: keptDescendants }),
+        };
     }
     /** 删除完成后通知全部客户端；新版不再通过伪造冷会话生命周期触发通知。 */
     publishDeletedSession(sessionId) {
@@ -1394,8 +1404,21 @@ var ArchiveWorkspaceRegistry = class {
     /** 尽力而为的级联删除：删除 `sessionId` 的 SUBAGENT 子会话。
      * 仅头部标记 `origin: "subagent"` 的会话参与：单凭 `parentSession` 有歧义
      *（fork 分支也携带它），而 fork 分支是独立的用户会话，绝不能被级联删除。
-     * @param storedIndex - 可选的批首 `id → header` 快照，见 {@link storedHeaderIndex}。 */
+     *
+     * **只级联「已归档」的子会话**（2026-09-30 审查 F10）。此前这里只按
+     * `parentSession + origin: subagent` 收集就逐个 `deleteSessionCore`，**完全不查归档集合**，
+     * 于是「只能删已归档」在**注册表层不成立** —— 删一个已归档父会话，会把它**未归档**的子代理
+     * 会话一起永久删掉。op 入口那层的收敛（`history-delete` / `deleteArchivedSessions`）拦不住
+     * 这条路：级联发生在删除主体内部，不经过任何 op 门禁。现在把不变量落到这里，而不是只写在
+     * 注释里 —— 未归档的一律**保留**（之后可单独归档再删），并记一条日志说明保留了哪些。
+     *
+     * 归档集合取 `requireState().archivedSessionIds`（权威），不取 `archivedSessionMetadata()`
+     * 那份有损投影；`requireState()` 抛错时**一个都不删**（fail-closed：宁可不级联，也不凭未知
+     * 状态做不可逆操作）。
+     * @param storedIndex - 可选的批首 `id → header` 快照，见 {@link storedHeaderIndex}。
+     * @returns 被保留（未归档）的子会话 id（含后代递归上来的），全部删净时为空数组。 */
     async deleteDescendants(sessionId, storedIndex) {
+        const kept = [];
         try {
             const descendants = [];
             const sessions = this.ctx.get("sessions");
@@ -1414,11 +1437,20 @@ var ArchiveWorkspaceRegistry = class {
                     !descendants.includes(header.id))
                     descendants.push(header.id);
             }
+            // 先取归档集合再动手：它抛错时一个子会话都不会被删（fail-closed）。
+            const archived = new Set(this.requireState().archivedSessionIds);
             for (const childId of descendants) {
+                if (!archived.has(childId)) {
+                    kept.push(childId);
+                    continue;
+                }
                 try {
                     if (!(await this.sessionKnown(childId, storedIndex)))
                         continue;
-                    await this.deleteSessionCore(childId, storedIndex);
+                    const result = await this.deleteSessionCore(childId, storedIndex);
+                    // 孙辈里被保留的同样要往上带，否则界面只看到最外一层。
+                    if (Array.isArray(result?.keptUnarchivedDescendants))
+                        kept.push(...result.keptUnarchivedDescendants);
                 }
                 catch (error) {
                     if (error instanceof ArchiveUnknownSessionError)
@@ -1426,10 +1458,13 @@ var ArchiveWorkspaceRegistry = class {
                     this.ctx.logger.warn(`archive-manager: cascade delete of subagent session "${childId}" (child of "${sessionId}") failed: ${String(error)}`);
                 }
             }
+            if (kept.length)
+                this.ctx.logger.warn(`archive-manager: cascade delete of "${sessionId}" kept ${kept.length} unarchived subagent session(s) — only archived sessions may be deleted: ${kept.join(", ")}`);
         }
         catch (error) {
             this.ctx.logger.warn(`archive-manager: descendant enumeration for deleted session "${sessionId}" failed: ${String(error)}`);
         }
+        return kept;
     }
     /** 尽力而为的 spill 清理：移除该会话作用域的 spill 目录。 */
     async cleanSpill(sessionId) {

package/lib/skills/core.js

@@ -302,6 +302,13 @@ function officialSkillRoot() {
                 deletable: false,
                 // 来源层无开关（同默认来源），单个技能可启停；overlay 以 599 压过官方
                 // provider 的 600，脚本从物化副本的真实路径执行。
+                //
+                // 残余风险（2026-09-30 审查 §5 F12，如实标注、不修）：`599` 是个**数字契约** ——
+                // 它只在"官方那个 provider 的 rank 恰好是 600"时成立。官方调档位（把内置技能提到
+                // 599 以上、或降到 599 以下）会让接管失效：要么官方内置技能重新注入、与 599 层并存
+                // （同名两份），要么本插件反向遮蔽掉本不该遮蔽的东西。rank 是纯数字、没有能力探测
+                // 能提前发现，doctor 也查不了（要枚举官方 provider 的注册参数）。所以记为**已知
+                // 假设**，列进 CHANGELOG 的宿主适配矩阵，官方更新时人工核对这一处。
                 toggleable: true,
                 native: false,
                 scope: "user",
@@ -2019,7 +2026,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 };
+    // 首选**可以**指向停用来源：这个写操作只记录一次选择，不启停任何东西，所以照旧写成功。
+    // 但「记录成功」不等于「已经生效」—— 停用不参与选赢家、且停用赢家仍要挡住低优先级副本
+    // （见 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}）` +
+            `当前处于停用状态，而它仍然挡住同名的其他副本 —— 两份都不生效。` +
+            `启用其中一份即可（启用这份，或改用另一份）。`,
+    };
 }
 async function safeExistingEntryPaths(root, name) {
     const paths = [];
@@ -2702,6 +2730,28 @@ export async function importSkill(source, log, options = {}) {
     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` 走的是更宽的一条（拒绝**所有**
+ * 点开头的段）—— 那里是历史口径，方向更保守，两边都安全，不必强行统一。
+ */
+function pathSegmentRewritten(part) {
+    if (/[\u0000-\u001f\u007f]/.test(part))
+        return true;
+    return part !== part.replace(/[.\s]+$/, "");
+}
 /**
  * 校验浏览器或 ZIP 提供的相对路径。上传内容始终写成普通文件，不解释 ZIP 的链接元数据。
  * 这样既不依赖浏览器泄露本机绝对路径，也不会让归档跨出管理器暂存目录。
@@ -2727,6 +2777,7 @@ function normalizeUploadPath(input) {
         parts.some((part) => !part ||
             part === "." ||
             part === ".." ||
+            pathSegmentRewritten(part) ||
             part.length > MAX_ENTRY_NAME_LENGTH ||
             WINDOWS_DEVICE_NAME_RE.test(part))) {
         throw codedError(`上传条目路径非法: ${raw}`, "error.upload.path", {
@@ -3110,7 +3161,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 +3190,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;
@@ -3288,14 +3351,21 @@ function markWinners(items, options = {}) {
     const preferred = options.preferred;
     for (const [canonicalName, [winner, ...shadowed],] of groupLoadableSkillsByName(items, preferred)) {
         winners.set(canonicalName, winner);
-        // 只有「首选命中且确实赢了」才算首选；来源被停用/移除时不谎报。
+        // `preferred` = 「这份显式选择**记录在案**且它确实赢了同名之争」，**不等于它正在生效**：
+        // 首选来源自己停用时它照样赢（停用不参与选赢家），此时 `view.enabled === false`，
+        // 而其余副本拿到 `shadowedBy.enabled === false` —— 界面据此说「两份都不生效」。
+        // 这里仍要打上 preferred，否则界面拿不到「取消首选」那颗按钮，用户就没法撤销这次选择。
         if (preferred && preferred[canonicalName] === winner.root.key)
             winner.view.preferred = true;
         if (options.markShadowed !== false) {
+            // `enabled` 传赢家的启用状态：界面靠它区分「另一份在跑」与「两份都不生效」。
+            // 少了这个字段，被覆盖的一行只能说「同名技能 X 正在生效」—— 而 X 停用时那是假话。
+            const winnerEnabled = winner.policy.enabled === true;
             for (const item of shadowed)
                 item.view.shadowedBy = {
                     root: winner.root.key,
                     name: winner.entry.name,
+                    enabled: winnerEnabled,
                 };
         }
         if (options.markWinner !== false)

package/lib/skills/service.js

@@ -9,7 +9,7 @@ import { Worker } from 'node:worker_threads';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { isInsideRootResolved } from '../paths.js';
+import { isInsideRootResolved, isSameOrDescendant, isValidSegment } from '../paths.js';
 import { state, setSkillEnabled, setPreferredSkill, markSkillsDisabled, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, permanentlyDeleteTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, updateSkill, skillDetail, listProviderCandidates, getProviderSkill, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, logPath, trashRootPath, } from './core.js';
 const MAX_LOG_BYTES = 1 << 20;
 const PROVIDER_NAME = 'dsh-plugin-tool-management-external';
@@ -106,9 +106,14 @@ async function moveToSystemTrash(abs) {
 async function permanentlyDeleteTrashSafely(id, log) {
     const clean = String(id || '').trim();
     const root = trashRootPath();
-    const sep = root.indexOf('\\') >= 0 ? '\\' : '/';
-    const target = /^[A-Za-z0-9._-]{1,128}$/.test(clean) ? root + sep + clean : null;
-    if (target && target.indexOf(root + sep) === 0 && existsSync(target)) {
+    // 走 `paths.ts` 的单段名校验，而不是自写白名单（审查 F1，0.17.0）：
+    // 原判据 `/^[A-Za-z0-9._-]{1,128}$/` 放行 `.` 与 `..`，而 `root + sep + '..'` 解析后
+    // 正是**回收站根目录**，末尾那句字符串前缀比对拦不住它 —— 于是「删掉某一条」变成
+    // 「把整个 `trash/`（技能/场景/子智能体/提示词四类）送进系统回收站」，且返回 `ok:true`。
+    // 换成 `isValidSegment` 还让两条路同源：能通过这里的 id，必定也能通过
+    // `permanentlyDeleteTrash` 内部的 `entryPath`（同一个谓词），不会一个放行、一个拒绝。
+    const target = isValidSegment(clean) ? join(root, clean) : null;
+    if (target && isSameOrDescendant(root, target) && existsSync(target)) {
         if (await moveToSystemTrash(target)) {
             await log('trash-delete-system', { id: clean, path: target });
             return { id: clean, method: 'system-trash' };

package/lib/subagents/service.js

@@ -517,7 +517,12 @@ export function createSubagentService(ctx, opts) {
             const fresh = [];
             try {
                 const entries = await readdir(dir);
-                for (const fileName of entries.filter((e) => e.endsWith('.md')).sort()) {
+                // 只列**能管得动**的人设（2026-09-30 审查 P2-18）：`validPersonaName` 走
+                // `paths.ts` 的 `isValidSegment`，隐藏名（`.foo`）被判 `hidden` —— 于是此前列表里
+                // 会出现一个「看得见、改不了、删不掉」的人设（任何 op 都拒它）。同一条谓词在这里
+                // 收口；大小写也按 `relocateLegacyPersonas` 的 `toLowerCase()` 口径统一（`A.MD` 在
+                // 那边算人设、在这边不算，是同一个分叉的另一半）。
+                for (const fileName of entries.filter((e) => !e.startsWith('.') && e.toLowerCase().endsWith('.md')).sort()) {
                     const raw = await readFile(join(dir, fileName), 'utf8').catch(() => '');
                     if (!raw.trim())
                         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-tool-management",
-  "version": "0.16.6",
+  "version": "0.17.0",
   "description": "DSH plugin: one settings panel for MCP servers, skills, scenes, memories, subagent personas and AGENTS.md presets — a scene switches the whole environment, and the model can drive it from chat too.",
   "repository": {
     "type": "git",