dsh-plugin-tool-management 0.8.5 → 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) {

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,15 +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_list` 查看全部人设）。',
-        '用 `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_* 工具的可见性，人设文件一个字节不动。
@@ -410,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))
@@ -432,12 +433,12 @@ 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 purgeTrashEntry('subagents', id);
             // v0.8.5：回收站恢复默认不启动（与新建/导入同口径）。
             await materializeEnabledExcluding([entry.name]).catch(() => undefined);
             cache = null;
@@ -445,7 +446,7 @@ export function createSubagentService(ctx, opts) {
         },
         '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 };
@@ -496,7 +497,7 @@ export function createSubagentService(ctx, opts) {
             return { ok: true, imported, skipped };
         },
         /**
-         * 子智能体开关（v0.8）：停用 = 不注入目录段、subagent_list/run 不可见；文件本体不动。
+         * 子智能体开关（v0.8）：停用 = 不注入目录段、subagent_manager_list/run 不可见；文件本体不动。
          * `enabled` 必须显式给布尔值 —— 与 rules-toggle 同一条口径：不按"翻转"推断，
          * 免得参数丢了时界面以为改了、实际什么都没动。
          */
@@ -533,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();

package/lib/subagents/tools.js

@@ -16,31 +16,36 @@ export async function filterBySceneBinding(docs, enabledSceneLists) {
     const allowed = live.filter((d) => bound.has(d.name));
     return { allowed, reason: allowed.length ? null : `当前启用场景的子智能体绑定: ${[...bound].join('、')}` };
 }
-export function defineSubagentListTool(subagents) {
+export function defineSubagentManagerListTool(subagents) {
     return {
-        name: 'subagent_list',
-        description: 'List available personas (pre-configured subagent profiles) with their descriptions. Call before subagent_run.',
-        parameters: {
-            scene: { type: 'string', description: 'Optional scene name filter (informational; the tool already reflects scene binding).' },
-        },
+        name: 'subagent_manager_list',
+        description: 'List available personas (pre-configured subagent profiles) with their descriptions. Call before subagent_manager_run.',
+        parameters: {},
         output: {
             schema: { type: 'string' },
             render: (_a, v) => text(String(v)),
         },
-        async execute() {
+        async execute(_args, exec) {
             const { allowed, reason } = await filterBySceneBinding(await subagents.list(), await subagents.sceneLists());
             const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(无描述)'));
-            return '人设子智能体（' + allowed.length + '）：\n' + (lines.join('\n') || '(无)') + (reason ? '\n注意：' + reason : '');
+            let notice = '';
+            try {
+                notice = typeof subagents.noticeFor === 'function' ? await subagents.noticeFor(exec) : '';
+            }
+            catch {
+                notice = '';
+            }
+            return '人设子智能体（' + allowed.length + '）：\n' + (lines.join('\n') || '(无)') + (reason ? '\n注意：' + reason : '') + notice;
         },
     };
 }
-export function defineSubagentRunTool(subagents) {
+export function defineSubagentManagerRunTool(subagents) {
     return {
-        name: 'subagent_run',
-        description: 'Run a named persona as a one-shot subagent: it receives the persona as its own system prompt, works on `task` in a fresh context, and returns only its final output. Discover personas with subagent_list first. Each run is stateless and ephemeral; it does not see this conversation.',
+        name: 'subagent_manager_run',
+        description: 'Run a named persona as a one-shot subagent: it gets the persona as its own system prompt, works on `task` in a fresh context, and returns only its final output. Stateless — it does not see this conversation. Expensive: starts a fresh model session, so use it only for self-contained work.',
         parameters: {
-            agent: { type: 'string', required: true, description: 'Persona name from subagent_list.' },
-            task: { type: 'string', required: true, description: 'Complete, self-contained task for the subagent (include all context it needs).' },
+            agent: { type: 'string', required: true, description: 'Persona name from subagent_manager_list.' },
+            task: { type: 'string', required: true, description: 'Self-contained task, with all context the subagent needs.' },
         },
         output: {
             schema: { type: 'string' },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-plugin-tool-management",
-  "version": "0.8.5",
-  "description": "DSH plugin: one settings panel for MCP servers, skills, scenes, memories, subagents, AGENTS.md presets and archived sessions — scene memory injects into the system prompt, scene lock freezes all five domains, deleted workspaces re-register with one click. Settings UI + HTTP API + 14 model tools (skill_mcp_manager_*, skill_manager_*, agentsmd_*, rule_manager_*, subagent_*). Install with one command: dsh plugin --profile web add dsh-plugin-tool-management@latest",
+  "version": "0.9.0",
+  "description": "DSH plugin: one settings panel for MCP servers, skills, scenes, memories, subagents, AGENTS.md presets and archived sessions — scene memory injects into the system prompt, scene lock freezes all five domains, deleted workspaces re-register with one click. Settings UI + HTTP API + 14 model tools (mcp_manager_*, skill_manager_*, prompt_manager_*, memory_manager_*, subagent_*). Install with one command: dsh plugin --profile web add dsh-plugin-tool-management@latest",
   "repository": {
     "type": "git",
     "url": "https://github.com/ouli-1242/dsh-plugin-tool-management"
@@ -41,7 +41,8 @@
     "check:host": "node scripts/host-deps.mjs && node scripts/doctor.mjs",
     "host-deps": "node scripts/host-deps.mjs --fix",
     "doctor": "node scripts/doctor.mjs",
-    "test": "npm run build && npm run check:i18n && node --test test/archive.test.mjs test/import.test.mjs test/approval-policy.test.mjs test/subagent-scene.test.mjs test/subagent-persona.test.mjs test/hub-layout.test.mjs test/skills-state.test.mjs test/skills-delete.test.mjs test/skills-source-remove.test.mjs test/client-exports.test.mjs test/client-render.test.mjs test/compat-probe.test.mjs test/compat-fallback.test.mjs test/preset-reach.test.mjs test/rules-toggle-args.test.mjs"
+    "test": "npm run build && npm run check:i18n && node --test test/client-exports.test.mjs test/client-render.test.mjs",
+    "sync:profile": "node scripts/sync-profile.mjs"
   },
   "keywords": [
     "dsh",
@@ -66,12 +67,14 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-tools": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-workspace": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-spill-local": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": ">=0.1.5-rc.2",
     "@deepseek-ai/dsh-session-projection-cache": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-spill-local": ">=0.1.5-rc.2",
     "@deepseek-ai/dsh-storage-domain": ">=0.1.5-rc.2",
     "@deepseek-ai/dsh-subagent-spawn-in-process": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-workspace": ">=0.1.5-rc.2",
     "react": "^18.2.0"
   },
   "peerDependenciesMeta": {
@@ -81,6 +84,8 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-session-projection-cache": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-spill-local": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-storage-domain": "^0.1.5-rc.2",

package/screenshots.json

@@ -1,10 +1,10 @@
 [
-  "docs/images/1场景.png",
-  "docs/images/2MCP.png",
-  "docs/images/3技能.png",
-  "docs/images/4子智能体.png",
-  "docs/images/5提示词.png",
-  "docs/images/6记忆.png",
-  "docs/images/7会话.png",
-  "docs/images/8兼容.png"
+  "docs/images/1.png",
+  "docs/images/2.png",
+  "docs/images/3.png",
+  "docs/images/4.png",
+  "docs/images/5.png",
+  "docs/images/6.png",
+  "docs/images/7.png",
+  "docs/images/8.png"
 ]