dsh-plugin-tool-management 0.6.0 → 0.7.0

package/lib/rules/service.js

@@ -34,6 +34,7 @@ import { expandUploads, planMemoryImport } from '../imports/upload.js';
 import { createRuleProviderRegistrar } from './provider.js';
 import { normalizePresetId } from '../agents-md/preset-id.js';
 import { normalizeArchive, memoryAllowed } from './archive.js';
+import { listTrashEntries, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
 // ── 常量 ───────────────────────────────────────────────────────────────────
 const MAX_SOURCE_DEPTH = 64; // 与 core.js 一致
 const MAX_DIRECTORIES = 2000; // 目录预算
@@ -2047,9 +2048,16 @@ export function createRulesService(ctx, deps) {
         const parts = parseId(id);
         if (!parts)
             return fail('error.rules.notFound', `规则不存在：${id}`);
+        // `enabled` 必须显式给。缺省时旧实现回落到"沿用当前值"，却照样刷新
+        // updatedAt 并返回 ok:true —— 调用方按 toggle（翻转）理解时会以为自己改了
+        // 状态，实际什么都没改（界面不受影响：它一直显式传值）。与 rulesSetActive
+        // 同一条口径：参数缺失就明确拒绝，不猜。
+        if (typeof (args && args.enabled) !== 'boolean') {
+            return fail('error.rules.invalidArgs', '缺少参数：enabled 必须是布尔值（toggle 只按传入值写入，不做"翻转"推断）');
+        }
         const index = await readIndex(stateDir);
         const idxEntry = index.rules[id] || {};
-        const enabled = args && args.enabled !== undefined ? args.enabled === true : (idxEntry.enabled ?? true);
+        const enabled = args.enabled === true;
         index.rules[id] = { ...idxEntry, enabled, updatedAt: new Date().toISOString() };
         await writeIndex(stateDir, index);
         invalidateSnapshot();
@@ -2252,6 +2260,15 @@ export function createRulesService(ctx, deps) {
         if (index.mode?.scene === name) {
             return fail('error.rules.sceneInMode', `场景「${name}」正处在当前模式，请先退出模式再删除`);
         }
+        // 场景本体（记录 + 档案）**先移入回收站**，再从索引里摘掉——这样「删除场景」
+        // 是可恢复的。记忆目录必须是空的（上面已拦），所以没有正文需要搬。
+        const trashed = await moveToTrash('scenes', name, [], {
+            record: (index.scenes && index.scenes[name]) || null,
+            archive: (index.archives && index.archives[name]) || null,
+        });
+        if (trashed.ok === false) {
+            return fail('error.rules.ioFailed', `移入回收站失败：${trashed.error}`);
+        }
         try {
             // fs.rm 删目录必须 recursive（即使已确认它是空的），否则报 EISDIR。
             await rm(join(rulesRoot, name), { recursive: true, force: true });
@@ -2277,8 +2294,63 @@ export function createRulesService(ctx, deps) {
             await writeIndex(stateDir, index);
         invalidateSnapshot();
         invalidateProviders();
+        return { ok: true, name, trashId: trashed.id };
+    }
+    /** 场景回收站列表（只读）：`<hub>/trash/scenes-trash/<id>/manifest.json`。 */
+    async function sceneTrashList() {
+        return { ok: true, trash: await listTrashEntries('scenes') };
+    }
+    /**
+     * 从回收站恢复一个场景：重建记忆目录 + 写回记录与档案。
+     * 同名场景已存在时**拒绝**（绝不覆盖既有场景）。
+     */
+    async function sceneTrashRestore(args) {
+        const id = String((args && args.id) || '').trim();
+        const entry = await readTrashEntry('scenes', id);
+        if (!entry)
+            return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+        const name = String(entry.name || '').trim();
+        if (!isValidGroupSegment(name))
+            return fail('error.rules.invalidGroup', `回收站里的场景名非法：${name || '(空)'}`);
+        const index = await readIndex(stateDir);
+        if (index.scenes?.[name])
+            return fail('error.rules.invalidGroup', `无法恢复，同名场景已存在：${name}`);
+        const dir = join(rulesRoot, name);
+        let entries = [];
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            entries = [];
+        }
+        if (entries.filter((n) => !n.startsWith('.')).length > 0) {
+            return fail('error.rules.sceneNotEmpty', `无法恢复，记忆目录「${name}」里已有内容，请先处理`);
+        }
+        const data = (entry.data || {});
+        try {
+            await mkdir(dir, { recursive: true });
+        }
+        catch (e) {
+            return fail('error.rules.ioFailed', `重建场景目录失败：${message(e)}`);
+        }
+        if (data.record && typeof data.record === 'object')
+            index.scenes = { ...(index.scenes || {}), [name]: data.record };
+        if (data.archive && typeof data.archive === 'object')
+            index.archives = { ...(index.archives || {}), [name]: data.archive };
+        await writeIndex(stateDir, index);
+        await purgeTrashEntry('scenes', id);
+        invalidateSnapshot();
+        invalidateProviders();
         return { ok: true, name };
     }
+    /** 永久删除一条场景回收站条目。 */
+    async function sceneTrashDelete(args) {
+        const id = String((args && args.id) || '').trim();
+        const gone = await purgeTrashEntry('scenes', id);
+        if (!gone)
+            return fail('error.rules.notFound', `回收站条目不存在：${id}`);
+        return { ok: true, id };
+    }
     /**
      * 提示词预设改名后**同步场景绑定**：把所有 `scenes[].prompt === from` 改成 `to`。
      * 由 AGENTS.md 预设库的改名路径调用——绑定存在 `rules-index.json` 里，预设库
@@ -2365,6 +2437,8 @@ export function createRulesService(ctx, deps) {
         'rules-create', 'rules-update', 'rules-remove', 'rules-restore', 'rules-toggle', 'rules-import',
         'rules-set-index', 'rules-set-active', 'rules-create-scene', 'rules-update-scene', 'rules-remove-scene', 'rules-rebind-prompt',
         'rules-attach', 'rules-detach', 'rules-trash-remove',
+        // 场景回收站（与记忆回收站 rules-trash-* 分开：那套管记忆正文，这套管场景记录与档案）
+        'scene-trash-restore', 'scene-trash-delete',
     ]);
     const ops = {
         'rules-list': (args) => rulesList(args || {}),
@@ -2386,6 +2460,9 @@ export function createRulesService(ctx, deps) {
         'rules-create-scene': (args) => runWrite(() => rulesCreateScene(args || {})),
         'rules-update-scene': (args) => runWrite(() => rulesUpdateScene(args || {})),
         'rules-remove-scene': (args) => runWrite(() => rulesRemoveScene(args || {})),
+        'scene-trash-list': () => sceneTrashList(),
+        'scene-trash-restore': (args) => runWrite(() => sceneTrashRestore(args || {})),
+        'scene-trash-delete': (args) => runWrite(() => sceneTrashDelete(args || {})),
         'rules-rebind-prompt': (args) => runWrite(() => rulesRebindPrompt(args || {})),
     };
     const service = {

package/lib/skills/core.js

@@ -178,6 +178,9 @@ export function customRootsFromState(stateValue) {
             label: typeof item.label === "string" && item.label.trim()
                 ? item.label.trim().slice(0, 64)
                 : "自定义目录",
+            // 用户加进来的来源（相对「按约定发现」的 dsh / hub / agents / codex / claude）：
+            // 界面据此决定要不要给「永久删除」——只有自定义来源能真正从插件里删掉记录。
+            custom: true,
             mutable: false,
             toggleable: true,
             native: false,
@@ -280,6 +283,10 @@ export async function removeCustomRoot(key, log) {
     delete current.state.sources[clean];
     delete current.state.disabledSkills[clean];
     delete current.state.enabledSkills[clean];
+    // 已移除记录一起清掉：否则「永久删除」之后状态文件里还留着一条指向不存在来源的脏键
+    // （读取时的 normalize 会丢弃它，但没理由写进去）。
+    if (Array.isArray(current.state.removedSources))
+        current.state.removedSources = current.state.removedSources.filter((key) => key !== clean);
     await writeManagerState(current.state);
     if (log)
         log("custom-remove", `移除自定义技能目录 ${target.path} (${clean})`);
@@ -2904,6 +2911,8 @@ export async function state(options = {}) {
                 mutable: root.mutable,
                 deletable: root.deletable === true,
                 removable: !isDefaultSkillSource(root) && root.scope !== "project",
+                // 自定义来源（用户手加的目录）：只有它能「永久删除」——按约定发现的来源删不掉。
+                custom: root.custom === true,
                 // 默认来源（dsh / hub）：界面据此隐藏来源开关、只显示「可管理」标记。
                 defaultSource: isDefaultSkillSource(root),
                 toggleable: root.toggleable,
@@ -2983,6 +2992,8 @@ export async function state(options = {}) {
             truncated: truncated === true,
             // 界面用：能否从管理器「移除」（不再读取）。dsh / hub / 项目级不可移除。
             removable: !isDefaultSkillSource(root) && root.scope !== "project",
+            // 自定义来源（用户手加的目录）：只有它能「永久删除」——按约定发现的来源删不掉。
+            custom: root.custom === true,
             // 默认来源（dsh / hub）：界面据此隐藏来源开关（它们不能停用），换成「可管理」标记。
             defaultSource: isDefaultSkillSource(root),
             removed: false,

package/lib/skills/service.js

@@ -397,6 +397,9 @@ export function createSkillsService(ctx) {
     // 写操作清单：与下方 ops 表同文件同源维护；HTTP 端门禁由 index.ts 从本集合派生，勿在宿主端另抄一份。
     const writeOps = new Set([
         'skill-enable', 'skill-disable', 'skill-source-enable', 'skill-source-disable',
+        // 移除/恢复来源会改写本地来源状态（listProviderCandidates 随之变化，模型侧的技能目录
+        // 也变），是写操作；漏在这份清单里 = 配了访问令牌也不会被要求带令牌。
+        'skill-source-remove', 'skill-source-restore',
         'skill-prefer', 'skill-unprefer',
         'skill-create', 'skill-import', 'skill-upload', 'skill-delete',
         'skill-trash-restore', 'skill-trash-delete', 'skill-custom-add', 'skill-custom-remove',

package/lib/subagents/service.js

@@ -5,9 +5,10 @@
 // v0.4 目录变更：人设由 `$DSH_HOME/subagents/` 搬到 `$DSH_HOME/tool-management/agents/`
 // （插件产生的文件统一收在 tool-management/ 下）。旧目录在首次扫描时搬入，见 relocateLegacyPersonas。
 import { createRequire } from 'node:module';
-import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 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/`。 */
@@ -50,25 +51,66 @@ async function relocateLegacyPersonas(dir) {
         }
     }
 }
-/** 行式 frontmatter 解析：只认 description / provider / model / tools / toolsDeny 五个键。 */
+/** 逗号/顿号分隔的名字清单（空串 → undefined）。 */
+function listOf(value) {
+    const text = String(value ?? '').trim();
+    if (!text)
+        return undefined;
+    const list = text.split(/[,，]/).map((s) => s.trim()).filter(Boolean);
+    return list.length ? list : undefined;
+}
+/**
+ * 解析 `toolsByPreset:` 块 —— 每个 Agent 预设一行：
+ *
+ * ```yaml
+ * toolsByPreset:
+ *   standard: allow: read, write
+ *   ptc: deny: workflow
+ * ```
+ *
+ * 缩进即"在块内"，回到顶格即块结束（frontmatter 只有这一处嵌套，所以不需要完整
+ * YAML 解析器）。模式 id 只做形状校验，认不认得由运行时按当前预设名单判断。
+ */
+export function parsePresetToolRules(frontmatter) {
+    const rules = {};
+    let inBlock = false;
+    for (const raw of frontmatter.split(/\r?\n/)) {
+        const line = raw.replace(/\s+#.*$/, '');
+        if (!inBlock) {
+            if (/^toolsbypreset\s*:\s*$/i.test(line.trim()))
+                inBlock = true;
+            continue;
+        }
+        if (line.trim() === '')
+            continue;
+        if (!/^\s/.test(line))
+            break;
+        const m = /^\s*([A-Za-z0-9._-]+)\s*:\s*(allow|deny)\s*:\s*(.*)$/i.exec(line);
+        if (!m)
+            continue;
+        const names = listOf(m[3]);
+        // 空名单 = 不限制 = 不落盘，读到时也直接忽略，免得把"没开"读成"开了但空"。
+        if (!names)
+            continue;
+        rules[m[1]] = { mode: m[2].toLowerCase() === 'deny' ? 'deny' : 'allow', names };
+    }
+    return Object.keys(rules).length ? rules : undefined;
+}
+/** 行式 frontmatter 解析：只认 description / provider / model / tools / toolsDeny / toolsByPreset。 */
 export function parsePersona(raw, fallbackName) {
     const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(raw);
     const data = {};
     let body = raw;
+    let toolsByPreset;
     if (m) {
         for (const line of m[1].split(/\r?\n/)) {
             const kv = /^([A-Za-z_-]+)\s*:\s*(.*)$/.exec(line.trim());
             if (kv)
                 data[kv[1].toLowerCase()] = kv[2].trim();
         }
+        toolsByPreset = parsePresetToolRules(m[1]);
         body = raw.slice(m[0].length);
     }
-    const listOf = (value) => {
-        if (!value)
-            return undefined;
-        const list = value.split(/[,，]/).map((s) => s.trim()).filter(Boolean);
-        return list.length ? list : undefined;
-    };
     const tools = listOf(data.tools);
     // 兼容两种写法：`toolsdeny: a, b`（线上格式）与 `toolsDeny: a, b`（键名统一小写后同形）。
     const toolsDeny = listOf(data.toolsdeny);
@@ -80,6 +122,7 @@ export function parsePersona(raw, fallbackName) {
         model: data.model || undefined,
         tools,
         toolsDeny,
+        ...(toolsByPreset === undefined ? {} : { toolsByPreset }),
         body: body.trim(),
         path: '',
     };
@@ -155,8 +198,14 @@ export function createSubagentService(ctx, opts) {
             throw new Error('spawn provider 挂载后仍未出现在 ctx.subagents.list()（宿主版本不匹配？）');
         return runtime;
     }
-    async function runOnce(parentAgent, p, task, signal) {
+    async function runOnce(parentAgent, p, task, signal, toolFilter) {
         const runtime = await ensureSpawnProvider();
+        // 工具限制三态：对象 = 调用方已按当前预设决定；null = 调用方明确决定不加限制；
+        // undefined = 调用方没决定（如别的入口直接调 runSerial）→ 回落人设里的旧格式全局名单。
+        const legacyFilter = (p.tools?.length || p.toolsDeny?.length)
+            ? { ...(p.tools?.length ? { allow: p.tools } : {}), ...(p.toolsDeny?.length ? { deny: p.toolsDeny } : {}) }
+            : null;
+        const resolved = toolFilter === undefined ? legacyFilter : toolFilter;
         // 官方签名：start(name, request) —— name = ctx.subagents 上的 provider 注册名。
         const run = await runtime.start('spawn', {
             label: p.name,
@@ -166,10 +215,8 @@ export function createSubagentService(ctx, opts) {
             prompt: [{ type: 'text', text: task }],
             persona: p.body,
             // 工具白/黑名单 → 官方 ToolRestriction（`deny` 优先级高于 `allow`；未知名官方会直接拒绝启动，
-            // 所以选择器给的是「全体预设工具并集」，见 index.ts presetToolCandidates）。
-            ...((p.tools?.length || p.toolsDeny?.length)
-                ? { toolFilter: { ...(p.tools?.length ? { allow: p.tools } : {}), ...(p.toolsDeny?.length ? { deny: p.toolsDeny } : {}) } }
-                : {}),
+            // 所以名单由 index.ts 按当前预设 + 当前真实存在的工具名算好再传进来，见 decideToolFilter）。
+            ...(resolved === null ? {} : { toolFilter: resolved }),
             maxDepth: 1,
             // provider 与 model 是模型路由的两半：DSH 的 resolveModel(provider, model) 不做
             // `provider/model` 字符串拆分，只改 model 会落在**主会话的 provider** 上——跨来源
@@ -197,8 +244,8 @@ export function createSubagentService(ctx, opts) {
     }
     // v1 串行：同一时刻至多一个子代理运行（设计 §3.2）。
     let chain = Promise.resolve();
-    const runSerial = (parentAgent, p, task, signal) => {
-        const queued = chain.then(() => runOnce(parentAgent, p, task, signal), () => runOnce(parentAgent, p, task, signal));
+    const runSerial = (parentAgent, p, task, signal, toolFilter) => {
+        const queued = chain.then(() => runOnce(parentAgent, p, task, signal, toolFilter), () => runOnce(parentAgent, p, task, signal, toolFilter));
         chain = queued.catch(() => undefined);
         return queued;
     };
@@ -207,7 +254,7 @@ export function createSubagentService(ctx, opts) {
             const docs = await list();
             return {
                 ok: true,
-                subagents: docs.map((p) => ({ name: p.name, description: p.description, provider: p.provider ?? null, model: p.model ?? null, tools: p.tools ?? null, toolsDeny: p.toolsDeny ?? null })),
+                subagents: docs.map((p) => ({ name: p.name, description: p.description, provider: p.provider ?? null, model: p.model ?? null, tools: p.tools ?? null, toolsDeny: p.toolsDeny ?? null, toolsByPreset: p.toolsByPreset ?? null })),
             };
         },
         'subagent-get': async (args) => {
@@ -216,7 +263,7 @@ export function createSubagentService(ctx, opts) {
             const p = docs.find((d) => d.name === name);
             if (!p)
                 return { ok: false, error: `人设不存在: ${name}` };
-            return { ok: true, persona: { name: p.name, description: p.description, provider: p.provider ?? '', model: p.model ?? '', tools: p.tools ?? [], toolsDeny: p.toolsDeny ?? [], body: p.body } };
+            return { ok: true, persona: { name: p.name, description: p.description, provider: p.provider ?? '', model: p.model ?? '', tools: p.tools ?? [], toolsDeny: p.toolsDeny ?? [], toolsByPreset: p.toolsByPreset ?? {}, body: p.body } };
         },
         'subagent-create': async (args) => {
             const name = String((args && args.name) || '').trim();
@@ -250,13 +297,55 @@ export function createSubagentService(ctx, opts) {
             cache = null;
             return { ok: true, name };
         },
+        /**
+         * 删除人设 = **移入回收站**（`hub/trash/agents-trash/<id>/persona.md`）。
+         * 早先这里是 `rm`，而界面按钮写着「移入回收站」——文案与行为不一致；现在行为追上文案，
+         * 误删可以从子智能体页的回收站里恢复。
+         */
         'subagent-delete': async (args) => {
             const name = String((args && args.name) || '').trim();
             if (!validPersonaName(name))
                 return { ok: false, error: `人设名不合法: ${name || '(空)'}` };
-            await rm(join(dir, name + '.md')).catch(() => { });
+            const target = join(dir, name + '.md');
+            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' }]);
+            if (moved.ok === false)
+                return { ok: false, error: `移入回收站失败: ${moved.error}` };
             cache = null;
-            return { ok: true, name };
+            return { ok: true, name, trashId: moved.id };
+        },
+        'subagent-trash-list': async () => ({ ok: true, trash: await listTrashEntries('agents') }),
+        'subagent-trash-restore': async (args) => {
+            const id = String((args && args.id) || '').trim();
+            const entry = await readTrashEntry('agents', id);
+            if (!entry)
+                return { ok: false, error: `回收站条目不存在: ${id}` };
+            if (!validPersonaName(entry.name))
+                return { ok: false, error: `回收站里的人设名不合法: ${entry.name}` };
+            const target = join(dir, entry.name + '.md');
+            const exists = await readFile(target, 'utf8').then(() => true).catch(() => false);
+            // 绝不覆盖：同名人设已经存在时如实拒绝，让人自己决定怎么办。
+            if (exists)
+                return { ok: false, error: `无法恢复，同名人设已存在: ${entry.name}` };
+            try {
+                await mkdir(dir, { recursive: true });
+                await moveOutOfTrash('agents', id, 'persona.md', target);
+            }
+            catch (e) {
+                return { ok: false, error: `恢复失败: ${message(e)}` };
+            }
+            await purgeTrashEntry('agents', id);
+            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);
+            if (!gone)
+                return { ok: false, error: `回收站条目不存在: ${id}` };
+            return { ok: true, id };
         },
         /**
          * 导入人设（.md / .zip）：一个 .md 一个人设，文件名（去扩展名）= 人设名；
@@ -302,20 +391,46 @@ export function createSubagentService(ctx, opts) {
             return { ok: true, imported, skipped };
         },
     };
-    return { list, runSerial, ops, writeOps: new Set(['subagent-create', 'subagent-update', 'subagent-delete', 'subagent-import']) };
+    return { list, runSerial, ops, writeOps: new Set(['subagent-create', 'subagent-update', 'subagent-delete', 'subagent-import', 'subagent-trash-restore', 'subagent-trash-delete']) };
 }
 function validPersonaName(name) {
     return name.length > 0 && name.length <= 64 && !name.startsWith('.') && !/[\\/<>:"|?*]/.test(name);
 }
+/** 字符串数组规范化（非数组/空项都丢掉）。 */
+function toStringList(value) {
+    return Array.isArray(value) ? value.map((x) => String(x).trim()).filter(Boolean) : [];
+}
+/**
+ * 规范化前端传来的 `toolsByPreset`：丢掉空名单（空 = 不限制 = 不落盘），
+ * 模式 id 只收形状合法的（预设 id 允许字母数字点横线）。
+ */
+export function presetRulesOf(value) {
+    if (value === null || typeof value !== 'object')
+        return [];
+    const out = [];
+    for (const [rawId, rawRule] of Object.entries(value)) {
+        const id = String(rawId).trim();
+        if (!id || !/^[A-Za-z0-9._-]+$/.test(id))
+            continue;
+        if (rawRule === null || typeof rawRule !== 'object')
+            continue;
+        const rec = rawRule;
+        const names = toStringList(rec.names);
+        if (!names.length)
+            continue;
+        out.push([id, { mode: String(rec.mode) === 'deny' ? 'deny' : 'allow', names }]);
+    }
+    return out;
+}
 /** 人设文件序列化：frontmatter 只写用户填过的键；正文 = 人设提示词。 */
 export function serializePersona(args) {
     const description = String((args && args.description) || '').replace(/\r?\n/g, ' ').trim();
     const provider = String((args && args.provider) || '').trim();
     const model = String((args && args.model) || '').trim();
-    const toList = (v) => (Array.isArray(v) ? v.map((x) => String(x).trim()).filter(Boolean) : []);
-    const tools = toList(args?.tools);
+    const tools = toStringList(args?.tools);
     // 黑名单字段兼容两种入参名：toolsDeny（UI/camel）与 tools_deny（snake）。
-    const toolsDeny = toList(args?.toolsDeny ?? args?.tools_deny);
+    const toolsDeny = toStringList(args?.toolsDeny ?? args?.tools_deny);
+    const byPreset = presetRulesOf(args?.toolsByPreset);
     const body = String((args && args.body) ?? '').trim();
     const lines = ['---'];
     if (description)
@@ -328,6 +443,65 @@ export function serializePersona(args) {
         lines.push('tools: ' + tools.join(', '));
     if (toolsDeny.length)
         lines.push('toolsDeny: ' + toolsDeny.join(', '));
+    if (byPreset.length) {
+        lines.push('toolsByPreset:');
+        for (const [id, rule] of byPreset)
+            lines.push('  ' + id + ': ' + rule.mode + ': ' + rule.names.join(', '));
+    }
     lines.push('---', '', body, '');
     return lines.join('\n');
 }
+/**
+ * 按**当前会话的 Agent 预设**决定这次委派下发什么工具限制。
+ *
+ * 为什么必须按预设分：子代理跑在父会话的预设里（官方 `composeFrom(childCtx, parent.ctx)`），
+ * 而各预设的工具集合差别极大（极简模式只有持久 shell），官方 `tools.restrict()` 遇到
+ * 名单里不存在的工具名会直接抛错、子代理根本起不来。所以：
+ *
+ *   - 当前预设配了名单（且名单非空）→ 用它；白名单额外并入**当时真实在跑的 MCP 工具**
+ *     （官方 allow 是"清单之外全砍"，不并进来会把 MCP 一起砍掉；用户裁定：子代理要能
+ *     用当前启动的 MCP）；
+ *   - 当前预设没配 → 回落旧的全局 `tools` / `toolsDeny`（老文件行为不变）；
+ *   - 名单里有已经消失的工具名 → **丢掉并在 note 里如实说明**（不接受静默失效）；
+ *   - 判断不了当前预设（老宿主 / 异常）→ 不按模式施加，并在 note 里说明。
+ *
+ * 三态返回：`filter: null` = 明确不加限制；`filter: {...}` = 下发该限制。
+ */
+export function decideToolFilter(persona, presetId, known) {
+    const rule = presetId === null ? undefined : persona.toolsByPreset?.[presetId];
+    if (rule && rule.names.length) {
+        const usable = rule.names.filter((name) => known.names.has(name));
+        const dropped = rule.names.filter((name) => !known.names.has(name));
+        const droppedNote = dropped.length ? `名单里这些工具当前不存在，已忽略：${dropped.join('、')}` : undefined;
+        if (!usable.length) {
+            return { filter: null, note: `「${presetId}」的${rule.mode === 'allow' ? '白' : '黑'}名单里没有当前存在的工具，本次不施加工具限制` };
+        }
+        if (rule.mode === 'allow')
+            return { filter: { allow: [...new Set([...usable, ...known.mcp])] }, ...(droppedNote === undefined ? {} : { note: droppedNote }) };
+        return { filter: { deny: usable }, ...(droppedNote === undefined ? {} : { note: droppedNote }) };
+    }
+    // 旧格式（全局名单）：保持老行为，白名单同样并入 MCP。
+    const legacyAllow = (persona.tools || []).filter((name) => known.names.has(name));
+    const legacyDeny = (persona.toolsDeny || []).filter((name) => known.names.has(name));
+    const legacyDropped = [...(persona.tools || []), ...(persona.toolsDeny || [])].filter((name) => !known.names.has(name));
+    const filter = {
+        ...(legacyAllow.length ? { allow: [...new Set([...legacyAllow, ...known.mcp])] } : {}),
+        ...(legacyDeny.length ? { deny: legacyDeny } : {}),
+    };
+    const notes = [];
+    const hasLegacy = Boolean((persona.tools || []).length || (persona.toolsDeny || []).length);
+    if (presetId === null) {
+        // 说清这一刻到底靠什么在跑：有旧格式就照旧格式，没有就明说"按模式配的限制这次不生效"。
+        notes.push(hasLegacy
+            ? '没能判断当前会话的 Agent 预设，按旧格式的全局名单执行'
+            : '没能判断当前会话的 Agent 预设，按模式配的限制这次不生效');
+    }
+    if (legacyDropped.length)
+        notes.push(`名单里这些工具当前不存在，已忽略：${legacyDropped.join('、')}`);
+    if (!Object.keys(filter).length) {
+        if (presetId === null && !notes.length)
+            notes.push('没能判断当前会话的 Agent 预设，本次不施加工具限制');
+        return { filter: null, ...(notes.length ? { note: notes.join('；') } : {}) };
+    }
+    return { filter, ...(notes.length ? { note: notes.join('；') } : {}) };
+}

package/lib/subagents/tools.js

@@ -54,9 +54,15 @@ export function defineSubagentRunTool(subagents) {
                 const available = allowed.map((p) => p.name).join('、') || '(无)';
                 throw new Error('人设不可用: ' + name + (reason ? '（' + reason + '）' : '（可用: ' + available + '）'));
             }
-            const r = await subagents.runSerial(exec.agent, persona, task, exec.signal);
+            // 按当前会话的 Agent 预设算工具限制：判断不了当前预设、或名单里的工具已经不存在时，
+            // 结论里会带一句实话，跟着结果一起返回——不静默改变限制的强度。
+            const decision = typeof subagents.toolFilterFor === 'function'
+                ? await subagents.toolFilterFor(persona, exec.agent && exec.agent.ctx)
+                : undefined;
+            const r = await subagents.runSerial(exec.agent, persona, task, exec.signal, decision === undefined ? undefined : decision.filter);
             const prefix = r.stopReason && r.stopReason !== 'completed' ? `[stopReason: ${r.stopReason}]\n` : '';
-            return prefix + r.text;
+            const note = decision && decision.note ? `⚠ ${decision.note}\n\n` : '';
+            return note + prefix + r.text;
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-tool-management",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "DSH plugin: one settings panel for MCP servers, Skills, AGENTS.md presets, archived sessions and scene memories — plus scene memory injected into the system prompt and one-shot persona subagents. 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",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
     "cordis.patch.yml",
     "README.md",
     "README_EN.md",
+    "CHANGELOG.md",
     "LICENSE",
     "screenshots.json",
     "docs"
@@ -40,7 +41,7 @@
     "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": "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"
   },
   "keywords": [
     "dsh",

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/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"
+]