dsh-plugin-tool-management 0.8.0 → 0.9.0

package/lib/scene-prompt-sync.js

@@ -1,12 +1,15 @@
 // dsh-plugin-tool-management —— 场景绑定提示词 ⇄ 全局基线（`~/.dsh/AGENTS.md`）同步。
 //
 // 用户裁定（2026-09-15）：「切换场景，对应的提示词直接把 AGENTS.md 直接修改」。
-// 因此场景绑定的提示词不再作为 systemPrompt 段注入，而是**真写全局基线文件**，
-// 与「提示词」页的「应用」走同一条路（覆盖前多代备份到 `agents-md/__last-applied__/`）。
+// 因此场景绑定的提示词不再作为提示词段/注入发送，而是**真写全局基线文件**，
+// 与「提示词」页的「应用」走同一条路（覆盖前多代备份到 `prompts/__last-applied__/`）。
+// 例外（2026-09-16）：预设**挂不到**官方 `dsh-agent-instructions` 行时（极简），文件没人读，
+// 注入通道会拿同一份正文兜底送达（rules 服务的 `promptText()`）。
 //
-// 四个动作会触发同步（调用方在 op 层包一层 `withSync`）：
+// 六个动作会触发同步（调用方在 op 层包一层 `withSync`）：
 //   ① 启用/切换场景    ② 关掉场景（恢复进场景前的基线）
 //   ③ 改场景绑定的预设  ④ 编辑"正在驱动基线的那份预设"的正文
+//   ⑤ 从回收站恢复预设（绑定重新变活）  ⑥ 应用提示词（场景接管时只放行绑定的那一份）
 //
 // 「进场景前的基线」快照存在 hub 的 `scene-baseline.json`：进场景时记下当时的
 // AGENTS.md 正文（以及当时匹配到的预设 id），关掉场景时**按原文**写回 ——
@@ -15,6 +18,11 @@
 //
 // 幂等与如实：文件已经是那份（`duplicate`）时不写盘；没有场景驱动、也没有快照时什么都不做；
 // 写失败**不改**原操作的成功结论，而是把原因放进 `error` 交给界面显示成警告。
+//
+// 这里同时是**三条状态的事实源**（用户实测反馈「显示 A、实际注入 B、A 还能删 B 不能删」后加的）：
+//   `driver()`     —— 谁在驱动基线（提示词页「应用」的守卫依据：场景接管期间不许应用别的预设）；
+//   `refs()`       —— 每个预设被谁引用（删除保护的唯一依据：场景绑定 / 基线当前内容 / 退出恢复目标）；
+//   `baseline()`   —— 进场景前的基线快照（退出场景后要恢复的那一份）。
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 export function createScenePromptSync(deps) {
@@ -54,9 +62,12 @@ export function createScenePromptSync(deps) {
             const sp = r && r.ok ? r.scenePrompt : null;
             if (!sp)
                 return null;
+            const scene = sp.scene ? String(sp.scene) : null;
             return {
-                scene: sp.scene ? String(sp.scene) : null,
+                scene,
                 presetId: sp.presetId ? String(sp.presetId) : null,
+                // 显示名缺失时退回场景名（老载荷 / 桩），宁可粗糙也不要空字符串。
+                label: sp.label ? String(sp.label) : (scene || ''),
                 missing: sp.missing === true,
                 duplicate: sp.duplicate === true,
             };
@@ -66,18 +77,96 @@ export function createScenePromptSync(deps) {
             return null;
         }
     }
+    /** 一个场景是否真的在驱动基线：有场景、绑定非空且预设正文读得到。 */
+    const drives = (s) => !!s && s.scene !== null && !s.missing && s.presetId !== null;
+    async function driver() {
+        const current = await state();
+        if (!drives(current))
+            return null;
+        return { scene: current.scene, label: current.label || current.scene, presetId: current.presetId };
+    }
+    async function applyGuard(id) {
+        const current = await driver();
+        if (!current)
+            return null;
+        // 同一份 = 重新应用（把被手改的基线写回场景绑定的内容）→ 放行。
+        if (current.presetId === String(id ?? '').trim())
+            return null;
+        return current;
+    }
+    async function refs() {
+        const out = new Map();
+        const add = (id, ref) => {
+            const list = out.get(id);
+            if (!list) {
+                out.set(id, [ref]);
+                return;
+            }
+            const dup = list.some((x) => {
+                if (x.kind !== ref.kind)
+                    return false;
+                if (x.kind === 'scene' && ref.kind === 'scene')
+                    return x.scene === ref.scene;
+                return true;
+            });
+            if (!dup)
+                list.push(ref);
+        };
+        // 三类探测各自失败都算「没探全」→ 整体返回 null（放行删除 + warn），
+        // 与原有「探测失败不拦删除、最坏少一份副本」的口径一致。
+        let complete = true;
+        try {
+            const r = await deps.rules.ops['rules-list']({});
+            if (!r || r.ok !== true) {
+                complete = false;
+            }
+            else {
+                for (const s of (Array.isArray(r.scenes) ? r.scenes : [])) {
+                    const id = s && typeof s.prompt === 'string' ? s.prompt : '';
+                    if (id === '')
+                        continue;
+                    const scene = String((s && s.name) || '');
+                    add(id, { kind: 'scene', scene, label: String((s && s.label) || scene), active: s && s.active === true });
+                }
+            }
+        }
+        catch (e) {
+            complete = false;
+            warn(`scene-prompt: refs probe (scenes) failed: ${String(e)}`);
+        }
+        try {
+            const cur = await deps.agentsMd.getCurrent();
+            if (!cur || cur.ok !== true)
+                complete = false;
+            else if (cur.presetId)
+                add(String(cur.presetId), { kind: 'file' });
+        }
+        catch (e) {
+            complete = false;
+            warn(`scene-prompt: refs probe (baseline file) failed: ${String(e)}`);
+        }
+        try {
+            const saved = await readBaseline();
+            if (saved && saved.content !== null && saved.presetId)
+                add(saved.presetId, { kind: 'restore' });
+        }
+        catch (e) {
+            complete = false;
+            warn(`scene-prompt: refs probe (snapshot) failed: ${String(e)}`);
+        }
+        return complete ? out : null;
+    }
     async function sync() {
         const current = await state();
         if (!current)
             return { unchanged: true };
-        const driving = current.scene !== null && !current.missing && current.presetId !== null;
-        if (driving) {
+        if (drives(current)) {
             if (current.duplicate)
                 return { applied: current.presetId, unchanged: true };
             // 进场景的第一笔写入之前，先记下当时的基线（已有快照就不覆盖：连续切场景时
             // 基线始终是"进场景之前"那一份）。
-            const baseline = await readBaseline();
-            if (!baseline || baseline.content === null) {
+            const saved = await readBaseline();
+            if (!saved || saved.content === null) {
                 const cur = await deps.agentsMd.getCurrent();
                 await writeBaseline({
                     v: 1,
@@ -92,10 +181,10 @@ export function createScenePromptSync(deps) {
             return { applied: current.presetId };
         }
         // 没有场景驱动 → 如果刚从驱动态退出，把进场景前的基线写回去。
-        const baseline = await readBaseline();
-        if (!baseline || baseline.content === null)
+        const saved = await readBaseline();
+        if (!saved || saved.content === null)
             return { unchanged: true };
-        const res = await deps.agentsMd.restore(baseline.content);
+        const res = await deps.agentsMd.restore(saved.content);
         if (res && res.ok === false)
             return { error: String(res.error || '恢复 AGENTS.md 失败') };
         await writeBaseline({ v: 1, at: Date.now(), presetId: null, content: null });
@@ -108,5 +197,5 @@ export function createScenePromptSync(deps) {
         const agentsMd = await sync();
         return { ...res, agentsMd };
     }
-    return { sync, withSync, state };
+    return { sync, withSync, state, driver, applyGuard, refs };
 }

package/lib/skills/catalog.js

@@ -0,0 +1,125 @@
+// src/skills/catalog.ts —— 技能目录段（注入通道的数据源）。
+//
+// 为什么需要它：技能目录本来是官方 `@deepseek-ai/dsh-tool-skill` 的活 —— 它随预设挂载，
+// 极简这类预设没挂，模型连"有哪些技能"都不知道（网页版把宿主那两条行交给预设后尤其如此）。
+// 本模块提供同一份信息的**兜底通道**：只在预设没挂官方那一行时注入（判定在
+// src/context-inject.ts 的 `CARRIER_FACT_OF`），格式与官方目录同形（`- \`name\`: description`）。
+//
+// 数据源用**插件自己的技能清单**（技能服务的 `skill-state`）：它已经含启停 / 被同名覆盖 /
+// 同名首选的判定 —— 那正是用户在技能页管的那些开关；官方注册表里的同一份策略也由本插件的
+// provider 喂进去，所以两边看到的是同一批技能。
+//
+// 与官方目录的两处有意差别：
+//   - 只列**当前启用且可被模型调用**的（官方只过滤可调用性，不管用户在插件页关掉了谁）。
+//   - 结尾多一行：本预设没有官方 `skill` 加载工具（目录与工具是一起挂的），需要正文时得先
+//     `skill_manager_list` 取源文件路径再读那个文件 —— 不写这句，模型会以为有 `skill` 工具可调。
+//
+// 同步性：`text()` 必须同步返回（注入通道每个 step 同步取文本），而技能清单是异步读盘 →
+// 与子智能体目录同构的 stale-while-revalidate：`text()` 返回缓存值并在超龄时后台重算，
+// `refresh()` 供技能写操作后立即重算。
+/** 描述截断长度（与官方目录的 `catalogDescriptionMaxLength` 默认值一致）。 */
+export const SKILL_CATALOG_DESCRIPTION_MAX_LENGTH = 500;
+/** 目录最多列几条；超出只报数量（让模型去调 `skill_manager_list`）。 */
+export const SKILL_CATALOG_MAX_ENTRIES = 50;
+/** 描述归一化 + 截断（与官方 `catalogDescription` 同款：折叠空白、超出补省略号）。 */
+function catalogDescription(value, maxLength) {
+    const normalized = String(value ?? '').replaceAll(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 3)}...`;
+}
+/** 与 `skill_manager_list` / 界面（`isSkillEnabled`）同一套启停推导。 */
+function isEnabled(row) {
+    if (row.enabled !== undefined)
+        return row.enabled === true;
+    return row.invocationPolicyValid === true && row.modelInvocable === true && row.userInvocable === true && row.managerEnabled !== false;
+}
+/**
+ * 渲染技能目录段（纯函数，便于单独推理）。
+ *
+ * 返回 `''` 表示没有可注入的技能 —— 没装技能的用户零 token 成本。
+ * 名字按字典序排序：底层目录枚举顺序变化时文本仍逐字节稳定（前缀缓存契约）。
+ */
+export function renderSkillCatalog(data, maxEntries = SKILL_CATALOG_MAX_ENTRIES, maxDescription = SKILL_CATALOG_DESCRIPTION_MAX_LENGTH) {
+    const roots = (data && typeof data === 'object' ? data.roots : undefined) ?? [];
+    const byName = new Map();
+    if (Array.isArray(roots)) {
+        for (const root of roots) {
+            const skills = (root && typeof root === 'object' ? root.skills : undefined) ?? [];
+            if (!Array.isArray(skills))
+                continue;
+            for (const raw of skills) {
+                if (!raw || typeof raw !== 'object')
+                    continue;
+                const row = raw;
+                // 影子里那份不可加载（同名只有胜出者生效），启停开关也管不到它 —— 不进目录。
+                if (row.shadowedBy)
+                    continue;
+                if (!isEnabled(row) || row.modelInvocable === false)
+                    continue;
+                const name = String(row.declaredName || row.name || '').trim();
+                if (name === '')
+                    continue;
+                // 同名（跨根）只留一份：胜出者由 core 标出，这里按出现顺序先到先得，避免重复行。
+                if (byName.has(name))
+                    continue;
+                byName.set(name, { name, description: catalogDescription(row.description, maxDescription) });
+            }
+        }
+    }
+    if (byName.size === 0)
+        return '';
+    const sorted = [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const shown = sorted.slice(0, Math.max(0, maxEntries));
+    const lines = shown.map((row) => (row.description ? '- `' + row.name + '`: ' + row.description : '- `' + row.name + '`'));
+    const out = [
+        '## 技能',
+        '',
+        '**本预设没有官方 `skill` 加载工具；要技能正文时用 `skill_manager_list` 取源文件路径再读。**',
+        '',
+        ...lines,
+    ];
+    const hidden = sorted.length - shown.length;
+    if (hidden > 0)
+        out.push('', `（另有 ${hidden} 个未列出，用 \`skill_manager_list\` 查。）`);
+    return out.join('\n');
+}
+/**
+ * 创建 SWR 的技能目录。计算失败时保留上一次的值（不把段清空），首次失败维持 `''`。
+ * 并发调用共享同一次计算（inflight 折叠）。
+ */
+export function createSkillCatalog(deps, opts = {}) {
+    const ttlMs = opts.ttlMs ?? 30_000;
+    const now = opts.now ?? (() => Date.now());
+    let value = '';
+    let loadedAt = Number.NEGATIVE_INFINITY;
+    let inflight = null;
+    const recompute = async () => {
+        try {
+            const result = await deps.state();
+            if (result && result.ok !== false) {
+                value = renderSkillCatalog(result.data ?? result, opts.maxEntries, opts.maxDescription);
+            }
+        }
+        catch { /* 保留上一次的值；首次失败则维持 '' */ }
+        loadedAt = now();
+    };
+    const revalidate = () => {
+        if (inflight)
+            return inflight;
+        inflight = recompute().finally(() => { inflight = null; });
+        return inflight;
+    };
+    return {
+        text: () => {
+            if (now() - loadedAt > ttlMs)
+                void revalidate();
+            return value;
+        },
+        refresh: () => {
+            loadedAt = Number.NEGATIVE_INFINITY;
+            return revalidate();
+        },
+        warm: () => revalidate(),
+    };
+}

package/lib/skills/core.js

@@ -411,13 +411,15 @@ export function managerHomePath() {
     return join(resolveDshHome(), "tool-management");
 }
 export function managerStatePath() {
-    return join(managerHomePath(), "state.json");
+    return join(managerHomePath(), "skills-state.json");
 }
+/** 技能回收站：与其余四类同形（`hub/trash/<域>-trash/`）。 */
 export function trashRootPath() {
-    return join(managerHomePath(), "trash");
+    return join(managerHomePath(), "trash", "skills-trash");
 }
+/** 插件日志（滚动 `.1`）：收在 hub 内，不再躺在 `$DSH_HOME` 根下。 */
 export function logPath() {
-    return join(resolveDshHome(), "dsh-plugin-tool-management.log");
+    return join(managerHomePath(), "tool-management.log");
 }
 /**
  * 为前端内嵌目录选择器列出一个本机目录层级。
@@ -885,7 +887,7 @@ async function writeFileAtomically(path, content) {
         await fs.writeFile(temp, content, "utf8");
         // Windows 上目标文件会被杀软/索引器短暂占住（EPERM/EACCES/EBUSY）——
         // 场景模式进出时这里写的是技能来源/策略状态，rename 被撞 = 运行时已切、
-        // 状态没落盘。与 rules-index.json 同一处理：重试瞬时占用，全失败才抛。
+        // 状态没落盘。与 memories-index.json 同一处理：重试瞬时占用，全失败才抛。
         await renameWithRetry(temp, path);
     }
     catch (error) {
@@ -1653,6 +1655,38 @@ async function setPolicySkillEnabled(root, name, enabled, log) {
 export async function setSkillEnabled(root, name, enabled, log) {
     return setPolicySkillEnabled(root, name, enabled, log);
 }
+/**
+ * 批量显式停用技能（v0.8.5：新建 / 导入 / 回收站恢复默认不启动 —— 用户裁定）。
+ * 直接写 disabledSkills 名单（与 setSkillEnabled 同一张表），不做 frontmatter 等
+ * 二次校验——调用方传入的必然是刚落盘/刚恢复的条目。
+ * 必须在调用方的写锁（service 的 write()）内执行。
+ * @param {{ root: string, name: string }[]} entries - root = 来源 key。
+ */
+export async function markSkillsDisabled(entries, log) {
+    const list = Array.isArray(entries) ? entries : [];
+    const clean = list
+        .map((e) => ({ root: String((e && e.root) || ""), name: String((e && e.name) || "") }))
+        .filter((e) => e.root !== "" && e.name !== "");
+    if (!clean.length)
+        return { ok: true };
+    const current = await readManagerState();
+    if (current.writable === false)
+        return invalidManagerStateWrite();
+    let dirty = false;
+    for (const e of clean) {
+        const prev = current.state.disabledSkills[e.root] || [];
+        if (prev.indexOf(e.name) >= 0)
+            continue;
+        current.state.disabledSkills[e.root] = [...prev, e.name].sort();
+        dirty = true;
+    }
+    if (dirty) {
+        await writeManagerState(current.state);
+        if (log)
+            log("skill-disable-default", `默认停用 ${clean.map((e) => `${e.root}/${e.name}`).join("、")}`);
+    }
+    return { ok: true };
+}
 /**
  * 同名技能「首选来源」：默认同名技能按来源 rank 取优先级最高者生效、其余显示为被覆盖；
  * 这里让用户显式指定哪个同名技能生效（preferred=false 取消，回到 rank 顺序）。

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 { state, setSkillEnabled, setPreferredSkill, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, permanentlyDeleteTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, skillDetail, listProviderCandidates, getProviderSkill, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, logPath, trashRootPath, } from './core.js';
+import { state, setSkillEnabled, setPreferredSkill, markSkillsDisabled, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, permanentlyDeleteTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, 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';
 const message = (e) => String((e && e.message) || e);
@@ -431,17 +431,43 @@ export function createSkillsService(ctx) {
             // requestRoot 未命中时回传原始 key，让 core 的 error.root.unknown 带上来源名
             // （否则传了不存在的 root 会收到「技能来源不存在：(空)」这种指错方向的提示）。
             const key = String(args.root || 'hub');
-            return createSkill({ name: args.name, description: args.description, body: args.body }, log, { root: (await requestRoot(key)) || key });
+            const res = await createSkill({ name: args.name, description: args.description, body: args.body }, log, { root: (await requestRoot(key)) || key });
+            // v0.8.5：新建技能默认不启动（用户裁定）——与子智能体 / MCP 同口径。
+            if (res && res.ok !== false && res.name) {
+                await markSkillsDisabled([{ root: String(res.root || 'hub'), name: String(res.name) }], log).catch(() => undefined);
+            }
+            return res;
+        }), afterWrite),
+        'skill-import': wrap((args) => write(async () => {
+            const res = await importSkill(String(args.source || ''), log, {
+                conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
+                dryRun: args.dryRun === true,
+            });
+            // 导入的技能默认停用；部分成功也对 imported 逐条停用。
+            const names = res && Array.isArray(res.imported) ? res.imported : [];
+            if (names.length)
+                await markSkillsDisabled(names.map((n) => ({ root: 'hub', name: String(n) })), log).catch(() => undefined);
+            return res;
+        }), afterWrite),
+        'skill-upload': wrap((args) => write(async () => {
+            const res = await importUploadedSkill({ name: args.name, entries: args.entries, zip: args.zip }, log, {
+                conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
+            });
+            // 上传/导入同口径：默认停用。
+            const names = res && Array.isArray(res.imported) ? res.imported : (res && res.name ? [res.name] : []);
+            if (names.length)
+                await markSkillsDisabled(names.map((n) => ({ root: 'hub', name: String(n) })), log).catch(() => undefined);
+            return res;
         }), afterWrite),
-        'skill-import': wrap((args) => write(() => importSkill(String(args.source || ''), log, {
-            conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
-            dryRun: args.dryRun === true,
-        })), afterWrite),
-        'skill-upload': wrap((args) => write(() => importUploadedSkill({ name: args.name, entries: args.entries, zip: args.zip }, log, {
-            conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',
-        })), afterWrite),
         'skill-delete': wrap((args) => write(async () => deleteSkill(await requestRoot(String(args.root || 'dsh')), String(args.name || ''), log)), afterWrite),
-        'skill-trash-restore': wrap((args) => write(() => restoreTrash(String(args.id || ''), log, projectOptions())), afterWrite),
+        'skill-trash-restore': wrap((args) => write(async () => {
+            const res = await restoreTrash(String(args.id || ''), log, projectOptions());
+            // 恢复的技能默认停用（v0.8.5 用户裁定：新建/导入/恢复一律不启动，手动开启）。
+            if (res && res.ok !== false && res.name) {
+                await markSkillsDisabled([{ root: String(res.root || 'hub'), name: String(res.name) }], log).catch(() => undefined);
+            }
+            return res;
+        }), afterWrite),
         'skill-trash-delete': wrap((args) => write(() => permanentlyDeleteTrashSafely(String(args.id || ''), log))),
         // 自定义技能目录：添加（绝对路径，只读接入）/ 移除（连同策略键）。
         'skill-custom-add': wrap((args) => write(() => addCustomRoot(args && args.path, args && args.label, log)), afterWrite),

package/lib/subagents/catalog.js

@@ -8,9 +8,9 @@ import { filterBySceneBinding } from './tools.js';
  * 官方对应的旋钮是 `catalogDescriptionMaxLength`。
  */
 export const DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH = 500;
-/** 段里最多列几个人设；超出部分只报数量，让模型自己去调 subagent_list。 */
+/** 段里最多列几个人设；超出部分只报数量，让模型自己去调 subagent_manager_list。 */
 export const DEFAULT_CATALOG_MAX_ENTRIES = 40;
-/** 无描述时的占位，与 `subagent_list` 工具的输出保持同一口径。 */
+/** 无描述时的占位，与 `subagent_manager_list` 工具的输出保持同一口径。 */
 const NO_DESCRIPTION = '(无描述)';
 /**
  * 描述归一化 + 截断 —— 逐字对齐官方 `dsh-tool-skill` 的实现：
@@ -27,6 +27,13 @@ export function catalogDescription(value, maxLength) {
  *
  * 返回 `''` 表示不注入 —— `renderPrompt` 会删除空段，所以不用人设的用户零 token 成本。
  * 名字按字典序排序：即使底层目录枚举顺序变化，段文本也保持逐字节稳定（前缀缓存契约）。
+ *
+ * 文案纪律（2026-09-16 用户裁定）：**只写模型能照做的事，不写实现说明**。原文两句里
+ * 「该人设的完整提示词会成为子代理的系统提示词」「子代理在独立上下文中执行」都是宿主内部
+ * 机制，模型无法据此行动；而委派的调用语义与成本（自包含任务、只回最终结果、会开新会话）
+ * 已经写在 `subagent_manager_run` 的描述里 —— 常驻层再重复一遍等于同一件事付两次 token。
+ * 第二版（用户指出"太冗余"）：引导语压成**半行** —— 只留「怎么用」，"下面是名字与摘要"这类
+ * 自明的话删掉；域是什么由消息引导语与轨迹行名交代，细节由 `subagent_manager_list` 承担。
  */
 export function renderSubagentCatalog(allowed, maxEntries = DEFAULT_CATALOG_MAX_ENTRIES, maxDescription = DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH) {
     if (!allowed.length)
@@ -36,14 +43,17 @@ export function renderSubagentCatalog(allowed, maxEntries = DEFAULT_CATALOG_MAX_
     const lines = shown.map((p) => '- **' + p.name + '** — ' + (catalogDescription(p.description, maxDescription) || NO_DESCRIPTION));
     const hidden = sorted.length - shown.length;
     const out = [
-        '## 子智能体（人设）',
+        '## 子智能体',
         '',
-        '需要委派独立任务时，用 `subagent_run` 并指定下面的人设名。',
+        '**可委派给下列子智能体（调 `subagent_manager_run`）。**',
         '',
         ...lines,
     ];
+    // 查询工具**只在真被 40 条上限截掉时**才出现：常态下不提，省常驻字符，也免得模型为了
+    // 「确认一遍」去调它（用户裁定：没列出来的就是当前不想要的）。与 MCP 状态段的
+    // `（另有 N 台未列出。）` 同一句式，但这里多给一个出口——不给人设就真的找不回来了。
     if (hidden > 0)
-        out.push('', `（另有 ${hidden} 个未列出，用 subagent_list 查看全部。）`);
+        out.push('', `（另有 ${hidden} 个未列出，用 \`subagent_manager_list\` 查。）`);
     return out.join('\n');
 }
 /**

package/lib/subagents/service.js

@@ -11,12 +11,13 @@ import { resolveDshHome } from '../skills/core.js';
 import { listTrashEntries, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
 import { expandUploads, planPersonaImport } from '../imports/upload.js';
 const message = (e) => String((e && e.message) || e);
-/** 人设默认目录：`$DSH_HOME/tool-management/agents/`。 */
+/** 人设默认目录：`$DSH_HOME/tool-management/subagents/`（域 = 子智能体，工具 `subagent_manager_*`）。 */
 export function defaultPersonasDir() {
-    return join(resolveDshHome(), 'tool-management', 'agents');
+    return join(resolveDshHome(), 'tool-management', 'subagents');
 }
 /**
- * 旧目录 `$DSH_HOME/subagents/` → `tool-management/agents/` 一次性搬移（幂等）。
+ * 旧目录 `$DSH_HOME/subagents/` → `tool-management/subagents/` 一次性搬移（幂等）。
+ * （hub 内 `agents/` → `subagents/` 的改名由 hub.ts 的启动迁移负责。）
  * 只在目标不存在同名文件时搬（绝不覆盖）；源目录保留空壳。每个进程只跑一次。
  */
 let personasRelocated = false;
@@ -131,11 +132,11 @@ const RESULT_MAX = 16 * 1024;
 export function createSubagentService(ctx, opts) {
     const dir = opts?.subagentsDir || defaultPersonasDir();
     const stateDir = opts?.stateDir && opts.stateDir.trim() !== '' ? opts.stateDir : join(resolveDshHome(), 'tool-management');
-    const stateFile = join(stateDir, 'agents-index.json');
+    const stateFile = join(stateDir, 'subagents-index.json');
     const req = createRequire(import.meta.url);
     let cache = null;
     // ── 人设启用集合（子智能体开关）────────────────────────────────────────
-    // agents-index.json：{ version: 1, enabled: string[] }（与 rules-index.json 同目录约定）。
+    // subagents-index.json：{ version: 1, enabled: string[] }（与 memories-index.json 同目录约定）。
     //   - 文件缺失/损坏 = **全部启用**（老用户升级零感知，行为与开关上线前一致）；
     //   - 文件一旦写出即为权威：之后新建/导入/回收站恢复的人设**自动启用**（刚建就想用是常理）；
     //   - 停用只影响注入与 subagent_* 工具的可见性，人设文件一个字节不动。
@@ -161,19 +162,17 @@ export function createSubagentService(ctx, opts) {
         await writeFile(stateFile, JSON.stringify({ version: 1, enabled: list }, null, 2), 'utf8');
         enabledCache = list;
     }
-    /** 新建/导入/恢复的人设默认启用；文件缺失（本来就全启用）时无需写。 */
-    async function enablePersonaNames(names) {
+    /** 新建/导入/恢复的人设默认停用（v0.8.5 用户裁定，与技能 / MCP 同口径）：
+     *  文件缺失（含旧数据）时先把「全部启用」物化成显式全集**并排除新名**——
+     *  否则新名会随"文件缺失=全启用"的兼容语义被误判为启用。已有显式集合时新名
+     *  不在集合里，天然停用，无需写盘。 */
+    async function materializeEnabledExcluding(names) {
         const set = await readEnabled();
-        if (set === null)
+        if (set !== null)
             return;
-        let dirty = false;
-        for (const n of names)
-            if (set.indexOf(n) < 0) {
-                set.push(n);
-                dirty = true;
-            }
-        if (dirty)
-            await writeEnabled(set);
+        const docs = await list();
+        await writeEnabled(docs.map((d) => d.name).filter((n) => names.indexOf(n) < 0));
+        cache = null;
     }
     /** 改名跟随：旧名在集合里就改新名；不在（停用中）保持停用。 */
     async function renamePersonaInEnabled(from, to) {
@@ -354,8 +353,8 @@ export function createSubagentService(ctx, opts) {
                 return { ok: false, error: `创建人设目录失败: ${dir}（${message(e)}）` };
             }
             await writeFile(target, serializePersona(args), 'utf8');
-            // 新建即启用（文件缺失 = 本来全启用，无需写）；缓存失效让下次 list 带上新成员。
-            await enablePersonaNames([name]).catch(() => undefined);
+            // v0.8.5：新建默认不启动——显式集合下新名天然停用；文件缺失时先物化全集并排除新名。
+            await materializeEnabledExcluding([name]).catch(() => undefined);
             cache = null;
             return { ok: true, name };
         },
@@ -412,17 +411,17 @@ export function createSubagentService(ctx, opts) {
             const exists = await readFile(target, 'utf8').then(() => true).catch(() => false);
             if (!exists)
                 return { ok: false, error: `人设不存在: ${name}` };
-            const moved = await moveToTrash('agents', name, [{ from: target, dest: 'persona.md' }]);
+            const moved = await moveToTrash('subagents', name, [{ from: target, dest: 'persona.md' }]);
             if (moved.ok === false)
                 return { ok: false, error: `移入回收站失败: ${moved.error}` };
             await removePersonaFromEnabled(name).catch(() => undefined);
             cache = null;
             return { ok: true, name, trashId: moved.id };
         },
-        'subagent-trash-list': async () => ({ ok: true, trash: await listTrashEntries('agents') }),
+        'subagent-trash-list': async () => ({ ok: true, trash: await listTrashEntries('subagents') }),
         'subagent-trash-restore': async (args) => {
             const id = String((args && args.id) || '').trim();
-            const entry = await readTrashEntry('agents', id);
+            const entry = await readTrashEntry('subagents', id);
             if (!entry)
                 return { ok: false, error: `回收站条目不存在: ${id}` };
             if (!validPersonaName(entry.name))
@@ -434,20 +433,20 @@ export function createSubagentService(ctx, opts) {
                 return { ok: false, error: `无法恢复，同名人设已存在: ${entry.name}` };
             try {
                 await mkdir(dir, { recursive: true });
-                await moveOutOfTrash('agents', id, 'persona.md', target);
+                await moveOutOfTrash('subagents', id, 'persona.md', target);
             }
             catch (e) {
                 return { ok: false, error: `恢复失败: ${message(e)}` };
             }
-            await purgeTrashEntry('agents', id);
-            // 恢复 = 拿回来用：自动启用（文件缺失本来就全启用，无需写）。
-            await enablePersonaNames([entry.name]).catch(() => undefined);
+            await purgeTrashEntry('subagents', id);
+            // v0.8.5：回收站恢复默认不启动（与新建/导入同口径）。
+            await materializeEnabledExcluding([entry.name]).catch(() => undefined);
             cache = null;
             return { ok: true, name: entry.name };
         },
         'subagent-trash-delete': async (args) => {
             const id = String((args && args.id) || '').trim();
-            const gone = await purgeTrashEntry('agents', id);
+            const gone = await purgeTrashEntry('subagents', id);
             if (!gone)
                 return { ok: false, error: `回收站条目不存在: ${id}` };
             return { ok: true, id };
@@ -492,13 +491,13 @@ export function createSubagentService(ctx, opts) {
                 imported.push(target.name);
             }
             if (imported.length) {
-                await enablePersonaNames(imported).catch(() => undefined);
+                await materializeEnabledExcluding(imported).catch(() => undefined);
                 cache = null;
             }
             return { ok: true, imported, skipped };
         },
         /**
-         * 子智能体开关（v0.8）：停用 = 不注入目录段、subagent_list/run 不可见；文件本体不动。
+         * 子智能体开关（v0.8）：停用 = 不注入目录段、subagent_manager_list/run 不可见；文件本体不动。
          * `enabled` 必须显式给布尔值 —— 与 rules-toggle 同一条口径：不按"翻转"推断，
          * 免得参数丢了时界面以为改了、实际什么都没动。
          */
@@ -535,6 +534,18 @@ export function createSubagentService(ctx, opts) {
             const state = new Map(docs.map((d) => [d.name, d.enabled !== false]));
             return names.filter((n) => state.get(n) === false);
         },
+        /** 指定名单里当前**开着**的（进入模式把未勾的关掉时，只记将被关闭的行）。 */
+        async enabledAmong(names) {
+            const docs = await list();
+            const state = new Map(docs.map((d) => [d.name, d.enabled !== false]));
+            return names.filter((n) => state.get(n) === true);
+        },
+        /** 当前开着的人设全名单（档案页把页面的「开关」落成场景绑定时用）。 */
+        async enabledNames() {
+            const docs = await list();
+            const state = new Map(docs.map((d) => [d.name, d.enabled !== false]));
+            return docs.map((d) => d.name).filter((n) => state.get(n) === true);
+        },
         /** 批量启停；只碰给出的名字，人设已不存在的跳过（别把悬空名写进集合）。 */
         async setEnabled(names, enabled) {
             const docs = await list();