dsh-plugin-tool-management 0.18.5 → 0.19.1

package/lib/prompts/service.js

@@ -52,6 +52,28 @@ const LAST_APPLIED_ID = LAST_APPLIED_PRESET_ID;
  * `isDirectory()` 过滤天然把它排除在预设之外。
  */
 const APPLIED_FILE = '__applied__.json';
+/**
+ * 「应用前 AGENTS.md 根本不存在」这个**事实**的标记文件，与备份内容同放在 `__last-applied__/`。
+ *
+ * 为什么需要它（0.19.1 修，用户 2026-10-10 反馈「全局提示词取消应用，AGENTS.md 还是存在」）：
+ * `backupGlobal()` 原先在 `current === null` 时直接 `return false` —— **一个字节都不写**。
+ * 于是"应用前没有这个文件"在磁盘上没留下任何痕迹，`unapply()` 便永远读不到备份、恒判
+ * `noBackup`，取消应用**永久关不掉**；而界面给出的出路「删除这份预设」根本不成立
+ * （`remove()` 只把预设目录移进回收站，不碰 AGENTS.md）。出路不成立 = 死路。
+ *
+ * 有了它，「取消应用」才是「应用」的**真逆操作**：
+ *   应用前有文件 → 写回那份内容；应用前没文件 → 把文件删掉。
+ * 与内容槽 `AGENTS.md` **同时只应有一个**：两个都在时 `unapplyState()` 优先判 `'restore'`，
+ * 就会把一份不相干的内容写进用户的文件。
+ *
+ * **但"只能有一个"不等于"每次写都刷掉另一个"**（0.19.1 再修，见 `backupGlobal` 的注释）：
+ * 这两个槽位合起来记的是**链起点**，链走到中途（应用 a 之后又应用 b）不许动它 ——
+ * 原先 `backupGlobal` 每写一笔都顺手 `rm` 掉另一个槽，于是「应用 a → 应用 b」这一步就把
+ * "起点不存在"永久抹掉了，取消应用再也回不到"没有文件"。
+ * 放在 `__last-applied__/` 里是安全的 —— 该目录已被 `list()` 按 `LAST_APPLIED_ID` 排除，
+ * 放什么进去都不会被当成预设。
+ */
+const ABSENT_FILE = 'absent.json';
 /** 新建预设的初始正文（空模板）；用户也可以直接粘贴自己的内容。 */
 const BLANK_TEMPLATE = '# AGENTS.md\n\n（DSH 全局指令基线预设，待编辑）\n';
 /** 全局 AGENTS.md 的备份代际上限：与 mcpm patch 的 KEEP_PATCH_BACKUPS 同纪律。 */
@@ -106,29 +128,34 @@ export function createPromptsService(_ctx, deps) {
         }
         catch { /* 描述写不进去不该让保存失败 */ }
     }
-    // 幂等初始化：仅当库完全无预设且全局 AGENTS.md 存在时，拷贝全局为 default
-    // 预设（首次运行引导）。用户已 create/apply 过任何预设则不插手，避免把
-    // 当前生效内容误存成 default 与真正生效的预设冲突。
+    // 幂等初始化：**只在库目录本身不存在时**把全局 AGENTS.md 拷成 default
+    // 预设（首次运行引导）。
+    //
+    // 判据为什么是「目录在不在」而不是「目录里有没有预设」（0.19.1 修）：后者把
+    // 「用户把预设删光了」误判成「首次运行的空库」，于是 list() / getCurrent() 每次都重新
+    // 播种 —— 用户删掉最后一个预设、刷新列表，同名 default 又回来了（内容 = 当前
+    // AGENTS.md，所以 md5 相同），删除看起来「不持久」。库目录一旦存在就说明这个库已经
+    // 被初始化过；空目录是用户的决定，不是我们的空库。
+    //
+    // 只在**目录不存在**时播种还有一层必要：库目录由 create / apply / 备份 / 应用记录
+    // 各自按需创建，所以「已存在」这个信号在任何一次真实使用之后都成立；反过来，
+    // 全新安装时没有任何一处会先建出这个目录（hub 布局迁移只搬已存在的东西），
+    // 首次运行引导因此仍然会发生。
     async function ensureInit() {
-        const [presetsDir, globalPath] = await Promise.all([deps.presetsDir, deps.getGlobalAgentsMdPath()]);
-        let existing = [];
         try {
-            existing = await readdir(presetsDir, { withFileTypes: true });
+            await stat(deps.presetsDir);
+            return; // 库目录已存在（哪怕空）→ 不插手
         }
-        catch { /* 库不存在 */ }
-        const hasPreset = existing.some((e) => e.isDirectory() && isValidPresetId(e.name) && e.name !== LAST_APPLIED_ID);
-        if (hasPreset)
-            return;
+        catch { /* 库目录不存在 → 真·首次运行，继续播种 */ }
         let globalContent;
         try {
-            globalContent = await readFile(globalPath, 'utf8');
+            globalContent = await readFile(await deps.getGlobalAgentsMdPath(), 'utf8');
         }
         catch {
             return;
         }
         try {
-            await mkdir(presetsDir, { recursive: true });
-            const defaultDir = join(presetsDir, 'default');
+            const defaultDir = join(deps.presetsDir, 'default');
             await mkdir(defaultDir, { recursive: true });
             await writeFile(join(defaultDir, FILENAME), globalContent, 'utf8');
         }
@@ -263,19 +290,52 @@ export function createPromptsService(_ctx, deps) {
         return { ok: true, id: targetId, ...(targetId === safeId ? {} : { renamedFrom: safeId }) };
     }
     /**
-     * 覆盖写全局 `~/.dsh/AGENTS.md` 前的备份（多代 + `__last-applied__` 维护）。
-     * **必须留多代**：只有单个 `__last-applied__` 槽位时，连续写两次就会把用户原始手写内容
-     * 永久覆盖掉（第一次备份原始内容 → 第二次备份第一个预设），而「应用」只是点两下按钮。
-     * @returns 是否真的备份了（当前文件存在才备份）。
+     * 覆盖写全局 `~/.dsh/AGENTS.md` 前的备份。
+     *
+     * **两个槽位（内容槽 `AGENTS.md` / `ABSENT_FILE`）合起来记的是「链起点」** —— 即
+     * "连续应用/取消往复"这一整串动作**开始之前**的文件状态。所以**只在链起点写一次**：
+     * 一旦记下，后面每一笔写入都原样保留它，直到链结束（取消应用 / 写回基线）才清掉。
+     *
+     * 为什么不是"每笔覆盖"（0.19.1 修，用户 2026-10-10 报：「原本没有 AGENTS.md，新建 a、b
+     * 两份提示词，启动 a，再启动 b；不启动 a 也不启动 b，`~/.dsh/AGENTS.md` 没有消失」）：
+     *   ① 起点      文件不存在   槽位=空
+     *   ② 应用 a    文件="# a"   槽位=absent（"应用前不存在"）
+     *   ③ 应用 b    文件="# b"   槽位=**被刷成 "# a"** ← 每笔覆盖把"起点不存在"永久抹掉了
+     *   ④ 取消应用  文件="# a"   槽位="# a"        ← 回不到"没有文件"，两颗开关还互相点亮
+     * ⑤ 此后无论点多少次，文件只在 "# a" / "# b" 之间来回，**永远回不到起点**。
+     *
+     * 与场景基线同一条口径：`scene-prompt-sync` 的 `writeBaseline` 也是「已有快照就不覆盖」
+     * （连续切场景时基线始终是"进场景之前"那一份）。
+     *
+     * **多代 `.bak-<stamp>` 快照照旧每笔都写**：它记的不是链起点，而是"每一笔被覆盖前的内容"
+     * （审计 / 抢救用），两者互不干扰 —— 链起点保证"退得回起点"，多代快照保证"中途每一份都还
+     * 在磁盘上"。**必须留多代**：只有单个槽位时，连续写两次就会把用户原始手写内容永久覆盖掉，
+     * 而「应用」只是点两下按钮。
+     *
+     * @returns 是否真的备份了内容（`current` 非空才为 `true`）。文件不存在时返回 `false`，但
+     *   **不再是"什么都不做"** —— 见 `ABSENT_FILE` 的注释：那个"不存在"本身就是链起点状态。
      */
     async function backupGlobal(current) {
-        if (current === null)
-            return false;
         const backupDir = join(deps.presetsDir, LAST_APPLIED_ID);
         await mkdir(backupDir, { recursive: true });
+        // 还没有链起点 → 现在记下它；记过就绝不再动（这正是 bug 的修法）。
+        if (await unapplyState() === null) {
+            if (current === null) {
+                // 链起点 = "文件不存在"。写不进去不该让「应用」失败 —— 代价只是取消应用退回"关不掉"。
+                try {
+                    await writeFile(join(backupDir, ABSENT_FILE), JSON.stringify({ at: new Date().toISOString() }, null, 2) + '\n', 'utf8');
+                }
+                catch { /* 见上 */ }
+            }
+            else {
+                await writeFile(join(backupDir, FILENAME), current, 'utf8');
+            }
+        }
+        if (current === null)
+            return false;
+        // 审计快照：每一笔被覆盖前的内容都留一代（链起点不受它影响）。
         const stamp = new Date().toISOString().replace(/[:.]/g, '-');
         await writeFile(join(backupDir, `${FILENAME}.bak-${stamp}`), current, 'utf8');
-        await writeFile(join(backupDir, FILENAME), current, 'utf8');
         try {
             const gens = (await readdir(backupDir)).filter((n) => n.startsWith(FILENAME + '.bak-')).sort();
             for (const stale of gens.slice(0, Math.max(0, gens.length - KEEP_GLOBAL_BACKUPS))) {
@@ -285,6 +345,15 @@ export function createPromptsService(_ctx, deps) {
         catch { /* 轮转失败不影响本次写入 */ }
         return true;
     }
+    /**
+     * 链结束（取消应用 / 写回基线）时清掉链起点 —— 下一笔「应用」重新开一条链。
+     * 与场景退出后 `writeBaseline({presetId: null, content: null})` 把快照清空是同一个口径。
+     */
+    async function clearChainStart() {
+        const dir = join(deps.presetsDir, LAST_APPLIED_ID);
+        await rm(join(dir, FILENAME), { force: true });
+        await rm(join(dir, ABSENT_FILE), { force: true });
+    }
     async function readGlobal() {
         try {
             return await readFile(await deps.getGlobalAgentsMdPath(), 'utf8');
@@ -332,8 +401,9 @@ export function createPromptsService(_ctx, deps) {
     }
     /**
      * 按**原文**写回全局基线（不经过任何预设）。
-     * 用途：场景切换的「关掉场景 → 恢复进场景之前的基线」——那份内容可能是用户手写的，
-     * 不一定对应任何预设。备份纪律与 `apply` 完全相同。
+     * 用途：① 场景切换的「关掉场景 → 恢复进场景之前的基线」——那份内容可能是用户手写的，
+     * 不一定对应任何预设；② 「取消应用」的 `'restore'` 分支。
+     * 备份纪律与 `apply` 完全相同；写回即**链结束**，链起点一并清掉（见 `clearChainStart`）。
      */
     async function restore(content) {
         const text = String(content ?? '');
@@ -347,18 +417,109 @@ export function createPromptsService(_ctx, deps) {
         }
         // 基线内容可能来自用户手写（场景退出恢复）→ 不绑定任何预设。
         await writeAppliedId(null);
+        await clearChainStart();
         return { ok: true, backedUp };
     }
+    /**
+     * 「链起点是什么状态」—— 界面据此决定「取消应用」可不可点、点下去会发生什么。
+     *   `'restore'` → 起点有一份内容，取消应用 = 把它写回去；
+     *   `'remove'`  → 起点 AGENTS.md 根本不存在，取消应用 = 删掉文件；
+     *   `null`      → 没有链起点（从没「应用」过，或链已结束），关不掉。
+     *
+     * 两个槽位同时存在只可能是手改磁盘造成的（`backupGlobal` 记链起点时只会写其中一个），
+     * 那种情况优先 `'restore'`：**写回内容比删文件保守**，猜错时用户丢的是"文件里的旧内容"
+     * 而不是整个文件。
+     */
+    async function unapplyState() {
+        const dir = join(deps.presetsDir, LAST_APPLIED_ID);
+        try {
+            if ((await stat(join(dir, FILENAME))).isFile())
+                return 'restore';
+        }
+        catch { /* 没有内容槽 */ }
+        try {
+            if ((await stat(join(dir, ABSENT_FILE))).isFile())
+                return 'remove';
+        }
+        catch { /* 没有"不存在"标记 */ }
+        return null;
+    }
+    /**
+     * 「取消应用」= **回到链起点**：把这一串应用/取消往复开始之前的文件状态恢复出来。
+     *
+     * 语义边界（写清楚是因为它决定了开关什么时候可关）：
+     *   - 恢复的是**链起点**，不是"上一步"。连续应用过 A、B 时，取消应用直接回到"应用 A 之前"
+     *     —— 文件不存在就删掉文件、有一份手写内容就写回那份内容（0.19.1 修，见 `backupGlobal`）。
+     *     想从 B 切回 A 就点 A 的开关，效果等价，不必先退回 A 再取消。
+     *   - **没有链起点就拒绝**（`noBackup`）。没有链起点只有一种成因：AGENTS.md 的当前内容不是
+     *     由「应用」写进去的（首次打开提示词页时播种出来的 `default` 就是这样，它内容与 AGENTS.md
+     *     相同、显示「生效中」，却从未发生过写入）。此时"起点"无从谈起，写空文件等于抹掉用户的
+     *     全局指令 —— 所以宁可拒绝，让界面去说清「要让它不再生效，请删除这份预设或应用别的预设」。
+     *
+     * `'restore'` 分支复用 `restore()`：备份纪律与「应用」完全一致。`'remove'` 分支（起点文件
+     * 不存在）先 `backupGlobal(prev)` 把当前内容存进多代快照，所以删掉的内容仍然拿得回来
+     * （`__last-applied__/AGENTS.md.bak-*`），可撤销性与另一支对称。
+     * 两支结束都清链起点（`'restore'` 在 `restore()` 里清）—— 链到此为止。
+     */
+    async function unapply() {
+        const mode = await unapplyState();
+        if (mode === null) {
+            return {
+                ok: false,
+                noBackup: true,
+                error: '没有可恢复的「链起点」：__last-applied__ 里既没有备份内容，也没有「起点不存在」的标记（AGENTS.md 当前内容不是由「应用」写进去的）。',
+            };
+        }
+        if (mode === 'remove') {
+            const prev = await readGlobal();
+            const backedUp = await backupGlobal(prev);
+            try {
+                await rm(await deps.getGlobalAgentsMdPath(), { force: true });
+            }
+            catch (e) {
+                return { ok: false, error: '删除全局 AGENTS.md 失败：' + message(e) };
+            }
+            await writeAppliedId(null);
+            await clearChainStart();
+            return { ok: true, backedUp, removed: true };
+        }
+        let content;
+        try {
+            content = await readFile(join(deps.presetsDir, LAST_APPLIED_ID, FILENAME), 'utf8');
+        }
+        catch {
+            // `unapplyState()` 刚判过它存在，这里读不到只能是并发下被清掉（或权限问题）。
+            return {
+                ok: false,
+                noBackup: true,
+                error: '没有可恢复的「链起点内容」：__last-applied__ 里没有备份（AGENTS.md 当前内容不是由「应用」写进去的）。',
+            };
+        }
+        return restore(content);
+    }
     async function getCurrent() {
         try {
             await ensureInit();
             const [globalPath, presetsDir] = await Promise.all([deps.getGlobalAgentsMdPath(), deps.presetsDir]);
+            // `lastApplied` 与 `presetId` 是**两个不同的事实**，删除保护要的是前者：
+            //   `presetId`   = 内容逐字节相同（谁的内容此刻躺在文件里）
+            //   `lastApplied`= 最近一次「应用」写进去的是谁（用户**主动做过这个选择**）
+            // 两者在"首次打开提示词页时自动播种出来的 default"上分道扬镳：它内容与 AGENTS.md
+            // 相同（presetId 命中），却从未发生过写入（lastApplied 为 null）。那份副本删掉完全
+            // 合理 —— 拦它反而会变成死路（取消应用也关不掉）。见 `ops/prompts.ts` 的删除保护。
+            const lastApplied = await readAppliedId();
+            // 与内容一起报「链起点是什么状态」—— 界面用它决定那颗「生效中」的开关点下去是
+            // 「取消应用」还是「说明为什么关不掉」，以及取消应用的确认弹窗要说"写回内容"还是
+            // **"删掉文件"**（后者是不可逆感很强的动作，必须提前说清，不能点下去才知道）。
+            const unapplyMode = await unapplyState();
+            const unapplyAvailable = unapplyMode !== null;
+            const unapplyRemoves = unapplyMode === 'remove';
             let content;
             try {
                 content = await readFile(globalPath, 'utf8');
             }
             catch {
-                return { ok: true, content: '', presetId: null, exists: false };
+                return { ok: true, content: '', presetId: null, lastApplied, exists: false, unapplyAvailable, unapplyRemoves };
             }
             const globalHash = createHash('sha256').update(content).digest('hex');
             let presetId = null;
@@ -382,7 +543,7 @@ export function createPromptsService(_ctx, deps) {
                     break;
                 }
             }
-            return { ok: true, content, presetId, exists: true };
+            return { ok: true, content, presetId, lastApplied, exists: true, unapplyAvailable, unapplyRemoves };
         }
         catch (e) {
             return { ok: false, error: message(e) };
@@ -409,6 +570,11 @@ export function createPromptsService(_ctx, deps) {
         const moved = await moveToTrash('prompts', safeId, [{ from: dir, dest: 'preset' }]);
         if (moved.ok === false)
             return { ok: false, error: '移入回收站失败：' + moved.error };
+        // 删掉的正是「最近一次应用」的那一份 → 记录跟着清掉。与 `update()` 改名时跟着改记录对称。
+        // 不清的后果：之后再新建一个同 id 的预设，界面会凭这条陈旧记录错误地标上「最近一次应用」
+        // （`list()` 只做 `appliedId === id` 的比对，认不出「这是另一个预设」）。
+        if (await readAppliedId() === safeId)
+            await writeAppliedId(null);
         return { ok: true, id: safeId };
     }
     async function trashList() {
@@ -462,5 +628,5 @@ export function createPromptsService(_ctx, deps) {
         await writeDescription(safeId, description);
         return { ok: true, id: safeId };
     }
-    return { list, read, create, update, apply, restore, getCurrent, remove, trashList, trashRestore, trashDelete, importPreset };
+    return { list, read, create, update, apply, unapply, restore, getCurrent, remove, trashList, trashRestore, trashDelete, importPreset };
 }

package/lib/scene-prompt-sync.js

@@ -156,7 +156,7 @@ export function createScenePromptSync(deps) {
             if (!cur || cur.ok !== true)
                 complete = false;
             else if (cur.presetId)
-                add(String(cur.presetId), { kind: 'file' });
+                add(String(cur.presetId), { kind: 'file', applied: cur.lastApplied === cur.presetId });
         }
         catch (e) {
             complete = false;

package/lib/scenes/candidates.js

@@ -7,8 +7,8 @@
 // 三组候选，各自的失效模式不同：
 //   * **技能 / 记忆 / 场景**（skillRows / memoryCandidates / memorySceneCandidates）——
 //     直接读各自 service 的 op，无缓存；
-//   * **预设工具**（presetToolCandidates / presetToolNames）—— 枚举会为预设建立 standing
-//     mount（官方语义：每进程一次），所以按 PRESET_ENUM_CACHE_MS 缓存，不能每次重枚举；
+//   * **预设工具**（presetToolCandidates / presetToolNames）—— 每次枚举要为每个预设取一次
+//     官方 `acquireScope` 租约 + 读一次 `tools.schemas()`，所以按 PRESET_ENUM_CACHE_MS 缓存；
 //   * **模型**（modelCandidates）—— 只读宿主 LLM 目录，**不发网络请求**。
 //
 // 依赖全部经 deps 显式传入。注意 \`toolKeyParts\` 留在 index.ts：场景档案引擎也在用它，
@@ -28,7 +28,7 @@ import { injectionFactsOf, readCompositionFacts, readCompositionText } from '../
 const MODEL_REASONING_TIMEOUT_MS = 10_000;
 export function createCandidates(deps) {
     // 外部能力一次解构成局部名：块内代码逐字搬来，保持原样最不容易出错。
-    const { get, tools, mcp, skillsService, memoriesService, toolKeyParts } = deps;
+    const { get, tools, mcp, skillsService, memoriesService, toolKeyParts, selfToolNames } = deps;
     const ctx = { get };
     // Agent 预设名单（@deepseek-ai/dsh-agent-presets）：同样是可选服务，按需取用。
     // 读它只为了回答"当前预设下本插件注入的东西到不到得了模型"——只读，不挂载任何预设。
@@ -195,31 +195,25 @@ export function createCandidates(deps) {
         }
     }
     /**
-     * 工具候选（人设的「工具白名单 / 黑名单」选择器）：
-     * 取**全体 Agent 预设工具名的并集**——人设可能在任意预设下被子代理复用，
-     * 只列当前会话的工具会让换预设后的子代理启动失败（官方 `toolFilter` 对未知名直接拒绝）。
-     * 同时标注 `current`：当前会话可见的工具（其余只是「本预设可用，当前会话看不到」）。
+     * 工具候选（人设的「工具白名单 / 黑名单」选择器）：一行一个 Agent 预设，各带**它自己的**
+     * 工具清单与归属组。
      *
-     * 每次调用都会为尚未挂载的预设建立 standing mount（官方语义：一个预设在本进程内只挂一次，
-     * 正常创建会话时同样会挂），因此结果会按需缓存 PRESET_ENUM_CACHE_MS，避免频繁枚举。
+     * 为什么按预设切而不是给一份并集：人设可能在任意预设下被子代理复用，而界面一行只对那个
+     * 预设生效，所以勾出来的名字必须属于那一行。见 `presetToolView`（判据与 0.19.0 修掉的
+     * 那条断链）。
+     *
+     * 0.19.0 删掉了原来那份「全体并集」（`tools`，含 `presets` / `current` 两个字段）：整条链
+     * 上零读取点（客户端只读 `presets`），而它是同一份数据的第二个真相 —— 从 `presets[].tools`
+     * 直接推得出来，每次调用白背 ≈2KB 载荷。
      */
-    // 两个预设枚举缓存（全体候选 / 单个预设）共用这个 TTL：枚举的代价是"给预设建立
-    // standing mount"，与内容变化无关，所以只要别刷得太勤就行。
+    // 两个预设枚举缓存（全体候选 / 单个预设）共用这个 TTL：枚举要一次 acquireScope 租约 +
+    // 一次 schemas()，与内容变化无关，所以只要别刷得太勤就行。
     const PRESET_ENUM_CACHE_MS = 60_000;
     let presetToolsCache = null;
     async function presetToolCandidates() {
         if (presetToolsCache && Date.now() - presetToolsCache.at < PRESET_ENUM_CACHE_MS)
             return presetToolsCache.value;
-        const byName = new Map();
         const presets = [];
-        // 当前会话的可见工具（用于标 current）；拿不到就全部按「非当前」处理。
-        const currentNames = new Set();
-        try {
-            const schemas = await tools.schemas();
-            for (const s of schemas || [])
-                currentNames.add(String(s.name));
-        }
-        catch { /* 无 live 工具 → current 全 false */ }
         const agentPresets = (typeof ctx.get === 'function' ? ctx.get('agentPresets') : undefined);
         if (agentPresets && typeof agentPresets.list === 'function') {
             try {
@@ -230,9 +224,10 @@ export function createCandidates(deps) {
                     const id = String((p && p.id) || '');
                     if (!id)
                         continue;
+                    const view = await presetToolView(id);
                     // MCP 工具名形如 `mcp__<server>__<tool>`：面向上百个条目，噪声大于价值 → 不进候选。
                     // 子代理照样能用当前在跑的 MCP —— 那份名单在 decideToolFilter 里运行时并进白名单。
-                    const names = (await presetToolNames(id)).filter((name) => !name.startsWith(MCP_TOOL_PREFIX));
+                    const names = view.names.filter((name) => !name.startsWith(MCP_TOOL_PREFIX));
                     presets.push({
                         id,
                         name: String((p && (p.name || p.id)) || id),
@@ -242,65 +237,150 @@ export function createCandidates(deps) {
                         trust: String((p && p.trust) || ''),
                         broken: typeof (p && p.broken) === 'string',
                         tools: names,
+                        // 与 tools 同序裁剪：被 MCP 前缀筛掉的名字不留在归属表里（这张表只描述列出来的那些）。
+                        toolGroups: names.reduce((acc, name) => {
+                            acc[name] = view.origins[name] ?? 'other';
+                            return acc;
+                        }, {}),
                     });
-                    for (const name of names) {
-                        const rec = byName.get(name) || { name, presets: new Set(), current: false };
-                        rec.presets.add(id);
-                        byName.set(name, rec);
-                    }
                 }
             }
-            catch { /* 预设服务不可用 → 退回「仅当前会话工具」 */ }
+            catch { /* 预设服务不可用 → 一行都不给（界面显示读不到，不假装空） */ }
         }
-        // 当前会话的工具即便没有任何预设可枚举，也要出现在候选里（否则选择器是空的）。
-        for (const name of currentNames) {
-            if (name.startsWith(MCP_TOOL_PREFIX))
-                continue;
-            const rec = byName.get(name) || { name, presets: new Set(), current: false };
-            byName.set(name, rec);
-        }
-        for (const rec of byName.values())
-            rec.current = currentNames.has(rec.name);
-        const value = {
-            tools: [...byName.values()]
-                .map((r) => ({ name: r.name, presets: [...r.presets].sort(), current: r.current }))
-                .sort((a, b) => a.name.localeCompare(b.name)),
-            // 保持 roster 顺序（官方的展示顺序），前端四行直接照用。
-            presets,
-        };
+        const value = { presets };
         presetToolsCache = { at: Date.now(), value };
         return value;
     }
+    /** 官方包的作用域前缀。只用来判「这个预设的行是不是全部来自官方」，不做任何工具名匹配。 */
+    const OFFICIAL_PACKAGE_PREFIX = '@deepseek-ai/';
     /**
-     * 单个预设的工具名（列表里含 MCP 与宿主平面的工具，因为子代理的可见集合是
-     * "宿主平面 ∪ 该预设"的并集）。枚举会为该预设建立 standing mount —— 官方语义：
-     * 一个预设每进程只挂一次，正常创建会话时同样会挂，所以这里按 id 缓存 PRESET_ENUM_CACHE_MS；
-     * `subagent_manager_run` 每次委派都要用它校验名单，不能每次都重新枚举。
+     * 一个预设自己的工具视图 + 三组归属。
+     *
+     * 归属只能做到「层」粒度，这是**官方的限制而不是设计选择**：`ToolSchema` 只有
+     * `{ name, description, parameters, deferLoading? }`，没有归属字段；`ToolRuntime` 的公开面
+     * （`register` / `restrict` / `guard` / `get` / `schemas` / `presentAs`）里也没有「这个工具是谁
+     * 注册的」（`view` 是 private）；`tools/change` 是**无载荷** emit，只报"变了"；宿主侧的
+     * `dsh-host-plugin-inventory` 自述 "No layer attribution"，且 Remote-only、进程内 `ctx.get`
+     * 拿不到。所以判据全部是集合运算，不出现任何工具名或包名的字面量：
+     *
+     *   G = tools.schemas()                       宿主平面（global 层）
+     *   P = tools.schemas(acquireScope(id).key)   该预设视图 = G ∪ 该预设自己挂的包
+     *   Δ = P − G                                 该预设自带的工具
+     *   O = 本插件注册漏斗登记的名字               插件工具 = O ∩ P
+     *
+     * 「官方」在这里是**该预设自带的**，不是「DeepSeek 出的」：宿主平面上的官方工具（如
+     * `load_workspace_dependencies`）会落在「其他」。这是刻意的 —— 宁可说「不知道」，不假装是
+     * 官方；要认出来只能靠一份名字对照表，那会同时丢掉「零硬编码」与「随官方更新而更新」。
+     * 预设里混挂了第三方行时 Δ 无法再拆（包粒度已知、工具粒度未知），此时整份落「其他」。
      */
-    const presetNamesCache = new Map();
-    async function presetToolNames(id) {
-        const hit = presetNamesCache.get(id);
+    const presetViewCache = new Map();
+    async function presetToolView(id) {
+        const hit = presetViewCache.get(id);
         if (hit && Date.now() - hit.at < PRESET_ENUM_CACHE_MS)
-            return hit.names;
+            return hit.view;
+        // 宿主平面：一次读、所有预设共用。读不到 → 空集，于是 Δ = P，全部落「其他」而不是误判成官方。
+        const hostNames = new Set();
+        try {
+            for (const s of (await tools.schemas()) || []) {
+                const name = String(s?.name || '');
+                if (name)
+                    hostNames.add(name);
+            }
+        }
+        catch { /* 读不到宿主平面 → Δ 退化成 P，全部落「其他」 */ }
         const agentPresets = (typeof ctx.get === 'function' ? ctx.get('agentPresets') : undefined);
-        let scopeKey;
+        // 官方预设服务的公开面里，取"某个预设的 standing scope key"的只有 `acquireScope(id)`：
+        // 返回 `{ key: ScopeKey } & AsyncDisposable`，契约是**读完就 dispose**（内部 `retain()` 会
+        // `generation.users++`，不还这份 generation 永远回收不掉）。它**不挂载**预设：`retain` 对
+        // 未激活/损坏的预设直接抛 `RemoteError` —— 于是"读不到"与"没有工具"被分开了，后者不会
+        // 再冒充前者。此前的 `standingKeyFor` 在官方包里根本不存在（`@deepseek-ai` 全树 0 命中），
+        // 那条 `typeof` 守卫恒为假，等于一直在读全局视图。
+        const canScope = !!(agentPresets && typeof agentPresets.acquireScope === 'function');
+        let names = [];
+        if (canScope) {
+            let lease;
+            try {
+                lease = await agentPresets.acquireScope(id);
+                names = ((await tools.schemas(lease && lease.key)) || [])
+                    .map((s) => String(s?.name || ''))
+                    .filter(Boolean);
+            }
+            catch {
+                names = [];
+            }
+            finally {
+                // 还租约。dispose 自己幂等且吞异常，这里再包一层只为不让"还租约"失败盖掉真正的读失败。
+                try {
+                    if (lease && typeof lease[Symbol.asyncDispose] === 'function')
+                        await lease[Symbol.asyncDispose]();
+                }
+                catch { /* 已经还过 */ }
+            }
+        }
+        else {
+            // 老宿主没有 `acquireScope`：退回宿主平面（= 0.19.0 之前的可见行为），并且**什么都不认成
+            // 官方**。这比列一份空的强（用户至少还看得见、还能勾），也比拿全局清单冒充"该预设自己的"诚实。
+            names = [...hostNames];
+        }
+        // 本插件自报的名字。读不到 → 空集，于是本插件的工具落「其他」而不是凭空消失。
+        const self = new Set();
         try {
-            scopeKey = agentPresets && typeof agentPresets.standingKeyFor === 'function'
-                ? await agentPresets.standingKeyFor(id)
-                : undefined;
+            for (const name of selfToolNames())
+                self.add(String(name));
         }
-        catch {
-            scopeKey = undefined;
+        catch { /* 读不到自报名单 */ }
+        const shipped = canScope ? await presetIsShipped(id) : false;
+        const origins = {};
+        for (const name of names) {
+            if (self.has(name))
+                origins[name] = 'plugin';
+            // 只有该预设的行**全部**来自官方包时才敢把差集叫「官方」；混挂第三方行时整份落「其他」。
+            else if (shipped && !hostNames.has(name))
+                origins[name] = 'official';
+            else
+                origins[name] = 'other';
         }
-        let names = [];
+        const view = { names, origins };
+        presetViewCache.set(id, { at: Date.now(), view });
+        return view;
+    }
+    /**
+     * 该预设的行是不是**全部**来自 `@deepseek-ai/`（出厂四预设都是）。
+     *
+     * 读 `compositionInventory()`（官方公开方法，"Read plugin rows without creating an Agent"）。
+     * 它是**包**粒度、不是工具粒度 —— 这正是本节开头那段限制的具体形状：拿得到"这个预设挂了
+     * 哪些包"，拿不到"哪个包贡献了哪个工具"。所以只能整份判，判不了就整份落「其他」。
+     *
+     * 任何一步失败都返回 `false`（= 不认成官方），不抛。
+     */
+    const presetShippedCache = new Map();
+    async function presetIsShipped(id) {
+        const hit = presetShippedCache.get(id);
+        if (hit && Date.now() - hit.at < PRESET_ENUM_CACHE_MS)
+            return hit.shipped;
+        let shipped = false;
         try {
-            names = ((await tools.schemas(scopeKey)) || []).map((s) => String(s.name)).filter(Boolean);
+            const agentPresets = (typeof ctx.get === 'function' ? ctx.get('agentPresets') : undefined);
+            if (agentPresets && typeof agentPresets.compositionInventory === 'function') {
+                const list = await agentPresets.compositionInventory();
+                const row = (list || []).filter((p) => p && String(p.id) === id)[0];
+                const rows = row && Array.isArray(row.rows) ? row.rows : [];
+                shipped = rows.length > 0 && rows.every((r) => String((r && r.moduleName) || '').startsWith(OFFICIAL_PACKAGE_PREFIX));
+            }
         }
         catch {
-            names = [];
+            shipped = false;
         }
-        presetNamesCache.set(id, { at: Date.now(), names });
-        return names;
+        presetShippedCache.set(id, { at: Date.now(), shipped });
+        return shipped;
+    }
+    /**
+     * 单个预设的工具名（含 MCP 与宿主平面的工具，因为子代理的可见集合是
+     * "宿主平面 ∪ 该预设"的并集）。`subagent_manager_run` 每次委派都要用它校验名单，所以
+     * 按 id 缓存 PRESET_ENUM_CACHE_MS。只取名字 —— 归属那份走 `presetToolView`。
+     */
+    async function presetToolNames(id) {
+        return (await presetToolView(id)).names;
     }
     /** 预设名单的名字投影（只读 roster，不挂载任何预设）：场景页显示模式名用。 */
     async function presetNames() {
@@ -318,32 +398,45 @@ export function createCandidates(deps) {
         }
     }
     /**
-     * 模型候选（人设的「模型」下拉）：宿主已注册的 provider + 各 provider 能宣告的模型。
-     * 只读宿主 LLM 目录，**不发起网络请求**（`discoverModels` 会打端点，这里不用）；
+     * 模型候选（人设的「模型」与「模型来源」两个下拉）：宿主已注册的 provider + 各 provider
+     * 能宣告的模型。只读宿主 LLM 目录，**不发起网络请求**（`discoverModels` 会打端点，这里不用）；
      * 拿不到就返回空列表，UI 退回手填（跨来源模型如 sensenova 的手工条目仍需手填兜底）。
-     * 返回扁平列表：DSH 的模型路由是 (provider, model) 一对，两个键必须同时给。
+     *
+     * 两份投影、用途不同：
+     *   · `models` 是扁平列表 —— DSH 的模型路由是 (provider, model) 一对，两个键必须同时给；
+     *   · `providers` 是去重后的来源清单 —— 「模型来源」下拉要用它。
+     *
+     * `providers` 不能由 `models` 去重反推：适配器不提供 `listModels` 时该 provider 一个模型
+     * 都报不出来（官方 LlmAdapter 里它是可选项），而"来源有、目录里没模型"恰恰是最需要手填
+     * 模型 id 的场景 —— 由 models 反推会让这类 provider 在来源下拉里整个消失。
      */
     async function modelCandidates() {
         const llm = (typeof ctx.get === 'function' ? ctx.get('llm') : undefined);
         if (!llm || typeof llm.listProviders !== 'function')
-            return { models: [] };
+            return { models: [], providers: [] };
         let list = [];
         try {
             list = llm.listProviders() || [];
         }
         catch {
-            return { models: [] };
+            return { models: [], providers: [] };
         }
         const models = [];
+        const providers = [];
         const seen = new Set();
+        const seenProvider = new Set();
         for (const p of list) {
             const provider = String((p && (p.id || p.provider)) || '');
             if (!provider)
                 continue;
             const providerName = String((p && (p.name || p.displayName)) || provider);
+            if (!seenProvider.has(provider)) {
+                seenProvider.add(provider);
+                providers.push({ id: provider, name: providerName });
+            }
             let discovered = [];
             try {
-                // 适配器可选提供 listModels（官方 LlmAdapter 契约）；未提供时该 provider 只报名字。
+                // 适配器可选提供 listModels（官方 LlmAdapter 契约）；未提供时该 provider 只有来源那一项。
                 if (typeof llm.listModels === 'function')
                     discovered = (await llm.listModels(provider)) || [];
             }
@@ -359,7 +452,7 @@ export function createCandidates(deps) {
                 models.push({ provider, providerName, id, name: String((m && m.name) || id) });
             }
         }
-        return { models };
+        return { models, providers };
     }
     /**
      * 某个 (provider, model) 的思考强度档位。见 `Candidates.modelReasoning` 的注释。

package/lib/settings-sidecars.js

@@ -14,7 +14,8 @@ export function createSettingsSidecars(deps) {
     // 注入设置（侧车 `inject-settings.json`，界面在「兼容」页）：
     //   - underSuppressingPresets：压制型预设（persona complete / 关运行时上下文，如极简）
     //     下是否仍然注入。默认 false = 跟随预设。
-    //   - domains：各域开关（任何预设下都生效；界面五个勾选）。
+    //   - domains：各域开关（任何预设下都生效；界面六个勾选。深度判据不在这里 —— 见
+    //     `InjectDomain.applicableTo`：场景与记忆只在顶层，子智能体目录按人设 catalogDepth）。
     // 注入器每个 step 都要同步读一次设置 → 走 TTL 缓存；未加载时先给默认值并异步预热。
     const INJECT_SETTINGS_FILE = 'inject-settings.json';
     const INJECT_SETTINGS_TTL_MS = 3000;