dsh-plugin-tool-management 0.13.0 → 0.15.0

package/lib/scenes/candidates.js

@@ -14,7 +14,16 @@
 // 依赖全部经 deps 显式传入。注意 \`toolKeyParts\` 留在 index.ts：场景档案引擎也在用它，
 // 放进本文件会让两个域互相引用。
 import { presetRosterOf } from '../compat/preset-reach.js';
-import { injectionFactsOf, readCompositionFacts } from '../compat/preset-reach.js';
+import { injectionFactsOf, readCompositionFacts, readCompositionText } 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;
@@ -101,7 +110,9 @@ export function createCandidates(deps) {
     const presetFactsCache = new Map();
     async function presetFactsForAgent(agent) {
         const roster = presetRoster();
-        if (!roster || typeof roster.composedPreset !== 'function' || typeof roster.read !== 'function')
+        if (!roster || typeof roster.composedPreset !== 'function')
+            return undefined;
+        if (typeof roster.read !== 'function' && typeof roster.readDocument !== 'function')
             return undefined;
         let presetId = '';
         try {
@@ -116,7 +127,7 @@ export function createCandidates(deps) {
         if (hit && Date.now() - hit.at < PRESET_FACTS_TTL_MS)
             return hit.value;
         try {
-            const text = String((await roster.read(presetId)) ?? '');
+            const text = await readCompositionText(roster, presetId);
             const value = injectionFactsOf(readCompositionFacts(text));
             presetFactsCache.set(presetId, { at: Date.now(), value });
             return value;
@@ -207,7 +218,10 @@ export function createCandidates(deps) {
                     presets.push({
                         id,
                         name: String((p && (p.name || p.id)) || id),
-                        trust: String((p && p.trust) || 'user'),
+                        // 官方 registry 的预设**没有** trust 字段 —— 缺省必须是 ''（未知）而不是 'user'：
+                        // 客户端只对显式 user 隐藏内置模式的词典名，缺省 'user' 会让四个内置模式永远
+                        // 显示原始 id（2026-09-28 用户截图）。
+                        trust: String((p && p.trust) || ''),
                         broken: typeof (p && p.broken) === 'string',
                         tools: names,
                     });
@@ -278,7 +292,7 @@ export function createCandidates(deps) {
         try {
             const roster = await agentPresets.list();
             return (roster || [])
-                .map((p) => ({ id: String((p && p.id) || ''), name: String((p && (p.name || p.id)) || ''), trust: String((p && p.trust) || 'user') }))
+                .map((p) => ({ id: String((p && p.id) || ''), name: String((p && (p.name || p.id)) || ''), trust: String((p && p.trust) || '') }))
                 .filter((p) => p.id !== '');
         }
         catch {
@@ -329,6 +343,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 +398,7 @@ export function createCandidates(deps) {
         presetToolNames,
         presetNames,
         modelCandidates,
+        modelReasoning,
         memoryCandidates,
         memorySceneCandidates,
     };

package/lib/sessions/bridge.js

@@ -62,6 +62,8 @@ function acquireCacheGuard(cache) {
             kind: "delete",
             fallback: "inform-only",
             detail: `投影缓存适配未完成（requireTable 抛错）：${String(error?.message ?? error)}；宿主对象未被改动。`,
+            detailKey: "projection-cache-adapter.setup",
+            params: { reason: String(error?.message ?? error) },
         });
         throw new CapabilityRefusalError("delete", [{
                 id: "projection.table-delete",
@@ -218,6 +220,9 @@ function acquireCacheGuard(cache) {
             detail: reason === "taken-over"
                 ? "宿主缓存的 put/write 已被第三方包装接管：本插件的删除屏障这一轮已退役（缓存行删除少了墓碑拦截），下一次删除会重新安装。"
                 : "投影缓存适配在首次使用时抛错（宿主形状可能变了）：已恢复宿主原方法，下一次删除会重新安装并再探一次。",
+            detailKey: reason === "taken-over"
+                ? "projection-cache-adapter.taken-over"
+                : "projection-cache-adapter.first-use",
         });
     }
     cacheGuards.set(cache, self);

package/lib/sessions/workspace.js

@@ -20,6 +20,8 @@ function reportNativeDeleteAvailable(entry) {
         kind: "delete",
         fallback: "inform-only",
         detail: `宿主已提供原生 ${entry}：本插件仍走自有完整序列（级联子会话 + spill + 记账 + 缓存行），尚未切换到原生入口。`,
+        detailKey: "workspace.delete-native",
+        params: { entry },
     });
 }
 //#region lib/types/index.js
@@ -697,8 +699,8 @@ var ArchiveWorkspaceRegistry = class {
     }
     /**
      * 列出已归档会话的展示元数据：sessionId / createdAt / cwd / title / archivedAt。
-     * title 经投影缓存 best-effort 读取（未播种会话用 inheritedEventCount=0）；
-     * 任何一步失败只降级为缺字段，不阻断列表。
+     * title 经投影缓存 best-effort 读取（cachedSnapshot 的标题行，旧格式记录退
+     * cachedPredecessorTitle）；任何一步失败只降级为缺字段，不阻断列表。
      */
     async archivedSessionDetails() {
         await this.reconcileArchiveLedger();
@@ -717,10 +719,19 @@ var ArchiveWorkspaceRegistry = class {
                     entry.cwd = header.cwd;
                 const cache = this.ctx.get("sessionProjectionCache");
                 if (cache !== undefined && typeof cache.cachedSnapshot === "function") {
-                    const snap = cache.cachedSnapshot(header, 0, ["title"]);
+                    // 官方契约是 cachedSnapshot(meta, keys?) 两参；keys 传数字会在
+                    // viewCheckpoint 的 new Set 里抛错，被外层 best-effort 吞成"永远没标题"。
+                    const snap = cache.cachedSnapshot(header, ["title"]);
                     const title = snap?.values?.title;
                     if (typeof title === "string")
                         entry.title = title;
+                    else if (typeof cache.cachedPredecessorTitle === "function") {
+                        // 旧格式代际的缓存记录过不了上面的身份校验，官方另有只认标题的提示面。
+                        const legacy = cache.cachedPredecessorTitle(header);
+                        const legacyTitle = legacy?.values?.title;
+                        if (typeof legacyTitle === "string")
+                            entry.title = legacyTitle;
+                    }
                 }
             }
             catch (error) {
@@ -775,7 +786,8 @@ var ArchiveWorkspaceRegistry = class {
             return false;
         try {
             // 未播种会话的继承事件数恒为零，先查缓存可避免读取完整会话原文。
-            if (!header.isSeeded && cache.cachedSnapshot(header, 0) !== void 0)
+            // keys 缺省 = 任一 wire 行可用即算已有缓存（官方两参契约，勿再传数字）。
+            if (!header.isSeeded && cache.cachedSnapshot(header) !== void 0)
                 return false;
             const stored = await this.readStoredProjectionSource(persistence, header.id);
             const meta = stored.meta ?? header;
@@ -788,7 +800,7 @@ var ArchiveWorkspaceRegistry = class {
                 this.ctx.logger.warn(`archive-manager: projection repair for unseeded archived session "${header.id}" skipped because its inherited event count is not zero`);
                 return false;
             }
-            if (cache.cachedSnapshot(meta, inheritedEventCount) !== void 0)
+            if (cache.cachedSnapshot(meta) !== void 0)
                 return false;
             const restored = projections.restore({}, stored.events, 0, meta, inheritedEventCount);
             if (restored === void 0 ||

package/lib/skills/core.js

@@ -305,8 +305,13 @@ async function nearestProjectRoot(cwd) {
         if (!(await fs.stat(start)).isDirectory())
             return null;
     }
-    catch {
-        return { unavailable: true, cwd };
+    catch (error) {
+        // 目录不存在（会话还开着、项目已被删）是最常见的一类：带上系统错误码，
+        // 调用方对 ENOENT 静默跳过 —— 报警留给真正读不了的目录。
+        const code = error && typeof error === "object" && "code" in error
+            ? String(error.code)
+            : undefined;
+        return { unavailable: true, cwd, ...(code ? { code } : {}) };
     }
     let current = start;
     for (;;) {
@@ -344,6 +349,10 @@ export async function projectRoots(projectCwds = [], diagnostics) {
     for (const cwd of Array.isArray(projectCwds) ? projectCwds : []) {
         const found = await nearestProjectRoot(cwd);
         if (!found || !found.root) {
+            // 目录不存在（ENOENT）= 会话开着、项目已删：这是常态而不是故障，静默跳过。
+            // 报警只留给真实读不了的目录（权限、损坏的链接等）。
+            if (found && found.unavailable && found.code === "ENOENT")
+                continue;
             if (found &&
                 found.unavailable &&
                 Array.isArray(diagnostics) &&
@@ -352,7 +361,7 @@ export async function projectRoots(projectCwds = [], diagnostics) {
                 diagnostics.push({
                     code: "warning.project.unavailable",
                     params: { path: cwd },
-                    error: `无法从宿主读取活动工作区，项目技能未显示: ${cwd}`,
+                    error: `活动会话的项目目录不可访问，项目技能未显示: ${cwd}`,
                 });
             }
             continue;
@@ -2696,6 +2705,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

@@ -1,8 +1,23 @@
 // model 工具（ctx.tools.register + defineTool）各域共用的依赖与 helper。
 //
-// 为什么单独一个文件：五个域的工具都要同一批依赖（defineTool 包装、注册出口、场景锁定
+// 为什么单独一个文件：各注入域的工具都要同一批依赖（defineTool 包装、注册出口、场景锁定
 // 守卫、注入边界提示），各写一份会漂移。
 /** 每个工具 output.render 的统一出口：把字符串包成宿主要的 content 数组。 */
 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;
+}