dsh-plugin-tool-management 0.13.0 → 0.14.0

package/lib/ops/candidates.js

@@ -16,6 +16,17 @@ export function buildCandidateOps(deps) {
         }),
         // model-candidates：宿主 LLM 目录里的 (provider, model) 对（不发网络请求）。
         'model-candidates': async () => ({ ok: true, ...(await deps.modelCandidates()) }),
+        // model-reasoning：某个 (provider, model) 支持的思考强度档位（人设表单的「思考强度」下拉）。
+        // 为什么单独一个 op：档位清单要问 adapter（`llm.resolveModelInfo`，异步、可能联网），而
+        // model-candidates 是"不发网络请求"的本地目录 —— 捆在一次调用里会让"打开人设表单"这件事
+        // 忽然变成可能联网的操作。这里只做参数归一与转发，判定留给调用方（界面按 ok 分两态显示）。
+        'model-reasoning': async (args) => {
+            const provider = String((args && args.provider) || '').trim();
+            const model = String((args && args.model) || '').trim();
+            if (!provider || !model)
+                return { ok: false, error: 'provider 与 model 都要给（档位跟模型走）' };
+            return deps.modelReasoning(provider, model);
+        },
         // 场景档案勾选器数据源 v2：全部 MCP 服务器（含未运行）+ 技能全集 + 人设清单。
         'scene-inventory': async () => {
             const [rowsR, tools, skills, subs] = await Promise.all([deps.mcpmListView(), deps.toolStates(), deps.skillRows(), deps.subagentList()]);

package/lib/ops/compat.js

@@ -170,13 +170,21 @@ export function buildCompatOps(deps) {
                 push('mcp-tools', 'MCP 工具停用', 'mcp', disabledTools === 0 ? 'ok' : 'partial', disabledTools === 0 ? '没有停用的工具' : `${disabledTools} 个工具处于停用态（执行拦截 + 可见性摘除）`);
                 // 工具表按每个请求付钱：这一行回答"这一轮实际发出去多少"。关掉的工具整份不进请求，
                 // 但代价是模型调不到它们（本插件的面板不受影响）——所以是 partial，不是 ok。
+                // **出厂默认关掉的那几条不算**：那是插件替用户做的一个可逆选择，不是用户关出了
+                // 一个缺口。把默认态报成 partial 违背本页口径（琥珀只留给"该做却没做"），也永远
+                // 无法消掉 —— 用户打开它们反而会被罚一个 ok。
                 // 末尾那句是**逐会话**的差额：官方 `skill` 工具在场的会话里我们那份加载器会再让位
                 // 一个（见 index.ts 的 CARRIER_DUPLICATES），本表的数字是全局口径、不含它。
                 const table = deps.toolTableReport();
                 const carrierNote = '；官方 `skill` 工具在场的会话，`skill_manager_read` 还会自动让位一份';
-                push('tool-table', '模型工具表', 'compat', table.hiddenCount === 0 ? 'ok' : 'partial', (table.hiddenCount === 0
+                const userOff = table.hiddenCount - table.defaultHiddenCount;
+                const offPart = table.hiddenCount === 0
                     ? `${table.totalCount} 个工具全部下发（≈${table.totalTok} tok/轮）`
-                    : `关掉 ${table.hiddenCount}/${table.totalCount} 个：一轮少发 ≈${table.hiddenTok} tok（现在 ≈${table.visibleTok} tok/轮，面板不受影响）`) + carrierNote);
+                    : (userOff === 0
+                        ? `出厂默认关掉 ${table.defaultHiddenCount}/${table.totalCount} 个`
+                        : `关掉 ${table.hiddenCount}/${table.totalCount} 个（含出厂默认 ${table.defaultHiddenCount} 个）`)
+                        + `：一轮少发 ≈${table.hiddenTok} tok（现在 ≈${table.visibleTok} tok/轮，到「兼容」页的「模型工具表」可逐条打开；面板不受影响）`;
+                push('tool-table', '模型工具表', 'compat', userOff === 0 ? 'ok' : 'partial', offPart + carrierNote);
                 push('native-delete', '宿主原生删除入口', 'compat', notes.has('workspace.delete-native') ? 'partial' : 'ok', notes.get('workspace.delete-native')?.detail ?? '宿主未提供原生删除入口（本插件自有完整序列）');
                 // 身份 / 版本：与 compat-status 同一份数据。
                 const identity = assessment?.identity;

package/lib/ops/sessions.js

@@ -388,7 +388,7 @@ export function buildSessionOps(deps) {
                             continue;
                         }
                         entries.push({ zip: `${id}/AGENTS.md`, abs: docAbs });
-                        // 描述侧车（「只给使用者看」的那句）随预设一起走：导出再导入不该把它丢掉。
+                        // 描述侧车（预设那句说明）随预设一起走：导出再导入不该把它丢掉。
                         const metaAbs = join(deps.promptsDir, id, 'meta.json');
                         try {
                             if ((await stat(metaAbs)).isFile())

package/lib/prompts/service.js

@@ -18,8 +18,29 @@ import { createHash } from 'node:crypto';
 import { isValidPresetId, LAST_APPLIED_PRESET_ID, normalizePresetId } from './preset-id.js';
 import { listTrashEntries, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
 const FILENAME = 'AGENTS.md';
-/** 描述侧车：与 AGENTS.md 同目录，避免把「只给使用者看」的文字注入提示词。 */
+/** 描述侧车：与 AGENTS.md 同目录，避免描述的文字被当成提示词正文注入。 */
 const META_FILE = 'meta.json';
+/**
+ * 预设描述的字数上限。界面上那两枚输入框（提示词页的新建 / 编辑弹窗）用同一个数当
+ * `maxLength` 与字数计数的分母，客户端镜像在 `42-shared-ui.js` 的 `PRESET_DESC_MAX`
+ * —— 改这里要一起改它。
+ *
+ * 为什么需要它（0.14.0）：描述此前是"只给使用者看"的，一个字都不进模型上下文，所以没有
+ * 上限也说得过去。现在 `prompt_manager_list` 会把它打给模型（否则模型无法在预设之间做
+ * 选择），它就成了**常驻成本**，必须有个预算。300 与 MCP 备注同数（那一条也是"给模型看的
+ * 一句用户提示"），但那是两个各自独立的预算，别当成同一个常量共用。
+ */
+export const DEFAULT_PRESET_DESC_MAX_LENGTH = 300;
+/**
+ * 压成一行并按上限截断。与 `normalizeMcpNote`（`../mcp/state-section.ts`）同形：两处都是
+ * "给模型看的一句用户文字"，口径必须一致，否则同一句在界面、段、工具里会是三个样子。
+ */
+export function normalizePresetDescription(value, maxLength = DEFAULT_PRESET_DESC_MAX_LENGTH) {
+    const flat = String(value ?? '').replaceAll(/\s+/g, ' ').trim();
+    if (!flat)
+        return '';
+    return flat.length <= maxLength ? flat : `${flat.slice(0, maxLength - 3)}...`;
+}
 const LAST_APPLIED_ID = LAST_APPLIED_PRESET_ID;
 /**
  * 「最近一次应用」的记录侧车。是**文件**不是目录，所以 `list()` / `ensureInit()` 的
@@ -46,9 +67,11 @@ export function createPromptsService(_ctx, deps) {
             return null;
         }
     }
-    // ── 描述（「只给使用者看」）────────────────────────────────────────────────
+    // ── 描述（给人看，也进模型清单）────────────────────────────────────────────
     // 存在预设目录的 `meta.json` 里，**不写进 AGENTS.md**：那个文件的正文会被原样注入
     // 系统提示词，把「这份预设是干什么的」写进去等于凭空给模型加了一段说明。
+    // 0.14.0 起另有一条通道会把它带给模型 —— `prompt_manager_list` 的清单行（模型要在预设
+    // 之间做选择，而 id 本身不说明用途），所以它有了 `DEFAULT_PRESET_DESC_MAX_LENGTH` 这条预算。
     // 读写都 best-effort：描述坏掉/写不进去不该让「保存预设」失败（正文才是本体）。
     async function readDescription(id) {
         try {

package/lib/scenes/candidates.js

@@ -15,6 +15,15 @@
 // 放进本文件会让两个域互相引用。
 import { presetRosterOf } from '../compat/preset-reach.js';
 import { injectionFactsOf, readCompositionFacts } from '../compat/preset-reach.js';
+/**
+ * 问 adapter 的等待上限。官方签名 `resolveModelInfo(provider, model, signal?)` 的 signal 是
+ * "optional cancellation for adapter-owned asynchronous lookup"，所以给一个上限 —— 界面那一格
+ * 是懒加载 + loading 态，挂住不返回会让它一直转。
+ *
+ * ⚠️ 10s 是**防御性**取值，没有实测依据：本机拿不到活着的 adapter，量不出真实耗时。
+ * 真机上若发现常见 provider 只要几十毫秒，可以调小；若某个 provider 稳定超过它，就该调大。
+ */
+const MODEL_REASONING_TIMEOUT_MS = 10_000;
 export function createCandidates(deps) {
     // 外部能力一次解构成局部名：块内代码逐字搬来，保持原样最不容易出错。
     const { get, tools, mcp, skillsService, memoriesService, toolKeyParts } = deps;
@@ -329,6 +338,52 @@ export function createCandidates(deps) {
         }
         return { models };
     }
+    /**
+     * 某个 (provider, model) 的思考强度档位。见 `Candidates.modelReasoning` 的注释。
+     *
+     * `llm` 与 `modelCandidates` 同一路径取（**不在 inject 声明里**，所以必须 `ctx.get('llm')`
+     * 而不是 `ctx.llm` —— 后者在未声明该服务时 cordis 代理会抛
+     * "cannot get property without inject"）。
+     */
+    async function modelReasoning(provider, model) {
+        const llm = (typeof ctx.get === 'function' ? ctx.get('llm') : undefined);
+        if (!llm || typeof llm.resolveModelInfo !== 'function') {
+            return { ok: false, error: '宿主没有提供 llm.resolveModelInfo（拿不到档位清单）' };
+        }
+        const ac = typeof AbortController === 'function' ? new AbortController() : null;
+        const timer = ac ? setTimeout(() => ac.abort(), MODEL_REASONING_TIMEOUT_MS) : null;
+        try {
+            const info = await llm.resolveModelInfo(provider, model, ac ? ac.signal : undefined);
+            const reasoning = info && info.reasoning;
+            const raw = reasoning && Array.isArray(reasoning.efforts) ? reasoning.efforts : [];
+            const efforts = [];
+            for (const e of raw) {
+                const id = String((e && e.id) || '');
+                if (!id)
+                    continue;
+                // 官方结构：`{ id, name, description? }`（`dsh-llm/lib/types/types.d.ts:295-302`）。
+                // name 是给人看的档位名，id 才是要传回去的值 —— 两者都要留着，界面按 name 显示、按 id 提交。
+                efforts.push({
+                    id,
+                    name: String((e && e.name) || id),
+                    ...(e && typeof e.description === 'string' && e.description ? { description: e.description } : {}),
+                });
+            }
+            return {
+                ok: true,
+                efforts,
+                // 缺省（null）= 由 provider 自己的默认决定（官方注释：Absence preserves the provider's own default）。
+                defaultEffort: reasoning && reasoning.defaultEffort ? String(reasoning.defaultEffort) : null,
+            };
+        }
+        catch (e) {
+            return { ok: false, error: (e && e.message) ? String(e.message) : String(e) };
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     return {
         presetRoster,
         presetFactsForAgent,
@@ -338,6 +393,7 @@ export function createCandidates(deps) {
         presetToolNames,
         presetNames,
         modelCandidates,
+        modelReasoning,
         memoryCandidates,
         memorySceneCandidates,
     };

package/lib/skills/core.js

@@ -2696,6 +2696,99 @@ export async function createSkill(input, log, options = {}) {
         log("create", `创建 ${join(target, "SKILL.md")}`);
     return { name, path: join(target, "SKILL.md"), root: definition.key };
 }
+/**
+ * 改写一份**已存在**的技能（bundle 的 `SKILL.md` 或 flat 的 `<name>.md`）。
+ *
+ * 为什么是独立函数、而不是给 `createSkill` 加一个 `allowOverwriteInOwnRoot` 开关：
+ * 「静默覆盖」这件事不该出现在同一个入口的签名里 —— 调用方读到的函数名必须已经说明了
+ * 它是破坏性的，否则一次参数写错就从"新建"变成"覆盖别人的技能"。
+ *
+ * 写入复用同一套原子写（stage 文件 + `renameWithRetry`）。bundle 形态**只换 SKILL.md**，
+ * 目录里其余文件（附件、脚本、参考文档）原样留着 —— 整目录替换会把它们全删掉。
+ *
+ * 边界：只在 `options.root`（默认 hub = `$DSH_HOME/tool-management/skills`）**里面已经
+ * 存在**的那一份上写。文件不在那里就是"不存在"，**绝不新建**（新建是 `createSkill` 的事，
+ * 它的冲突检查会拒掉同名）。
+ *
+ * 「胜出者必须是 hub 这一份」这层判定不在这里：它要读来源排序与首选设置，属于状态层
+ * （见 service.ts 的 `skill-update` op）。本函数只保证"不越出给定根"。
+ */
+export async function updateSkill(input, log, options = {}) {
+    const requestedRoot = Object.prototype.hasOwnProperty.call(options, "root")
+        ? options.root
+        : rootByKey("hub") || rootByKey("dsh");
+    const definition = await checkedWritableRootDefinition(requestedRoot);
+    if (definition && definition.ok === false)
+        return definition;
+    if (!definition) {
+        if (!rootDefinition(requestedRoot)) {
+            return {
+                ok: false,
+                code: "error.root.unknown",
+                params: { root: String(requestedRoot == null ? "" : requestedRoot) },
+                error: `技能来源不存在：${requestedRoot == null || requestedRoot === "" ? "(空)" : requestedRoot}`,
+            };
+        }
+        return readonlyError("update");
+    }
+    const root = definition.path;
+    const requestedName = String((input && input.name) || "").trim();
+    const name = toKebab(requestedName);
+    if (!name || !KEBAB_RE.test(name) || entryPath(root, name) === null)
+        return {
+            ok: false,
+            error: `无法生成合法 kebab-case 名称（原始名: ${requestedName}）`,
+            code: "error.import.invalidName",
+            params: { name: requestedName },
+        };
+    // 形态判定与 `resolveEntry` 同口径：bundle 目录优先，其次 flat 单文件。
+    const bundleDir = entryPath(root, name);
+    const bundleDoc = join(bundleDir, "SKILL.md");
+    const flatDoc = resolve(root, `${name}.md`);
+    const exists = async (p) => await fs.stat(p).then(() => true).catch(() => false);
+    const existingDoc = (await exists(bundleDoc)) ? bundleDoc : (await exists(flatDoc)) ? flatDoc : null;
+    if (!existingDoc)
+        return {
+            ok: false,
+            code: "error.update.notFound",
+            error: `技能不存在（本插件落点里没有 ${name}）：本工具只改本插件自己写的技能，不新建、也不动官方根里的`,
+            params: { name },
+        };
+    const current = parseSkillDoc(await fs.readFile(existingDoc, "utf8"));
+    const curDescription = unquote(String(current.map.description ?? "")).trim();
+    const curBody = String(current.body ?? "").trim();
+    // 省略 = 保持。注意区分"未给"与"给了空串"：空串是显式意图，会被下面的必填校验挡下并
+    // 说明缺哪个 —— 静默保留会让模型以为清掉了。
+    const description = input && input.description !== undefined
+        ? String(input.description).trim()
+        : curDescription;
+    const body = input && input.body !== undefined ? String(input.body).trim() : curBody;
+    if (!description)
+        return { ok: false, error: "技能简介不能为空", code: "error.create.descriptionRequired" };
+    if (!body)
+        return { ok: false, error: "技能正文不能为空", code: "error.create.bodyRequired" };
+    if (description.length > 500 || body.length > 1 << 18)
+        return { ok: false, error: "技能内容过长", code: "error.create.tooLarge" };
+    const content = `---\nname: ${name}\ndescription: ${yamlString(description)}\n---\n\n${body}\n`;
+    if (existingDoc === flatDoc) {
+        await writeFileAtomically(flatDoc, content);
+        if (log)
+            log("update", `更新 ${flatDoc}`);
+        return { name, path: flatDoc, root: definition.key };
+    }
+    const stage = temporaryPath(existingDoc, "update");
+    try {
+        await fs.writeFile(stage, content, "utf8");
+        await renameWithRetry(stage, existingDoc);
+    }
+    catch (error) {
+        await fs.rm(stage, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    if (log)
+        log("update", `更新 ${existingDoc}`);
+    return { name, path: existingDoc, root: definition.key };
+}
 export async function skillDetail(keyOrRoot, name, options = {}) {
     const scopedRoots = await projectRoots(options.projectCwds);
     // 支持传 key 或 definition（自定义来源由 service 层解析后传入）。

package/lib/skills/service.js

@@ -10,7 +10,7 @@ import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { isInsideRootResolved } from '../paths.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';
+import { state, setSkillEnabled, setPreferredSkill, markSkillsDisabled, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, permanentlyDeleteTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, updateSkill, skillDetail, listProviderCandidates, getProviderSkill, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, logPath, trashRootPath, } from './core.js';
 const MAX_LOG_BYTES = 1 << 20;
 const PROVIDER_NAME = 'dsh-plugin-tool-management-external';
 const message = (e) => String((e && e.message) || e);
@@ -455,7 +455,7 @@ export function createSkillsService(ctx) {
         // 也变），是写操作；漏在这份清单里 = 配了访问令牌也不会被要求带令牌。
         'skill-source-remove', 'skill-source-restore',
         'skill-prefer', 'skill-unprefer',
-        'skill-create', 'skill-import', 'skill-upload', 'skill-delete',
+        'skill-create', 'skill-update', 'skill-import', 'skill-upload', 'skill-delete',
         // 批量启停与单条启停同权：配了访问令牌的宿主必须同样要求带令牌。
         'skill-set-all',
         'skill-trash-restore', 'skill-trash-delete', 'skill-custom-add', 'skill-custom-remove',
@@ -549,6 +549,38 @@ export function createSkillsService(ctx) {
             }
             return res;
         }), afterWrite),
+        // 改写**本插件自己写的那一份**技能。只认 hub 里的胜出者：同名技能在 dsh / agents /
+        // claude / 自定义根各有一份时只有一份生效，改错那一份会返回 OK 而技能毫无变化
+        // （用户实测踩过：同一技能四份并存，启错根等于没启）。胜出者判定要读来源排序与首选
+        // 设置，属于状态层，所以在这里做；core 的 `updateSkill` 只保证不越出给定根。
+        'skill-update': wrap((args) => write(async () => {
+            const wanted = String(args.name || '').trim();
+            const s = await readState();
+            const hits = [];
+            for (const root of (s && s.roots) || []) {
+                for (const skill of root.skills || []) {
+                    if (String(skill.declaredName || skill.name || '') !== wanted)
+                        continue;
+                    hits.push({
+                        rootKey: String(root.key || ''),
+                        shadowedBy: skill.shadowedBy && skill.shadowedBy.root ? String(skill.shadowedBy.root) : '',
+                    });
+                }
+            }
+            if (!hits.length) {
+                return { ok: false, code: 'error.update.notFound', params: { name: wanted }, error: `技能不存在：${wanted}` };
+            }
+            const winner = hits.find((h) => !h.shadowedBy) || hits[0];
+            if (winner.rootKey !== 'hub') {
+                return {
+                    ok: false,
+                    code: 'error.update.notOwnRoot',
+                    params: { name: wanted, root: winner.rootKey },
+                    error: `技能 ${wanted} 的生效副本在来源「${winner.rootKey}」，不在本插件落点（hub = $DSH_HOME/tool-management/skills）：本插件不修改官方根里的技能`,
+                };
+            }
+            return updateSkill({ name: args.name, description: args.description, body: args.body }, log, { root: (await requestRoot('hub')) || 'hub' });
+        }), afterWrite),
         'skill-import': wrap((args) => write(async () => {
             const res = await importSkill(String(args.source || ''), log, {
                 conflict: args.conflict === 'overwrite' ? 'overwrite' : 'skip',

package/lib/subagents/service.js

@@ -99,6 +99,17 @@ export function parsePresetToolRules(frontmatter) {
     return Object.keys(rules).length ? rules : undefined;
 }
 /** 行式 frontmatter 解析：只认 description / provider / model / tools / toolsDeny / toolsByPreset / catalogDepth / output。 */
+/**
+ * 思考强度档位 id 的归一：单行、去空白、限长。**不校验它是不是合法档位** —— 清单要问 adapter
+ * 才拿得到（可能拿不到），而官方本来就会在 provider I/O 之前拒掉不支持的显式值。
+ *
+ * 为什么必须去换行：frontmatter 是**逐行**解析的（`parsePersona`），值里带换行会把后面半截
+ * 变成一行无主文本。限长是防脏值（正常档位 id 都很短）。
+ */
+export const REASONING_EFFORT_MAX_LENGTH = 64;
+export function normalizeReasoningEffort(value) {
+    return String(value ?? '').replace(/[\r\n]+/g, ' ').trim().slice(0, REASONING_EFFORT_MAX_LENGTH);
+}
 export function parsePersona(raw, fallbackName) {
     const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(raw);
     const data = {};
@@ -133,6 +144,8 @@ export function parsePersona(raw, fallbackName) {
         description: data.description || firstLine,
         provider: data.provider || undefined,
         model: data.model || undefined,
+        // frontmatter 键统一小写后是 `reasoningeffort`（写出去的是 camelCase）。
+        reasoningEffort: normalizeReasoningEffort(data.reasoningeffort) || undefined,
         tools,
         toolsDeny,
         ...(toolsByPreset === undefined ? {} : { toolsByPreset }),
@@ -618,8 +631,22 @@ export function createSubagentService(ctx, opts) {
             // provider 与 model 是模型路由的两半：DSH 的 resolveModel(provider, model) 不做
             // `provider/model` 字符串拆分，只改 model 会落在**主会话的 provider** 上——跨来源
             // 指定模型（如 sensenova 的 sensenova-6.8-flash-lite）必须两个键一起给。
-            ...(p.provider || p.model
-                ? { agentOptions: { ...(p.provider ? { provider: p.provider } : {}), ...(p.model ? { model: p.model } : {}) } }
+            // 2026-09-23 加 `reasoningEffort`：条件是"三个键任一有值"—— 只设强度（不改模型）也得
+            // 把这个对象发出去，否则那一格永远不生效。官方合并语义（`dsh-subagent/lib/index.js:471-483`）
+            // 是"先继承主会话的三项、再用这里的覆盖"，所以只给 reasoningEffort 时 provider/model
+            // 照旧继承；反过来，改了 provider/model 而没给 reasoningEffort 时，**继承来的那一档会被
+            // 删掉**（回落到该模型自己的默认）—— 那不是 bug，是官方的显式语义。
+            ...(p.provider || p.model || p.reasoningEffort
+                ? {
+                    agentOptions: {
+                        ...(p.provider ? { provider: p.provider } : {}),
+                        ...(p.model ? { model: p.model } : {}),
+                        // 类型是官方的品牌串 `ReasoningEffortId`；我们的值本来就是 adapter 自己给的
+                        // opaque id（界面从 `resolveModelInfo` 的清单里选出来的），所以这里只做归一、
+                        // 不重新校验 —— 不支持的档位由官方在 provider I/O 之前拒。
+                        ...(p.reasoningEffort ? { reasoningEffort: p.reasoningEffort } : {}),
+                    },
+                }
                 : {}),
         });
         try {
@@ -660,7 +687,8 @@ export function createSubagentService(ctx, opts) {
             return {
                 ok: true,
                 // catalogDepth 报**生效值**（没写就是默认 1），界面与模型都不必各自知道默认是多少。
-                subagents: docs.map((p) => ({ name: p.name, enabled: p.enabled !== false, description: p.description, provider: p.provider ?? null, model: p.model ?? null, tools: p.tools ?? null, toolsDeny: p.toolsDeny ?? null, toolsByPreset: p.toolsByPreset ?? null, catalogDepth: catalogDepthOf(p), output: p.output ?? null })),
+                // 手写 map：新增字段必须**两处都加**（list 与 get），少一处就是界面读不到。
+                subagents: docs.map((p) => ({ name: p.name, enabled: p.enabled !== false, description: p.description, provider: p.provider ?? null, model: p.model ?? null, reasoningEffort: p.reasoningEffort ?? null, tools: p.tools ?? null, toolsDeny: p.toolsDeny ?? null, toolsByPreset: p.toolsByPreset ?? null, catalogDepth: catalogDepthOf(p), output: p.output ?? null })),
             };
         },
         'subagent-get': async (args) => {
@@ -669,7 +697,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 ?? [], toolsByPreset: p.toolsByPreset ?? {}, catalogDepth: catalogDepthOf(p), output: p.output ?? '', body: p.body } };
+            return { ok: true, persona: { name: p.name, description: p.description, provider: p.provider ?? '', model: p.model ?? '', reasoningEffort: p.reasoningEffort ?? '', tools: p.tools ?? [], toolsDeny: p.toolsDeny ?? [], toolsByPreset: p.toolsByPreset ?? {}, catalogDepth: catalogDepthOf(p), output: p.output ?? '', body: p.body } };
         },
         'subagent-create': async (args) => {
             const name = String((args && args.name) || '').trim();
@@ -982,6 +1010,9 @@ 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();
+    // 思考强度：空值**不落盘**（与 `catalogDepth` 默认值同规矩）—— 免得每个新建的人设都多一行
+    // 说明"它和默认一样"，也保证老的人设文件回写后逐字节不变。
+    const reasoningEffort = normalizeReasoningEffort(args?.reasoningEffort);
     const tools = toStringList(args?.tools);
     // 黑名单字段兼容两种入参名：toolsDeny（UI/camel）与 tools_deny（snake）。
     const toolsDeny = toStringList(args?.toolsDeny ?? args?.tools_deny);
@@ -1006,6 +1037,8 @@ export function serializePersona(args) {
         lines.push('provider: ' + provider);
     if (model)
         lines.push('model: ' + model);
+    if (reasoningEffort)
+        lines.push('reasoningEffort: ' + reasoningEffort);
     if (hasCatalogDepth)
         lines.push('catalogDepth: ' + String(catalogDepth));
     for (const line of outputLines)

package/lib/subagents/tools.js

@@ -22,7 +22,7 @@ export async function filterBySceneBinding(docs, enabledSceneLists) {
 export function defineSubagentManagerListTool(subagents) {
     return {
         name: 'subagent_manager_list',
-        description: 'List personas (pre-configured subagent profiles) with their descriptions. The「可委派的子智能体」reminder carries the same catalog; call this for the always-current full list before subagent_manager_run.',
+        description: 'List personas (pre-configured subagent profiles) with their descriptions. The「可委派的子智能体」reminder carries the same catalog; call this for the always-current full list.',
         parameters: {},
         output: {
             schema: { type: 'string' },
@@ -66,11 +66,18 @@ export function defineSubagentManagerRunTool(subagents) {
         // 代价如实记下：子智能体域被关掉、或走压制型预设时上下文里没有那条 how 行，模型只剩本
         // 描述与 `agent` 参数说明（"Persona name from subagent_manager_list"）—— 够它认出这条是
         // 带人设的委派通道，但"没有人设贴合时才用官方那两个"这层分界就没人说了。
+        //
+        // 2026-09-23（用户裁定）：本工具的 `task` / `inherit` 两个参数说明与上面的 Modes 段
+        // **逐字重复**，而工具表每轮都发 —— 同一件事付两次 token。实测 `subagent_manager_run`
+        // 整份 407 tok（参数段：`inherit` 86 / `task` 57 / `agent` 19），其中 `inherit` 是全表
+        // 最贵的单个参数。收完两处重复后目标 ≈325 tok。判据是"删掉的那句在描述里已经有了吗"：
+        // Modes 段留着（它是模型的入口），参数说明只留"这一段独有的信息"。
+        // `inherit` 那句"轮中委派拿不到当前轮"必须留 —— 它是这条参数唯一会让人写错 task 的地方。
         description: 'Run a named persona as a subagent: it gets the persona as its own system prompt, works on `task`, and returns only its final output.\n\nModes: by default a fresh child that cannot see this conversation, so `task` must be self-contained. With `inherit: true` it also gets this conversation\'s **finished** turns (like the host\'s `subagent_fork`) — the current turn is never included, so a mid-turn hand-off still needs a self-contained `task`.\n\n`task` = the goal plus the context it needs; leave method and output format to the persona.\n\nUse it when the work matches a persona in the「可委派的子智能体」reminder (a review, an investigation, a piece of writing) and the detail should not sit in your own context. Not for reading a file (Read), finding a definition (Grep/Glob), or touching two or three files.',
         parameters: {
-            agent: { type: 'string', required: true, description: 'Persona name from subagent_manager_list.' },
-            task: { type: 'string', required: true, description: 'The task for the subagent: the goal plus the context it needs. Self-contained by default; with inherit: true it only needs to state what is new. Leave method and output format to the persona.' },
-            inherit: { type: 'boolean', description: 'Let the subagent inherit this conversation\'s finished turns, like the host\'s subagent_fork (default false = a fresh child that cannot see this conversation). Only finished turns are inherited — a delegation made mid-turn cannot pass the current turn\'s content, so write `task` as if it were self-contained.' },
+            agent: { type: 'string', required: true, description: 'Persona name.' },
+            task: { type: 'string', required: true, description: 'The task for the subagent. Self-contained by default; with inherit: true only state what is new.' },
+            inherit: { type: 'boolean', description: 'Let the subagent see this conversation\'s finished turns (the current turn is never included). Default false = a fresh child.' },
         },
         output: {
             schema: { type: 'string' },

package/lib/tools/deps.js

@@ -6,3 +6,18 @@
 export function text(value) {
     return [{ type: 'text', text: value }];
 }
+/**
+ * 名单渲染：超过 `TOOL_NAME_LIST_CAP` 项就截断，并把总数写在后面（"等 N 项"）。
+ *
+ * 为什么两个地方都要它：`scene_manager_list` 用它列档案，`scene_manager_save` 用它
+ * 在回执里回显"这一次替换挤掉了什么"。两处都必须**点名、不能只给数量** —— 只给数量
+ * 答不了"我这次给出去的段会不会盖掉原来勾着的那些"，而那正是会静默出错的地方。
+ * 截断则是因为这些文字都要进上下文，不能无上限。
+ */
+export const TOOL_NAME_LIST_CAP = 6;
+export function toolNameList(list) {
+    if (!list.length)
+        return '空';
+    const head = list.slice(0, TOOL_NAME_LIST_CAP).join('、');
+    return list.length > TOOL_NAME_LIST_CAP ? head + ' 等 ' + list.length + ' 项' : head;
+}