dsh-plugin-tool-management 0.18.5 → 0.19.0

package/lib/client.js

@@ -291,12 +291,29 @@ button.dsm-tag:disabled{cursor:default;opacity:.6}
 .dsm-adv-caret{flex:none;color:var(--dsw-alias-label-tertiary);font-size:10px}
 /* 「高级选项」永不折行：它在收起时与两行摘要并排，被挤成两字一行就不再像个标题了。 */
 .dsm-adv-title{flex:none;white-space:nowrap}
-/* 折叠摘要固定两行（模型/思考强度/目录注入 + 工具名单），靠 align-items:center 与标题垂直居中。 */
+/* 折叠摘要最多两行（第一行模型 / 思考强度 / 允许追问，第二行工具限制；没有值的那一行不出现），
+   靠 align-items:center 与标题垂直居中。 */
 .dsm-adv-sum{display:flex;min-width:0;flex-direction:column;gap:1px}
-.dsm-adv-body{display:flex;flex-direction:column;gap:12px;padding:11px;border-top:1px solid var(--dsw-alias-border-l1)}
+.dsm-adv-body{display:flex;flex-direction:column;gap:16px;padding:11px;border-top:1px solid var(--dsw-alias-border-l1)}
+/* 分组（0.19.0 重排）：组标题 + 一条横贯的细线，组间距靠 .dsm-adv-body 的 16px。
+   重排前是五组平铺、只靠 12px gap 分隔，视觉上连成一片 —— 分组是这次清理的主手段。 */
+.dsm-adv-group{display:flex;flex-direction:column;gap:10px}
+.dsm-adv-group-head{display:flex;align-items:center;gap:8px;color:var(--dsw-alias-label-primary);font-size:12px;font-weight:570}
+.dsm-adv-group-head::after{content:'';height:1px;flex:1;background:var(--dsw-alias-border-l1)}
+/* 半宽字段：与 .dsm-field-row 的列宽同源（calc(50% - 6px) = 12px gap 的一半），
+   所以单独一个半宽字段和并排两个的列边界对齐。 */
+.dsm-adv-half{width:calc(50% - 6px)}
+/* 下拉在 .dsm-combo-row 里必须自己撑满整格。缺这条时 .dsm-select 是 flex:0 1 auto、宽度
+   由**选项文字**撑出：收窄来源后标签变短（去掉了「来源 · 」前缀、候选只剩几条），下拉当场
+   跟着缩 —— 用户 2026-10-07 截图「模型来源选择后，模型框变短了」。实测（headless Chrome，
+   字段宽 251）：标签带前缀 251 / 去前缀 251 / 只剩 id 162 / 只有一个模型 135，加了这条全部 251。
+   min-width:0 是配套的：flex 项默认 min-width:auto = min-content，不放宽就压不到整格以下。 */
+.dsm-combo-row .dsm-select{flex:1;min-width:0}
 .dsm-adv-note{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:17px}
 /* ── 工具限制四行（人设表单：一行一个 Agent 预设，白/黑名单互斥、默认折叠）──────── */
-.dsm-modes{display:flex;flex-direction:column;gap:6px;margin-top:6px}
+/* 无 margin-top：这个名单原先紧跟在自己的字段 label 后面，靠 6px 拉开；0.19.0 重排后
+   label 撤掉、由分组头承担，间距交给 .dsm-adv-group 的 gap。 */
+.dsm-modes{display:flex;flex-direction:column;gap:6px}
 .dsm-mode-row{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-1)}
 .dsm-mode-row.dsm-mode-on{border-color:var(--dsw-alias-border-l3)}
 .dsm-mode-head{display:flex;min-height:38px;align-items:center;gap:9px;padding:0 10px}
@@ -3807,7 +3824,7 @@ html,body{scrollbar-gutter:stable}.dsm-settings-scroll-host{overflow-y:scroll!im
         "compat.live.state.child": "不在本会话注入",
         "compat.live.state.error": "取数失败",
         "compat.live.state.error.title": "这个域这一轮取数抛了异常（内容还在，是这一步没取到）—— 兼容页「上下文注入通道」有一行降级写着原因。它不会误发「已清空」，下一步会自动重试。",
-        "compat.live.state.child.title": "本会话的深度超过了人设的目录注入深度（catalogDepth），所以常驻目录不在这里注入。要让目录出现在子会话，把对应人设的「目录注入」调大（或选「不限制嵌套」）。注意：这不影响委派 —— 子代理始终可以继续委派。",
+        "compat.live.state.child.title": "本会话是子代理会话，这个域对子会话不成立 —— 两种情形：① **场景与记忆**只在顶层注入（它们说的是父会话的处境，子代理要什么由父代理写进委派说明）；② **人设目录**的注入深度不够（本会话深度超过该人设的 `catalogDepth`，默认 1 = 只在顶层），这一种可以把人设的「目录注入」调大或选「不限制嵌套」。两种都不影响委派 —— 子代理始终可以继续委派。",
         "compat.live.adopt": "注入 {injected} 次 · 调用 {used} 次 · 采纳 {adopted} 次",
         "compat.live.adopt.none": "注入 {injected} 次 · 从未调用",
         "compat.live.adopt.title": "只数**最近这一段对话**（换一段重新数，重启归零）。采纳 = 调用发生时该域正文正在这个会话的上下文里；调用次数不区分成功失败",
@@ -3918,15 +3935,32 @@ html,body{scrollbar-gutter:stable}.dsm-settings-scroll-host{overflow-y:scroll!im
         "subagents.create": "新建人设", "subagents.edit": "编辑人设",
         "subagents.field.name": "人设名",
         "subagents.field.description": "描述", "subagents.field.description.placeholder": "例如 擅长 Java 后端实现与重构",
-        "subagents.field.model": "模型", "subagents.field.model.placeholder": "自定义模型 id", "subagents.field.model.hint": "留空继承主会话", "subagents.field.provider": "模型来源", "subagents.field.provider.placeholder": "deepseek", "subagents.field.provider.hint": "「模型来源」与「模型」是一对：只填模型会落在主会话的来源上，跨来源会解析失败。",
-        "subagents.field.catalogDepth": "目录注入", "subagents.field.catalogDepth.onlyTop": "只在顶层", "subagents.field.catalogDepth.toChild": "顶层和子会话", "subagents.field.catalogDepth.toGrand": "顶层和两层子会话", "subagents.field.catalogDepth.unlimited": "不限制嵌套", "subagents.field.catalogDepth.hint": "决定人设目录注入到哪几层会话。\n只影响目录注入，不影响委派 —— 子代理始终可以继续委派。\n子会话看不到目录时，可用 subagent_manager_list 查询。",
-        // 思考强度（0.14.0）。界面上只留"这一格现在能选什么"，不解释机制 ——
-        // 官方语义（改 provider/model 会丢掉继承值、不支持的档位直接拒）记在 CHANGELOG / update.md，
-        // 不搬进表单。
-        "subagents.field.effort": "思考强度", "subagents.effort.default": "默认（模型的默认强度）", "subagents.effort.none": "默认", "subagents.effort.needModel": "当前默认主会话思考强度", "subagents.effort.loading": "正在问该模型支持哪些档位…", "subagents.effort.unavailable": "该模型没有暴露可选档位，默认思考强度", "subagents.effort.hint": "当前可选择多种思考强度", "subagents.effort.dropped": "换模型后「{effort}」不在新模型的档位里，已清空。",
-        "subagents.model.inherit": "继承主会话（不指定）", "subagents.model.customOption": "自定义 / 目录里没有…",
-        "subagents.field.modes": "工具限制（按 Agent 预设）",
-        "subagents.field.modes.hint": "只有当前模式那一行生效，其他模式用该模式的全部工具。",
+        // 模型来源 / 模型 / 目录注入三格的静态说明（provider.hint、catalogDepth.hint）随 0.19.0
+        // 重排移出表单：来源与模型并排成一组，谁跟谁是一对由位置表达；目录注入那条只说了半句
+        // "不影响委派"，半句不解释"那影响什么"，留着比不留更费解。
+        "subagents.field.model": "模型", "subagents.field.provider": "模型来源",
+        "subagents.field.offCatalog": "{id} · 目录里没有",
+        "subagents.field.catalogDepth": "目录注入", "subagents.field.catalogDepth.onlyTop": "只在顶层", "subagents.field.catalogDepth.toChild": "顶层和子会话", "subagents.field.catalogDepth.toGrand": "顶层和两层子会话", "subagents.field.catalogDepth.unlimited": "不限制嵌套",
+        // 允许追问（0.19.0）。界面只留复选框副标题那一行 —— 机制（官方 startContinuable / 结算通知 /
+        // 返回指引）与代价（占用可继续子代理名额、需要持久化与 session query）留在 CHANGELOG 与
+        // README（2026-10-07 用户裁定：高级选项里的提示句太密，长说明一律不进表单）。
+        "subagents.field.continuable": "允许追问（后台运行）", "subagents.field.continuable.short": "回执一个 id，之后还能继续对话",
+        // 收起态摘要用的两个「尾巴」。分隔号写在值里（而不是在代码里 join '；'）：英文侧要用
+        // "; "，中文用「；」，写进词典才不用为语言改代码。空串 = 这一项没值，整段不出现。
+        "subagents.adv.continuable": "；允许追问（后台运行）",
+        "subagents.adv.legacy": "；旧格式：白名单 {allow} / 黑名单 {deny}",
+        // 思考强度（0.14.0）。界面上只留"这一格现在能选什么"与**状态**（未选模型 / 拉取中 / 拉不到），
+        // 不解释机制 —— 官方语义（改 provider/model 会丢掉继承值、不支持的档位直接拒）记在
+        // CHANGELOG / update.md，不搬进表单。needModel 保留但压到最短：它解释的是"这一格为什么灰着"。
+        "subagents.field.effort": "思考强度", "subagents.effort.default": "默认（模型的默认强度）", "subagents.effort.none": "默认", "subagents.effort.needModel": "先选模型", "subagents.effort.loading": "正在问该模型支持哪些档位…", "subagents.effort.unavailable": "该模型没有暴露可选档位，默认思考强度", "subagents.effort.dropped": "换模型后「{effort}」不在新模型的档位里，已清空。",
+        // 来源下拉的空选项。措辞刻意与模型那条不同（"继承主会话"）：两者含义一致，但并排两个
+        // 下拉出现同一句话会让人以为点错了格。这一句同时接住被撤掉的那条静态说明
+        // （provider.hint「只填模型会落在主会话的来源上」）要说的事。
+        "subagents.provider.inherit": "不指定（用主会话的来源）",
+        "subagents.model.inherit": "继承主会话（不指定）",
+        // 标题改由高级选项的分组头承担（subagents.adv.group.tools），字段自己的 label 撤掉 ——
+        // 同一句话在 10px 内说两遍（"工具限制" + "工具限制（按 Agent 预设）"）。
+        "subagents.field.modes.hint": "只有当前模式那一行生效；MCP 工具不在候选里，始终可用",
         "subagents.mode.startAllow": "启动白名单", "subagents.mode.startDeny": "启动黑名单", "subagents.mode.stopAllow": "关闭白名单", "subagents.mode.stopDeny": "关闭黑名单",
         "subagents.mode.off": "未限制", "subagents.mode.empty": "已启动但没勾选（= 不限制）",
         "subagents.mode.allowOn": "白名单 {count} 个", "subagents.mode.denyOn": "黑名单 {count} 个",
@@ -3939,8 +3973,10 @@ html,body{scrollbar-gutter:stable}.dsm-settings-scroll-host{overflow-y:scroll!im
         "subagents.legacy.note": "这个文件里还有一份旧写法的工具限制（白名单 {allow} 个 / 黑名单 {deny} 个），它对所有模式都生效。",
         "subagents.legacy.convert": "转换到按模式设置",
         "subagents.legacy.hint": "转换会把旧名单搬进你选的模式；不点它，文件里的旧键原样保留（运行时照旧生效）。",
-        "subagents.tools.filter": "筛选工具名", "subagents.tools.remove": "移除", "subagents.toolFailed": "子代理工具没注册上：{names}（{reason}）。这几个工具在子智能体流程里用不了；重启 DSH 后仍如此请核对宿主版本。",
-        "subagents.adv.title": "高级选项", "subagents.adv.inherit": "继承主会话", "subagents.adv.summary": "模型：{model}；思考强度：{effort}；目录注入：{depth}", "subagents.adv.summary2": "模式限制：{modes} 项；旧格式：白名单 {allow} / 黑名单 {deny}", "subagents.adv.note": "白名单 = 子代理只能用勾选的工具。\n黑名单 = 除勾选的以外都能用。\nMCP 工具不在候选里：子代理始终能用当前在跑的 MCP。", "subagents.adv.loadFailed": "读取候选数据失败（模型目录 / 工具清单）；仍可手动填写。",
+        "subagents.tools.filter": "筛选工具名", "subagents.tools.remove": "移除", "subagents.tools.group.plugin": "插件工具", "subagents.tools.group.official": "官方工具", "subagents.tools.group.other": "其他工具", "subagents.toolFailed": "子代理工具没注册上：{names}（{reason}）。这几个工具在子智能体流程里用不了；重启 DSH 后仍如此请核对宿主版本。",
+        // 收起态摘要最多两行、只报有值的项：第一行模型 / 思考强度（+ 允许追问），第二行工具限制。
+        // 目录注入不进摘要 —— 它只决定目录出现在哪些会话，不影响委派本身。
+        "subagents.adv.title": "高级选项", "subagents.adv.inherit": "继承主会话", "subagents.adv.summary": "模型：{model}；思考强度：{effort}{tail}", "subagents.adv.summary2": "模式限制：{modes} 项{tail}", "subagents.adv.loadFailed": "读取候选数据失败（模型目录 / 工具清单）；仍可手动填写。", "subagents.adv.group.model": "模型", "subagents.adv.group.runtime": "运行方式", "subagents.adv.group.tools": "工具限制",
         "preset.name.standard": "标准模式", "preset.name.ptc": "PTC模式", "preset.name.minimal": "极简模式", "preset.name.cordis": "创造模式",
         "preset.short.standard": "标准", "preset.short.ptc": "PTC", "preset.short.minimal": "极简", "preset.short.cordis": "创造",
         "subagents.field.body": "人设提示词", "subagents.field.body.placeholder": "写下这个人设的身份、职责与工作方式…",
@@ -4426,7 +4462,7 @@ html,body{scrollbar-gutter:stable}.dsm-settings-scroll-host{overflow-y:scroll!im
         "compat.live.state.child": "Not injected here",
         "compat.live.state.error": "Failed to load",
         "compat.live.state.error.title": "This domain threw while producing its text this round (the content exists; this step just could not read it). The Compat page's \"Context injection channel\" row carries a degraded note with the reason. No false \"cleared\" notice is sent, and the next step retries automatically.",
-        "compat.live.state.child.title": "This session is deeper than the personas' catalog injection depth (catalogDepth), so the standing catalog is not injected here. To let the catalog reach subagent sessions, raise the persona's catalog injection depth (or pick “No nesting limit”). Note: this does not affect delegation — subagents can always delegate further.",
+        "compat.live.state.child.title": "This session is a subagent session and this domain does not apply to it — two cases: (1) **scene and memory** are injected at the top level only (they describe the parent session's situation; what a subagent needs belongs in the delegation brief); (2) the **persona catalog**'s injection depth is too shallow (this session is deeper than that persona's `catalogDepth`, default 1 = top level only) — raise that persona's catalog injection depth or pick “No nesting limit”. Neither affects delegation — subagents can always delegate further.",
         "compat.live.adopt": "injected {injected} · called {used} · adopted {adopted}",
         "compat.live.adopt.none": "injected {injected} · never called",
         "compat.live.adopt.title": "Counts the most recent conversation only (it restarts when you switch, and on every launch). Adopted = the domain text was in context when the call happened; calls are counted whether or not they succeeded",
@@ -4537,15 +4573,37 @@ html,body{scrollbar-gutter:stable}.dsm-settings-scroll-host{overflow-y:scroll!im
         "subagents.create": "New persona", "subagents.edit": "Edit persona",
         "subagents.field.name": "Persona name",
         "subagents.field.description": "Description", "subagents.field.description.placeholder": "e.g. Senior Java engineer",
-        "subagents.field.model": "Model", "subagents.field.model.placeholder": "Custom model id", "subagents.field.model.hint": "Blank inherits the main session", "subagents.field.provider": "Model provider", "subagents.field.provider.placeholder": "deepseek", "subagents.field.provider.hint": "Provider and model are a pair: a model alone resolves against the main session's provider and fails across providers.",
-        "subagents.field.catalogDepth": "Catalog injection", "subagents.field.catalogDepth.onlyTop": "Top level only", "subagents.field.catalogDepth.toChild": "Top level and subagents", "subagents.field.catalogDepth.toGrand": "Top level and two levels down", "subagents.field.catalogDepth.unlimited": "No nesting limit", "subagents.field.catalogDepth.hint": "Which levels of sessions get the persona catalog.\nIt affects the catalog only — subagents can always delegate further.\nWhen the catalog is not injected, subagent_manager_list still works.",
-        // Reasoning effort (0.14.0). The form only says what this field offers right now; the
-        // official semantics (the host drops the inherited level when provider/model change, and an
-        // unsupported level is rejected rather than clamped) live in CHANGELOG / update.md, not here.
-        "subagents.field.effort": "Reasoning effort", "subagents.effort.default": "Default (the model's default)", "subagents.effort.none": "default", "subagents.effort.needModel": "Currently the main session's default reasoning effort.", "subagents.effort.loading": "Asking the model which levels it supports…", "subagents.effort.unavailable": "This model exposes no selectable levels — default reasoning effort.", "subagents.effort.hint": "Several reasoning-effort levels are available.", "subagents.effort.dropped": "“{effort}” is not among the new model's levels, so it was cleared.",
-        "subagents.model.inherit": "Inherit the main session (unspecified)", "subagents.model.customOption": "Custom / not in the catalogue…",
-        "subagents.field.modes": "Tool limits (per agent preset)",
-        "subagents.field.modes.hint": "Only the row for the current preset applies; other presets keep their full tool set.",
+        // The static help lines for provider / model / catalog depth left the form with the 0.19.0
+        // re-layout: provider and model now sit side by side as one group, so the pairing is carried
+        // by position; the catalog-depth line only stated half a fact ("affects the catalog only")
+        // without saying what it does affect, which is more confusing than saying nothing.
+        "subagents.field.model": "Model", "subagents.field.provider": "Model provider",
+        "subagents.field.offCatalog": "{id} · not in the catalogue",
+        "subagents.field.catalogDepth": "Catalog injection", "subagents.field.catalogDepth.onlyTop": "Top level only", "subagents.field.catalogDepth.toChild": "Top level and subagents", "subagents.field.catalogDepth.toGrand": "Top level and two levels down", "subagents.field.catalogDepth.unlimited": "No nesting limit",
+        // Continuable (0.19.0). The form keeps only the checkbox subtitle; the mechanism (the
+        // official startContinuable, the settlement notice, the return guidance) and the cost
+        // (capacity slot, persistence + session query) live in CHANGELOG and README, not here
+        // (user ruling 2026-10-07: the advanced section carried far too many help sentences).
+        "subagents.field.continuable": "Continuable (runs in the background)", "subagents.field.continuable.short": "Returns an id you can keep talking to",
+        // The two "tails" of the collapsed summary. The separator lives inside the value (not a
+        // hard-coded join in code): English needs "; " where Chinese needs "；". Empty = no value,
+        // so the whole clause disappears.
+        "subagents.adv.continuable": "; continuable (runs in the background)",
+        "subagents.adv.legacy": "; legacy allow: {allow} / deny: {deny}",
+        // Reasoning effort (0.14.0). The form keeps only what this field offers right now plus the
+        // transient states (no model picked / loading / none available); the official semantics (the
+        // host drops the inherited level when provider/model change, and an unsupported level is
+        // rejected rather than clamped) live in CHANGELOG / update.md, not here.
+        "subagents.field.effort": "Reasoning effort", "subagents.effort.default": "Default (the model's default)", "subagents.effort.none": "default", "subagents.effort.needModel": "Pick a model first", "subagents.effort.loading": "Asking the model which levels it supports…", "subagents.effort.unavailable": "This model exposes no selectable levels — default reasoning effort.", "subagents.effort.dropped": "“{effort}” is not among the new model's levels, so it was cleared.",
+        // The blank entry of the provider dropdown. Deliberately worded differently from the model
+        // one ("Inherit the main session"): same meaning, but the same sentence in two adjacent
+        // dropdowns reads like a mis-click. This line also carries what the removed static hint
+        // (provider.hint) used to say.
+        "subagents.provider.inherit": "Unspecified (main session's provider)",
+        "subagents.model.inherit": "Inherit the main session (unspecified)",
+        // The heading moved to the advanced section's group head (subagents.adv.group.tools) and the
+        // field's own label was dropped — the same phrase twice within 10px otherwise.
+        "subagents.field.modes.hint": "Only the current preset's row applies; MCP tools are not listed and always stay available",
         "subagents.mode.startAllow": "Enable allowlist", "subagents.mode.startDeny": "Enable denylist", "subagents.mode.stopAllow": "Disable allowlist", "subagents.mode.stopDeny": "Disable denylist",
         "subagents.mode.off": "no restriction", "subagents.mode.empty": "enabled with nothing picked (= no restriction)",
         "subagents.mode.allowOn": "allowlist {count}", "subagents.mode.denyOn": "denylist {count}",
@@ -4558,8 +4616,11 @@ html,body{scrollbar-gutter:stable}.dsm-settings-scroll-host{overflow-y:scroll!im
         "subagents.legacy.note": "This file still carries the old-style tool limits (allowlist {allow} / denylist {deny}); they apply to every preset.",
         "subagents.legacy.convert": "Convert into a preset row",
         "subagents.legacy.hint": "Converting moves the old list into the preset you pick; until then the old keys stay untouched in the file (and keep working at run time).",
-        "subagents.tools.filter": "Filter tool names", "subagents.tools.remove": "Remove", "subagents.toolFailed": "Subagent tools failed to register: {names} ({reason}). They cannot be used in the subagent flow; if this persists after a DSH restart, check the host version.",
-        "subagents.adv.title": "Advanced options", "subagents.adv.inherit": "inherit", "subagents.adv.summary": "model: {model}; effort: {effort}; catalog: {depth}", "subagents.adv.summary2": "preset limits: {modes}; legacy allow: {allow} / deny: {deny}", "subagents.adv.note": "Allowlist = the subagent may only use the picked tools.\nDenylist = everything except the picked ones.\nMCP tools are not listed: a subagent always keeps the MCP servers currently running.", "subagents.adv.loadFailed": "Could not read the candidate data (model catalogue / tool list); you can still fill the fields by hand.",
+        "subagents.tools.filter": "Filter tool names", "subagents.tools.remove": "Remove", "subagents.tools.group.plugin": "Plugin tools", "subagents.tools.group.official": "Official tools", "subagents.tools.group.other": "Other tools", "subagents.toolFailed": "Subagent tools failed to register: {names} ({reason}). They cannot be used in the subagent flow; if this persists after a DSH restart, check the host version.",
+        // The collapsed summary is at most two lines and reports only what has a value: line 1 is
+        // model / effort (+ continuable), line 2 is the tool limits. Catalog injection is left out —
+        // it only decides which sessions see the catalogue, not how a delegation runs.
+        "subagents.adv.title": "Advanced options", "subagents.adv.inherit": "inherit", "subagents.adv.summary": "model: {model}; effort: {effort}{tail}", "subagents.adv.summary2": "preset limits: {modes}{tail}", "subagents.adv.loadFailed": "Could not read the candidate data (model catalogue / tool list); you can still fill the fields by hand.", "subagents.adv.group.model": "Model", "subagents.adv.group.runtime": "Runtime", "subagents.adv.group.tools": "Tool limits",
         "preset.name.standard": "Standard mode", "preset.name.ptc": "PTC mode", "preset.name.minimal": "Minimal mode", "preset.name.cordis": "Creator mode",
         "preset.short.standard": "Standard", "preset.short.ptc": "PTC", "preset.short.minimal": "Minimal", "preset.short.cordis": "Creator",
         "subagents.field.body": "Persona prompt", "subagents.field.body.placeholder": "Describe the persona's role, responsibilities, and working style…",
@@ -10040,810 +10101,972 @@ function enabledMemoryCount(rules) {
             }) : null,
           )
         }
-        // ---------- 子智能体页：人设文件（~/.dsh/subagents/*.md）管理 ----------
-        /**
-         * 「思考强度」档位的按 (provider, model) 缓存。
-         *
-         * 为什么放在**组件外**：放进组件里每次渲染都会重建，等于没有缓存，而档位清单要问
-         * adapter（`llm.resolveModelInfo`，异步、可能联网）—— 编辑人设时来回切模型不该每次都问。
-         * TTL 5 分钟：档位是模型能力声明，短时间内不会变；换模型时才重新问。
-         */
-        var EFFORT_CACHE_TTL_MS = 5 * 60 * 1000
-        var effortCacheByRoute = {}
-        function readEffortCache(key) {
-          var hit = effortCacheByRoute[key]
-          if (!hit) return null
-          if (Date.now() - hit.at > EFFORT_CACHE_TTL_MS) { delete effortCacheByRoute[key]; return null }
-          return hit.value
-        }
-        function writeEffortCache(key, value) { effortCacheByRoute[key] = { at: Date.now(), value: value } }
-        function SubagentsPage() {
-          var state = React.useState({ loading: true, error: null, subagents: [] })
-          var data = state[0], setData = state[1]
-          var bs = React.useState(false)
-          var busy = bs[0], setBusy = bs[1]
-          var rs = React.useState(null)
-          var result = rs[0], setResult = rs[1]
-          var ms = React.useState(null)
-          var modal = ms[0], setModal = ms[1]
-          /**
-           * 「思考强度」的加载状态。key = 已拉取/正在拉取的 `provider\0model`（空串 = 还没选模型）。
-           * 与 `cands` 分开两个 state：档位是**按模型**懒加载的，而候选目录是一次性拉的，
-           * 混在一起会让"切换模型"误触发整份候选重拉。
-           */
-          var es = React.useState({ key: '', loading: false, error: null, efforts: [], defaultEffort: null })
-          var eff = es[0], setEff = es[1]
-          /** 换模型导致已存档位被清掉时的一次性提示（下次换模型或关弹窗即消失）。 */
-          var ens = React.useState(null)
-          var effNotice = ens[0], setEffNotice = ens[1]
-          // 搜索词独立一处：`data` 在 refresh 时被整对象替换，寄在它里面会被刷新清空。
-          // 过滤用防抖值，输入框仍绑原值（与提示词页同一写法）。
-          var qs = React.useState('')
-          var query = qs[0], setQuery = qs[1]
-          var dq = useDebouncedValue(query)
-          // 场景锁定（v0.8）：任一场景锁定 = 五个域整体冻结；本页全部写控件禁用。
-          var anyLocked = data.anyLocked === true
-          // 场景内开关由档案定义：人设开关置灰（要改就去场景页的档案编辑器里改）。
-          var sceneName = data.activeScene || null
-          // 回收站：删除人设 = 移入回收站（宿主侧 subagent-delete），这里列出/恢复/永久删除。
-          var ts = React.useState(null)
-          var trash = ts[0], setTrash = ts[1]
-          var tb = React.useState(false)
-          var trashBusy = tb[0], setTrashBusy = tb[1]
-          var flipRef = React.useRef(null)
-          useFlipReorder(flipRef)
-          function loadTrash(keepOpen) {
-            setTrash(Object.assign({ loading: true, error: null, entries: [] }, keepOpen ? trash || {} : {}))
-            apiCall('subagent-trash-list', {}).then(function (res) {
-              if (res && res.ok) setTrash({ loading: false, error: null, entries: res.trash || [] })
-              else setTrash({ loading: false, error: (res && res.error) || t('trash.loadFailed'), entries: [] })
-            }).catch(function (e) { setTrash({ loading: false, error: errMsg(e), entries: [] }) })
-          }
-          function restorePersona(item) {
-            setTrashBusy(true)
-            apiCall('subagent-trash-restore', { id: item.id }).then(function (res) {
-              setTrashBusy(false)
-              if (res && res.ok) { var sw = stateSyncWarn(t, res); setResult({ ok: !sw, warning: !!sw, text: t('trash.restored', { name: item.name }) + (sw ? ' ' + sw : '') }); refresh(true); loadTrash(true) }
-              else setTrash(function (cur) { return Object.assign({}, cur, { error: (res && res.error) || t('mcp.msg.failed') }) })
-            }).catch(function (e) { setTrashBusy(false); setTrash(function (cur) { return Object.assign({}, cur, { error: errMsg(e) }) }) })
-          }
-          function purgePersona(item) {
-            setTrashBusy(true)
-            apiCall('subagent-trash-delete', { id: item.id }).then(function (res) {
-              setTrashBusy(false)
-              if (res && res.ok) { setResult({ ok: true, text: t('trash.purged', { name: item.name }) }); loadTrash(true) }
-              else setTrash(function (cur) { return Object.assign({}, cur, { error: (res && res.error) || t('mcp.msg.failed') }) })
-            }).catch(function (e) { setTrashBusy(false); setTrash(function (cur) { return Object.assign({}, cur, { error: errMsg(e) }) }) })
-          }
-          React.useEffect(function () { if (!result || result.ok !== true) return undefined; var timer = setTimeout(function () { setResult(null) }, 2600); return function () { clearTimeout(timer) } }, [result])
-          function refresh(silent) {
-            if (!silent) setData(function (prev) { return Object.assign({}, prev, { loading: true, error: null }) })
-            apiCall('subagent-list', {}).then(function (r) {
-              // `activeScene` 必须一起搬进来：这里是把 `data` 整对象替换掉（搜索词另存就是为了
-              // 不被冲掉），漏一个字段等于那个字段永远是初始值 —— 场景横幅因此从来没显示过
-              // （2026-09-19 用户报的：技能 / 子智能体 / 记忆三页都看不到"当前处于场景…"）。
-              if (r && r.ok) setData({ loading: false, error: null, subagents: r.subagents || [], anyLocked: r.anyLocked === true, activeScene: r.activeScene || null, toolFailures: Array.isArray(r.toolFailures) ? r.toolFailures : [] })
-              else setData({ loading: false, error: translateError(t, r), subagents: [], toolFailures: [] })
-            }).catch(function (e) { setData({ loading: false, error: errMsg(e), subagents: [], toolFailures: [] }) })
-          }
-          React.useEffect(function () { refresh() }, [])
-          /**
-           * 子智能体开关（与记忆页同一套交互）：停用 = 不注入目录段、subagent_manager_list/run
-           * 不可见；人设文件不动。开关联动全局状态，立即提交。
-           */
-          function togglePersona(p) {
-            var next = !(p.enabled !== false)
-            setBusy(true)
-            apiCall('subagent-toggle', { name: p.name, enabled: next }).then(function (r) {
-              setBusy(false)
-              if (r && r.ok) {
-                // 场景内改开关：人设改了、档案没跟上时说清楚（详见 sceneSyncWarn）。
-                var warn = sceneSyncWarn(t, r)
-                setResult(warn ? { ok: false, warning: true, text: warn } : null)
-                refresh(true)
-              } else if (r) setResult({ ok: false, text: translateError(t, r) })
-            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
-          }
-          /**
-           * 人设表单的候选数据（模型目录 / 全体预设工具并集）只在**首次展开高级选项**时拉取：
-           * 宿主枚举预设需要为尚未挂载的预设建立 standing mount，不该在打开弹窗时就付这个代价。
-           */
-          var cands = React.useState({ loaded: false, loading: false, error: null, models: [], tools: [], presets: [] })
-          var cand = cands[0], setCand = cands[1]
-          function loadCandidates() {
-            if (cand.loaded || cand.loading) return
-            setCand(Object.assign({}, cand, { loading: true, error: null }))
-            Promise.all([apiCall('model-candidates', {}), apiCall('preset-tools', {})]).then(function (rs) {
-              var mres = rs[0], tres = rs[1]
-              var failed = (!mres || mres.ok === false) && (!tres || tres.ok === false)
-              setCand({
-                loaded: true, loading: false,
-                error: failed ? t('subagents.adv.loadFailed') : null,
-                models: (mres && mres.models) || [],
-                tools: (tres && tres.tools) || [],
-                // presets 必须原样带过来：四行模式的名字、顺序、每行的工具清单全靠它，
-                // 早先这里只留 models/tools，于是分组标题退回裸 id（中文界面里显示英文）。
-                presets: (tres && tres.presets) || [],
-              })
-            }).catch(function (e) {
-              setCand({ loaded: true, loading: false, error: errMsg(e), models: [], tools: [], presets: [] })
-            })
-          }
-          /**
-           * 拉取某个 (provider, model) 的思考强度档位。**只有真正展开了高级选项、且选了模型**才会
-           * 被调到（三个调用点：展开高级选项、模型下拉变更、自定义模型输入失焦）。
-           *
-           * 两个语义要点（都来自官方源码，见 src/subagents/service.ts 的 `reasoningEffort` 注释）：
-           *   · 档位跟模型走 —— 换模型必须重拉，旧清单对新模型无效；
-           *   · **拉取失败一律不动已存的值**：只有"成功且当前值不在清单里"才清档。否则一次网络
-           *     抖动就把用户设置抹了，而失败本身已经有提示。
-           */
-          function loadEfforts(provider, model) {
-            setEffNotice(null)
-            var pv = String(provider || ''), md = String(model || '')
-            if (!pv || !md) { setEff({ key: '', loading: false, error: null, efforts: [], defaultEffort: null }); return }
-            var key = pv + '\u0000' + md
-            var cached = readEffortCache(key)
-            if (cached) {
-              setEff({ key: key, loading: false, error: cached.ok ? null : cached.error, efforts: cached.efforts || [], defaultEffort: cached.defaultEffort || null })
-              if (cached.ok) dropEffortIfGone(cached.efforts || [])
-              return
-            }
-            setEff({ key: key, loading: true, error: null, efforts: [], defaultEffort: null })
-            apiCall('model-reasoning', { provider: pv, model: md }).then(function (res) {
-              var value = res && res.ok !== false
-                ? { ok: true, efforts: res.efforts || [], defaultEffort: res.defaultEffort || null }
-                : { ok: false, error: (res && res.error) || t('subagents.effort.unavailable'), efforts: [], defaultEffort: null }
-              writeEffortCache(key, value)
-              setEff({ key: key, loading: false, error: value.ok ? null : value.error, efforts: value.efforts, defaultEffort: value.defaultEffort })
-              if (value.ok) dropEffortIfGone(value.efforts)
-            }).catch(function (e) {
-              var value = { ok: false, error: errMsg(e), efforts: [], defaultEffort: null }
-              writeEffortCache(key, value)
-              setEff({ key: key, loading: false, error: value.error, efforts: [], defaultEffort: null })
-            })
-          }
-          /**
-           * 自动清档：清单里没有当前存的那一档 → 清掉并给一次性提示。
-           *
-           * 为什么必须清：官方对**不支持**的显式档位是在 provider I/O 之前直接拒（不夹紧、不别名），
-           * 留着它 = 下一次委派直接起不来，而错误要到那时才看得见。
-           * 为什么只在"拉取成功"时判断：失败时清单是空的，拿空清单当"没有这一档"会把设置误清。
-           */
-          function dropEffortIfGone(list) {
-            if (!modal || modal.type !== 'editor') return
-            var cur = String(modal.form.reasoningEffort || '')
-            if (!cur) return
-            var has = (list || []).some(function (e) { return String(e && e.id) === cur })
-            if (has) return
-            setEffNotice(t('subagents.effort.dropped', { effort: cur }))
-            setForm({ reasoningEffort: '' })
-          }
-          /** 当前表单的 (provider, model) 路由键 —— 用来与 `eff.key` 比，确认清单属于当前模型。 */
-          function currentRouteKey() {
-            return String((modal && modal.form.provider) || '') + '\u0000' + String((modal && modal.form.model) || '')
-          }
-          /**
-           * 当前模型**已就绪**的档位。未就绪一律返回空数组：切换模型后 `eff` 里还留着上一个模型的
-           * 清单（新请求还没回来），照它渲染会让用户选中一个不属于这个模型的档位 —— 而官方对不支持的
-           * 档位是直接拒，等于埋一次"委派起不来"。
-           */
-          function currentEfforts() {
-            if (!modal || !modal.form.model || eff.loading || eff.error) return []
-            return eff.key === currentRouteKey() ? (eff.efforts || []) : []
-          }
-          /** 空档（不指定）那一行的悬停说明：把 adapter 给的默认档位名字显示出来（拿不到就不显示）。 */
-          function defaultEffortTitle() {
-            var id = eff.defaultEffort
-            if (!id || eff.key !== currentRouteKey()) return undefined
-            var hit = (eff.efforts || []).filter(function (e) { return String(e && e.id) === String(id) })[0]
-            return hit ? String(hit.name || hit.id) : String(id)
-          }
-          /** 高级选项：默认收起；已经在用模型/工具限制的人设自动展开（否则用户看不见自己配了什么）。 */
-          /** 「不限制嵌套」的取值（与 src/subagents/service.ts 的 UNLIMITED_PERSONA_CATALOG_DEPTH 同值）。 */
-          var CATALOG_DEPTH_UNLIMITED = 99
-          /** 目录注入深度的选项文案：下拉与折叠摘要共用一处，免得两处说法分叉。 */
-          function catalogDepthLabel(n) {
-            if (n === 1) return t('subagents.field.catalogDepth.onlyTop')
-            if (n === 2) return t('subagents.field.catalogDepth.toChild')
-            if (n >= CATALOG_DEPTH_UNLIMITED) return t('subagents.field.catalogDepth.unlimited')
-            return t('subagents.field.catalogDepth.toGrand')
-          }
-          function initialAdvanced(p) {
-            var modes = p && p.toolsByPreset ? Object.keys(p.toolsByPreset).length : 0
-            // 目录注入深度不是默认值（1）时也算"配过"：它决定常驻目录出现在哪些会话，
-            // 藏起来会让"为什么子会话看不到目录"变得无从查起。
-            var budget = !!(p && typeof p.catalogDepth === 'number' && p.catalogDepth !== 1)
-            // 思考强度同理：配过就得让人看得见 —— 它是"下一次委派会怎么跑"的一部分，
-            // 藏在收起的高级选项里等于用户改过又忘了自己改过。
-            return !!(budget || (p && (p.model || p.provider || p.reasoningEffort)) || (p && ((p.tools || []).length || (p.toolsDeny || []).length || modes)))
-          }
-          /** 编辑态里按模式分组的名单（深拷贝：取消编辑不留痕）。 */
-          function cloneRules(source) {
-            var out = {}
-            Object.keys(source || {}).forEach(function (id) {
-              var rule = source[id] || {}
-              out[id] = { mode: rule.mode === 'deny' ? 'deny' : 'allow', names: (rule.names || []).slice() }
-            })
-            return out
-          }
-          function openEditor(name) {
-            if (!name) {
-              setModal({ type: 'editor', mode: 'create', advanced: false, openMode: null, stoppedRules: {}, modeQuery: '', legacyTarget: '', form: { name: '', description: '', provider: '', model: '', reasoningEffort: '', catalogDepth: 1, tools: [], toolsDeny: [], toolsByPreset: {}, body: '', output: '', error: null } })
-              return
-            }
-            setBusy(true)
-            apiCall('subagent-get', { name: name }).then(function (res) {
-              setBusy(false)
-              if (res && res.ok) {
-                var p = res.persona || {}
-                var advanced = initialAdvanced(p)
-                setModal({ type: 'editor', mode: 'edit', originalName: String(p.name || name), advanced: advanced, openMode: null, stoppedRules: {}, modeQuery: '', legacyTarget: '', form: {
-                  name: p.name || name, description: p.description || '', provider: p.provider || '', model: p.model || '',
-                  // 思考强度：服务端回空串 = 这份人设没指定（不是"没有档位"）。空值不落盘，见 serializePersona。
-                  reasoningEffort: p.reasoningEffort || '',
-                  // 服务端回的是**生效值**（没写就是默认 1），所以这里不必再兜默认。
-                  catalogDepth: typeof p.catalogDepth === 'number' ? p.catalogDepth : 1,
-                  tools: (p.tools || []).slice(), toolsDeny: (p.toolsDeny || []).slice(),
-                  toolsByPreset: cloneRules(p.toolsByPreset), body: p.body || '', output: p.output || '', error: null,
-                } })
-                // 已配过限制的人设**一打开就是展开的**（initialAdvanced）→ 候选数据必须在这里也拉，
-                // 否则四行模式先亮"宿主没有回传预设名单"，非得点两次「高级选项」才补上（用户实测）。
-                // 思考强度同理：展开着就要有档位清单（它按模型懒加载，所以这里显式带上 model）。
-                if (advanced) { loadCandidates(); loadEfforts(p.provider, p.model) }
-              } else setResult({ ok: false, text: translateError(t, res) })
-            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
-          }
-          function setForm(patch) { if (modal && modal.type === 'editor') setModal(Object.assign({}, modal, { form: Object.assign({}, modal.form, patch) })) }
-          /** 列表里增删一项（勾选语义：存在 = 勾上）。 */
-          function toggled(list, name) {
-            var next = (list || []).slice()
-            var i = next.indexOf(name)
-            if (i >= 0) next.splice(i, 1); else next.push(name)
-            return next
-          }
-          /**
-           * 模型下拉的当前值。
-           * 宿主目录里有这对 (provider, model) → 用它；只有 model 没有 provider（跨来源手工填的）
-           * 或目录里没有 → 走「自定义」，同时把输入框露出来，避免把用户已配好的值悄悄改掉。
-           */
-          function modelSelectValue() {
-            if (!modal || modal.type !== 'editor') return ''
-            var f = modal.form
-            if (!f.model) return ''
-            var hit = (cand.models || []).filter(function (m) { return m.provider === f.provider && m.id === f.model })[0]
-            return hit ? (f.provider + '\u0000' + f.model) : '__custom__'
-          }
-          /**
-           * 官方四个预设的中英名走插件词典（官方 preset.yml 里只有中文名，直接用会让英文界面
-           * 露出中文）；**自建预设用它自己的名字，不翻译** —— 与官方 display 规则一致。
-           * 四个预设 id → 词典键的映射只认官方发布的这四个 id。
-           */
-          var SHIPPED_PRESET_IDS = { minimal: 1, standard: 1, ptc: 1, cordis: 1 }
-          function presetLabel(p) {
-            if (!p) return ''
-            var id = String(p.id || '')
-            if (SHIPPED_PRESET_IDS[id] === 1 && String(p.trust || 'system') !== 'user') return t('preset.name.' + id)
-            return String(p.name || id)
-          }
-          /** 该模式下可勾选的工具名；`null` = 宿主没给出该模式的清单（读不到，不能假装是空）。 */
-          function modeTools(id) {
-            var hit = (cand.presets || []).filter(function (p) { return p.id === id })[0]
-            return hit && Array.isArray(hit.tools) ? hit.tools : null
-          }
-          function modeRule(id) { return (modal.form.toolsByPreset || {})[id] }
-          function setModeRule(id, rule) {
-            var next = Object.assign({}, modal.form.toolsByPreset || {})
-            if (rule) next[id] = rule; else delete next[id]
-            setModal(Object.assign({}, modal, {
-              form: Object.assign({}, modal.form, { toolsByPreset: next }),
-              openMode: modal.openMode === id && !rule ? null : modal.openMode,
-            }))
-          }
-          /** 模式行上的一句话状态：未开启 / 白名单 N 个 / 黑名单 N 个 / 已开启但没勾（= 不限制）。 */
-          function modeSummary(id) {
-            var rule = modeRule(id)
-            if (!rule) return { text: t('subagents.mode.off'), cls: 'dsm-mode-off' }
-            var n = (rule.names || []).length
-            if (!n) return { text: t('subagents.mode.empty'), cls: 'dsm-mode-off' }
-            return {
-              text: t(rule.mode === 'deny' ? 'subagents.mode.denyOn' : 'subagents.mode.allowOn', { count: n }),
-              cls: rule.mode === 'deny' ? 'dsm-mode-deny' : 'dsm-mode-allow',
-            }
-          }
-          /**
-           * 启动某一侧名单：生效 + 就地展开。同一模式内白/黑互斥 —— 启动一侧就把模式切过去，
-           * **已勾选的名字保留**（只换语义），这样"改成黑名单"不用从头再勾一遍。
-           */
-          function startMode(id, mode) {
-            // 刚被「关闭」掉的名字记在 stoppedRules 里：重新启用时带回，免得"关一下再开"把
-            // 已勾好的名单清空（用户实测踩到：以为「关闭白名单」是收起设置，再启用就空了）。
-            var prev = modeRule(id) || (modal.stoppedRules || {})[id]
-            var names = prev && Array.isArray(prev.names) ? prev.names.slice() : []
-            setModal(Object.assign({}, modal, {
-              openMode: id, modeQuery: '',
-              form: Object.assign({}, modal.form, {
-                toolsByPreset: Object.assign({}, modal.form.toolsByPreset || {}, { [id]: { mode: mode, names: names } }),
-              }),
-            }))
-          }
-          function stopMode(id) {
-            var prev = modeRule(id)
-            var stopped = Object.assign({}, modal.stoppedRules || {})
-            if (prev) stopped[id] = { mode: prev.mode, names: (prev.names || []).slice() }
-            var next = Object.assign({}, modal.form.toolsByPreset || {})
-            delete next[id]
-            setModal(Object.assign({}, modal, {
-              stoppedRules: stopped,
-              openMode: modal.openMode === id ? null : modal.openMode,
-              form: Object.assign({}, modal.form, { toolsByPreset: next }),
-            }))
-          }
-          function toggleModeTool(id, name) {
-            var rule = modeRule(id)
-            if (!rule) return
-            setModeRule(id, { mode: rule.mode, names: toggled(rule.names || [], name) })
-          }
-          /**
-           * 展开后的勾选区：只列**该模式自己的**工具。这样勾出来的名字天然都属于这个预设，
-           * 不会出现"在标准模式勾了只属于 PTC 的工具 → 换模式跑就启动失败"。
-           * MCP 工具不在这里（用户裁定）：子代理照旧能用当前在跑的 MCP，那份名单在运行时并入。
-           */
-          function modeEditor(p) {
-            var id = p.id
-            var rule = modeRule(id)
-            if (!rule) return null
-            var all = modeTools(id)
-            if (all === null || all.length === 0) {
-              return React.createElement('div', { className: 'dsm-mode-body' },
-                React.createElement('div', { className: 'dsm-pick-empty' }, p.broken ? t('subagents.mode.broken') : t('subagents.mode.noTools')))
-            }
-            var q = String(modal.modeQuery || '').trim().toLowerCase()
-            var list = q ? all.filter(function (n) { return n.toLowerCase().indexOf(q) >= 0 }) : all
-            var picked = rule.names || []
-            // 与其余「全选」同一口径：全勾了就只给「取消全选」（二合一，不并列）。
-            var allPickedAll = all.length > 0 && all.every(function (n) { return picked.indexOf(n) >= 0 })
-            return React.createElement('div', { className: 'dsm-mode-body' },
-              picked.length
-                ? React.createElement('div', { className: 'dsm-tools-chips' }, picked.map(function (name) {
-                    return React.createElement('span', { key: 'c:' + name, className: 'dsm-chip' + (rule.mode === 'deny' ? ' dsm-chip-deny' : '') },
-                      name,
-                      React.createElement('button', { type: 'button', title: t('subagents.tools.remove'), onClick: function () { toggleModeTool(id, name) } }, '×'))
-                  }))
-                : React.createElement('span', { className: 'dsm-adv-note' }, t(rule.mode === 'deny' ? 'subagents.mode.denyEmpty' : 'subagents.mode.allowEmpty')),
-              React.createElement('div', { className: 'dsm-combo-row' },
-                React.createElement('input', {
-                  className: 'dsm-control',
-                  value: modal.modeQuery || '',
-                  placeholder: t('subagents.tools.filter'),
-                  onChange: function (e) { setModal(Object.assign({}, modal, { modeQuery: e.target.value })) },
-                }),
-                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary dsm-btn-bulk', disabled: busy, onClick: function () { setModeRule(id, { mode: rule.mode, names: allPickedAll ? [] : all.slice() }) } }, bulkPair(allPickedAll ? t('bulk.unselectAll') : t('bulk.selectAll'), allPickedAll ? t('bulk.selectAll') : t('bulk.unselectAll')))),
-              list.length
-                ? React.createElement('div', { className: 'dsm-tools-grid' }, list.map(function (name) {
-                    return pickRow({ key: 'm:' + id + ':' + name, disabled: busy, checked: picked.indexOf(name) >= 0, name: name, onChange: function () { toggleModeTool(id, name) } })
-                  }))
-                : React.createElement('div', { className: 'dsm-pick-empty' }, t('scenes.mem.noMatch')))
-          }
-          /**
-           * 工具限制的两段说明：先「哪一行生效」，再白/黑名单语义。
-           * 两段是同一件事的两半，紧贴成一块 —— 分开渲染时中间隔着 12px 空行（用户 2026-09-18 指出）；
-           * 后一段按条目清单渲染（一条一行，见 helpBullets）。
-           */
-          function modeNotes() {
-            return React.createElement('div', null,
-              React.createElement('p', { className: 'dsm-help' }, t('subagents.field.modes.hint')),
-              helpBullets(t, 'subagents.adv.note'))
-          }
-          /**
-           * 一行一个 Agent 预设（roster 顺序：标准 / PTC / 极简 / 创造 / 自建预设）。
-           * 默认全部折叠、全部未启动；右侧两个按钮「启动 白名单」「启动 黑名单」互斥。
-           */
-          function modeRows() {
-            var presets = (cand.presets || []).slice()
-            if (!presets.length) {
-              return React.createElement('div', { className: 'dsm-field' },
-                React.createElement('span', { className: 'dsm-label' }, t('subagents.field.modes')),
-                React.createElement('div', { className: 'dsm-pick-empty' }, cand.loading ? t('memory.loading') : t('subagents.mode.noPresets')),
-                modeNotes())
-            }
-            return React.createElement('div', { className: 'dsm-field' },
-              React.createElement('span', { className: 'dsm-label' }, t('subagents.field.modes')),
-              React.createElement('div', { className: 'dsm-modes' }, presets.map(function (p) {
-                var id = p.id
-                var rule = modeRule(id)
-                var summary = modeSummary(id)
-                var startButton = function (mode, isDeny) {
-                  var active = !!rule && rule.mode === mode
-                  return React.createElement('button', {
-                    key: mode,
-                    type: 'button',
-                    className: 'dsm-btn dsm-btn-quiet' + (active ? (mode === 'deny' ? ' dsm-mode-btn-deny' : ' dsm-mode-btn-allow') : ''),
-                    disabled: busy,
-                    onClick: function () { if (active) stopMode(id); else startMode(id, mode) },
-                  }, t(active
-                    ? (isDeny ? 'subagents.mode.stopDeny' : 'subagents.mode.stopAllow')
-                    : (isDeny ? 'subagents.mode.startDeny' : 'subagents.mode.startAllow')))
-                }
-                var open = modal.openMode === id
-                return React.createElement('div', { className: 'dsm-mode-row' + (rule ? ' dsm-mode-on' : ''), key: id },
-                  React.createElement('div', { className: 'dsm-mode-head' },
-                    // 行首按钮 = 展开 / 收起名单（用户实测：已配好的模式只有「关闭白名单」可点，
-                    // 点下去是把模式停掉、名单设置再也进不去 —— 查看/编辑与启用/停用必须分开）。
-                    React.createElement('button', {
-                      type: 'button',
-                      className: 'dsm-mode-head-main',
-                      disabled: !rule,
-                      title: rule ? t('subagents.mode.toggleHint') : '',
-                      'aria-expanded': open ? 'true' : 'false',
-                      onClick: function () {
-                        setModal(Object.assign({}, modal, { openMode: open ? null : id, modeQuery: '' }))
-                      },
-                    },
-                      React.createElement('span', { className: 'dsm-mode-caret', 'aria-hidden': 'true' }, rule ? (open ? '▾' : '▸') : ''),
-                      React.createElement('span', { className: 'dsm-mode-name' }, presetLabel(p)),
-                      p.broken ? React.createElement('span', { className: 'dsm-tag dsm-tag-off' }, t('compat.reach.broken')) : null,
-                      React.createElement('span', { className: 'dsm-mode-sum ' + summary.cls }, summary.text)),
-                    React.createElement('span', { className: 'dsm-mode-actions' },
-                      startButton('allow', false),
-                      startButton('deny', true))),
-                  open ? modeEditor(p) : null)
-              })),
-              modeNotes())
-          }
-          /**
-           * 旧格式（全局 `tools:` / `toolsDeny:`）的只读小结 + 转换入口。
-           * 旧键对所有模式生效，运行时仍然照旧执行；**不点转换就不动文件里的旧键**。
-           */
-          function legacyNotice() {
-            var allow = modal.form.tools || []
-            var deny = modal.form.toolsDeny || []
-            if (!allow.length && !deny.length) return null
-            var presets = cand.presets || []
-            var target = modal.legacyTarget || (presets[0] ? presets[0].id : '')
-            return React.createElement('div', { className: 'dsm-legacy' },
-              React.createElement('span', { className: 'dsm-adv-note' }, t('subagents.legacy.note', { allow: allow.length, deny: deny.length })),
-              React.createElement('div', { className: 'dsm-combo-row' },
-                React.createElement('div', { className: 'dsm-select' },
-                  React.createElement('select', {
-                    className: 'dsm-control',
-                    value: target,
-                    disabled: busy || !presets.length,
-                    onChange: function (e) { setModal(Object.assign({}, modal, { legacyTarget: e.target.value })) },
-                  }, presets.map(function (p) { return React.createElement('option', { key: p.id, value: p.id }, presetLabel(p)) }))),
-                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-quiet', disabled: busy || !target || !presets.length, onClick: function () {
-                  var rule = { mode: allow.length ? 'allow' : 'deny', names: (allow.length ? allow : deny).slice() }
-                  setModal(Object.assign({}, modal, {
-                    openMode: target,
-                    modeQuery: '',
-                    legacyTarget: target,
-                    form: Object.assign({}, modal.form, {
-                      tools: [], toolsDeny: [],
-                      toolsByPreset: Object.assign({}, modal.form.toolsByPreset || {}, { [target]: rule }),
-                    }),
-                  }))
-                } }, t('subagents.legacy.convert'))),
-              React.createElement('p', { className: 'dsm-help' }, t('subagents.legacy.hint')))
-          }
-          function toggleAdvanced() {
-            if (!modal || modal.type !== 'editor') return
-            var next = !modal.advanced
-            setModal(Object.assign({}, modal, { advanced: next }))
-            if (next) {
-              loadCandidates()
-              // 档位清单与候选目录**分开拉**：候选是本地目录（一次性），档位要问 adapter
-              // （按模型、可能联网），所以这里用表单里当前的模型去拉；没选模型就什么都不发。
-              loadEfforts(modal.form.provider, modal.form.model)
-            }
-          }
-          function submitEditor() {
-            if (!modal || modal.type !== 'editor') return
-            setBusy(true)
-            var op = modal.mode === 'create' ? 'subagent-create' : 'subagent-update'
-            // 编辑时名字可改：nextName 只在真的改过时才传（服务端按原名定位文件）。
-            var renamed = modal.mode === 'edit' && modal.originalName && modal.originalName !== modal.form.name
-            apiCall(op, {
-              name: renamed ? String(modal.originalName) : modal.form.name,
-              ...(renamed ? { nextName: String(modal.form.name || '').trim() } : {}),
-              description: modal.form.description,
-              provider: modal.form.provider, model: modal.form.model,
-              catalogDepth: modal.form.catalogDepth,
-              // 旧格式的全局名单原样回写（旧键不点转换就不动），新模式名单另存一块。
-              tools: modal.form.tools || [], toolsDeny: modal.form.toolsDeny || [],
-              toolsByPreset: modal.form.toolsByPreset || {},
-              body: modal.form.body,
-              output: modal.form.output || '',
-            }).then(function (res) {
-              setBusy(false)
-              if (res && res.ok) { var sw = stateSyncWarn(t, res); setModal(null); setResult({ ok: !sw, warning: !!sw, text: t('subagents.result.saved', { name: modal.form.name }) + (sw ? ' ' + sw : '') }); refresh(true) }
-              else setModal(Object.assign({}, modal, { form: Object.assign({}, modal.form, { error: translateError(t, res) }) }))
-            }).catch(function (e) { setBusy(false); setModal(Object.assign({}, modal, { form: Object.assign({}, modal.form, { error: errMsg(e) }) })) })
-          }
-          function submitDelete(name) {
-            setBusy(true)
-            apiCall('subagent-delete', { name: name }).then(function (res) {
-              setBusy(false); setModal(null)
-              if (res && res.ok) { var sw = stateSyncWarn(t, res); setResult({ ok: !sw, warning: !!sw, text: t('subagents.result.deleted', { name: name }) + (sw ? ' ' + sw : '') }); refresh(true) }
-              else setResult({ ok: false, text: translateError(t, res) })
-            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
-          }
-          // ── 导入人设（.md / .zip，多选或拖入；同名跳过并报告）──
-          function submitImport(files) {
-            if (!files || !files.length) return
-            setBusy(true)
-            apiCall('subagent-import', { files: files }).then(function (res) {
-              setBusy(false)
-              if (res && res.ok) {
-                setModal(null)
-                var names = res.imported || [], skipped = res.skipped || []
-                var text = names.length ? t('subagents.result.imported', { count: names.length, names: names.join('、') }) : t('import.none')
-                if (skipped.length) text += ' · ' + t('import.skipped', { items: skipped.map(function (s) { return s.name + '（' + s.reason + '）' }).join('；') })
-                var sw = stateSyncWarn(t, res)
-                if (sw) text += ' ' + sw
-                setResult({ ok: !sw, warning: !!sw, text: text }); refresh(true)
-              } else setResult({ ok: false, text: translateError(t, res) })
-            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
-          }
-          // 过滤只跟数据与（防抖后的）搜索词有关：每次渲染重扫一整份列表没有必要。
-          // FLIP 的 key 仍是 `p.name`（过滤只改变"列表里有哪些"，不改变身份）。
-          var visibleSubagents = React.useMemo(function () {
-            return data.subagents.filter(function (p) { return matchPersonaQuery(p, dq) })
-          }, [data.subagents, dq])
-          // 「启用的排前面」（用户要求）：与过滤分开记忆 —— 只跟过滤结果有关，弹窗 / 结果提示条
-          // 之类的状态变化不再重跑分区。FLIP 的 data-flip-on 仍来自 p.enabled，未动。
-          var orderedSubagents = React.useMemo(function () {
-            return enabledFirst(visibleSubagents, function (p) { return p.enabled !== false; })
-          }, [visibleSubagents])
-          var limitedCount = React.useMemo(function () {
-            return data.subagents.filter(function (p) { return (p.tools && p.tools.length) || (p.toolsDeny && p.toolsDeny.length) || (p.toolsByPreset && Object.keys(p.toolsByPreset).length) }).length
-          }, [data.subagents])
-          return React.createElement('section', { className: 'dsm-section' },
-            React.createElement('div', { className: 'dsm-head' },
-              React.createElement('div', { className: 'dsm-title-block' },
-                React.createElement('div', { className: 'dsm-title-row' },
-                  React.createElement('h2', { className: 'dsm-title' }, t('subagents.title'))),
-                React.createElement('p', { className: 'dsm-desc' }, t('subagents.desc'))),
-              React.createElement('div', { className: 'dsm-actions' },
-                refreshButton(t, busy || data.loading, { className: 'dsm-btn dsm-btn-secondary', disabled: busy || data.loading, onClick: function () { refresh() } }),
-                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', disabled: busy || anyLocked, onClick: function () { openEditor(null) } }, t('subagents.new')),
-                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', disabled: busy || anyLocked, onClick: function () { setResult(null); setModal({ type: 'import' }) } }, t('subagents.import')),
-                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', disabled: busy || !data.subagents.length, onClick: function () { setResult(null); setModal({ type: 'export' }) } }, t('export.subagents')),
-                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', onClick: function () { loadTrash(false) } }, t('trash.btn.open')))),
-            anyLocked === true ? React.createElement('div', { className: 'dsm-feedback dsm-warning', role: 'status' }, t('lock.banner')) : null,
-            // 锁定期间不显示场景那条长句：开关全是灰的，"改动会同步写进档案"没有落点，
-            // 两条并排还会互相矛盾（用户 2026-09-19）。
-            (anyLocked !== true && sceneName) ? React.createElement('div', { className: 'dsm-feedback dsm-warning', role: 'status' }, t('scene.switch.banner', { scene: sceneName })) : null,
-            React.createElement('div', { className: 'dsm-summary', style: { '--dsm-stat-cols': '2' } },
-              [['total', data.subagents.length, t('subagents.stat.total')],
-                ['limited', limitedCount, t('subagents.stat.limited')]].map(function (item) {
-                return React.createElement('div', { key: item[0], className: 'dsm-stat' },
-                  React.createElement('strong', null, item[1]), item[2])
-              })),
-            // 搜索框：统计条之后（与 MCP / 技能 / 记忆 / 提示词页同一位置与样式）。
-            React.createElement('div', { className: 'dsm-filters' },
-              React.createElement('input', {
-                className: 'dsm-control dsm-search', value: query, 'aria-label': t('search'),
-                placeholder: t('subagents.search.placeholder'),
-                onChange: function (e) { setQuery(e.target.value) },
-              })),
-            React.createElement(Notice, { kind: result && result.warning ? 'warn' : result && result.ok ? 'ok' : 'err', text: result && result.text }),
-            // 走 Notice 而不是裸 div：令牌没过的提醒会在右侧自动多出一颗「填写令牌」按钮。
-            data.error ? React.createElement(Notice, { kind: 'err', text: String(data.error) }) : null,
-            // 注册失败的工具（`subagent_manager_list` / `_run`）：模型侧只会「查无此工具」，
-            // 这条横幅是用户唯一能看到的地方。名字与原因来自服务端，句子在这里按当前语言拼。
-            (data.toolFailures || []).length ? React.createElement(Notice, {
-              kind: 'warn',
-              text: t('subagents.toolFailed', {
-                names: (data.toolFailures || []).map(function (f) { return f.name }).join('、'),
-                reason: String(((data.toolFailures || [])[0] || {}).reason || ''),
-              }),
-            }) : null,
-            data.loading && !data.subagents.length ? React.createElement('div', { className: 'dsm-empty' }, t('memory.loading'))
-              : !data.subagents.length ? React.createElement('div', { className: 'dsm-empty' }, t('subagents.empty'))
-                : !visibleSubagents.length ? React.createElement('div', { className: 'dsm-empty' }, t('subagents.empty.search'))
-                  : React.createElement('div', { className: 'dsm-sources', ref: flipRef }, orderedSubagents.map(function (p) {
-                return React.createElement('div', { key: p.name, className: 'dsm-source', 'data-flip-key': p.name, 'data-flip-on': p.enabled !== false ? '1' : '0' },
-                  React.createElement('div', { className: 'dsm-source-head' },
-                    React.createElement('div', { className: 'dsm-source-head-main dsm-persona-main' },
-                      React.createElement('div', { className: 'dsm-persona-name-row' },
-                        React.createElement('span', { className: 'dsm-source-title', title: p.name }, p.name),
-                        // 两个状态都给胶囊：以前只在停用时挂标签，启用的一行什么都不留，
-                        // 用户没法一眼看出「没标签 = 启用」。
-                        p.enabled === false
-                          ? React.createElement(StatusTag, { tone: 'muted', text: t('subagents.disabled'), title: t('subagents.disabled.hint') })
-                          : React.createElement(StatusTag, { tone: 'ok', text: t('subagents.enabled') })),
-                      // 没有描述就不渲染这一行：空 div 仍占一行行高，行会变成一条无内容的空隙。
-                      p.description ? React.createElement('div', { className: 'dsm-persona-desc', title: p.description }, p.description) : null),
-                    React.createElement('div', { className: 'dsm-source-actions' },
-                      React.createElement(Switch, { on: p.enabled !== false, disabled: busy || anyLocked, label: t('subagents.toggle') + ' ' + p.name, onClick: function () { togglePersona(p) } }),
-                      React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-quiet', disabled: busy || anyLocked, onClick: function () { openEditor(p.name) } }, t('memory.edit')),
-                      React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-quiet dsm-btn-danger', disabled: busy || anyLocked, onClick: function () { setModal({ type: 'delete', name: p.name }) } }, t('memory.delete')))))
-              })),
-            modal && modal.type === 'editor' ? React.createElement(Modal, { key: 'sedit', wide: true, title: modal.mode === 'create' ? t('subagents.create') : t('subagents.edit') + ' · ' + modal.form.name, closeLabel: t('btn.close'), onClose: function () { setModal(null) } },
-              React.createElement('div', { className: 'dsm-form' },
-                React.createElement('label', { className: 'dsm-field' },
-                  React.createElement('span', { className: 'dsm-label' }, t('subagents.field.name')),
-                  React.createElement('input', { className: 'dsm-control', value: modal.form.name || '', placeholder: 'code-review', onChange: function (e) { setForm({ name: e.target.value }) } })),
-                React.createElement('label', { className: 'dsm-field' },
-                  // 描述会整段进「可委派的子智能体」目录，上限就是注入侧的截断长度（`CATALOG_DESC_MAX`）；
-                  // 存量人设的超长描述标红（服务端不校验这个长度，只有注入时截）。
-                  React.createElement('div', { className: 'dsm-budget-meta' },
-                    React.createElement('span', { className: 'dsm-label' }, t('subagents.field.description')),
-                    React.createElement('span', { className: 'dsm-char-count' + (String(modal.form.description || '').length > CATALOG_DESC_MAX ? ' dsm-char-over' : '') }, String(modal.form.description || '').length + ' / ' + CATALOG_DESC_MAX)),
-                  React.createElement('input', { className: 'dsm-control', value: modal.form.description || '', maxLength: CATALOG_DESC_MAX, placeholder: t('subagents.field.description.placeholder'), onChange: function (e) { setForm({ description: e.target.value }) } })),
-                React.createElement('label', { className: 'dsm-field' },
-                  React.createElement('span', { className: 'dsm-label' }, t('subagents.field.body')),
-                  React.createElement('textarea', { className: 'dsm-control dsm-textarea-md', value: modal.form.body || '', placeholder: t('subagents.field.body.placeholder'), onChange: function (e) { setForm({ body: e.target.value }) } })),
-                // 输出要求（frontmatter `output:`，一条一行）：单独成节写进子代理的系统提示词。
-                // 与正文分开是有意的 —— 正文是"这个角色是什么"（散文），这里放"产出必须长什么样"
-                // （可检验的硬要求）。混在一起时散文会把硬要求稀释成风格提示（用户实测）。
-                React.createElement('label', { className: 'dsm-field' },
-                  React.createElement('span', { className: 'dsm-label' }, t('subagents.field.output')),
-                  React.createElement('textarea', { className: 'dsm-control dsm-textarea-md', value: modal.form.output || '', placeholder: t('subagents.field.output.placeholder'), onChange: function (e) { setForm({ output: e.target.value }) } }),
-                  React.createElement('p', { className: 'dsm-help' }, t('subagents.field.output.hint'))),
-                // ── 高级选项（默认收起）──
-                // 模型 / 工具限制是「少数人才改」的字段，但一旦改错代价高（跨来源模型、工具名打错
-                // 会让子代理直接启动失败）。所以：收起来但**有值就自动展开**，并把候选做成选择器。
-                React.createElement('div', { className: 'dsm-adv' },
-                  React.createElement('button', { type: 'button', className: 'dsm-adv-head', 'aria-expanded': modal.advanced === true, onClick: toggleAdvanced },
-                    React.createElement('span', { className: 'dsm-adv-caret' }, modal.advanced ? '▼' : '▶'),
-                    React.createElement('span', { className: 'dsm-adv-title' }, t('subagents.adv.title')),
-                    modal.advanced ? null : React.createElement('span', { className: 'dsm-adv-note dsm-adv-sum' },
-                      // 摘要固定两行：六项挤在一行会整句折行，把「高级选项」顶得七零八落。
-                      // 第一行是"下一次委派会怎么跑"，第二行是工具名单的存量。
-                      React.createElement('span', null, t('subagents.adv.summary', {
-                        model: modal.form.model ? (modal.form.provider ? modal.form.provider + '/' + modal.form.model : modal.form.model) : t('subagents.adv.inherit'),
-                        depth: catalogDepthLabel(typeof modal.form.catalogDepth === 'number' ? modal.form.catalogDepth : 1),
-                        // 思考强度收起来也要看得见：它是"下一次委派会怎么跑"的一部分。
-                        // 没配时报「默认」而**不是**「继承」—— 官方语义里换模型会把继承来的那一档
-                        // 删掉（`dsh-subagent/lib/index.js:482`），报「继承」是句假话。
-                        effort: modal.form.reasoningEffort ? String(modal.form.reasoningEffort) : t('subagents.effort.none'),
-                      })),
-                      React.createElement('span', null, t('subagents.adv.summary2', {
-                        modes: Object.keys(modal.form.toolsByPreset || {}).length,
-                        allow: (modal.form.tools || []).length,
-                        deny: (modal.form.toolsDeny || []).length,
-                      })))),
-                  modal.advanced ? React.createElement('div', { className: 'dsm-adv-body' },
-                    // 模型 + 思考强度并排（`.dsm-field-row`）：它们是同一件事的两半 —— 档位清单是
-                    // **按模型**给的（adapter 的能力声明），换模型必须同时看这一格。
-                    // 不复用 `.dsm-combo-row`：那个的语义是"一个控件 + 它的自定义输入"，
-                    // 它的 `.dsm-control{flex:1}` 会把两个控件都拉满。
-                    React.createElement('div', { className: 'dsm-field-row' },
-                      // 模型：宿主 LLM 目录里的 (provider, model) 对 + 自定义兜底。
-                      React.createElement('div', { className: 'dsm-field' },
-                        React.createElement('span', { className: 'dsm-label' }, t('subagents.field.model')),
-                        React.createElement('div', { className: 'dsm-combo-row' },
-                          React.createElement('div', { className: 'dsm-select' },
-                            React.createElement('select', {
-                              className: 'dsm-control',
-                              value: modelSelectValue(),
-                              disabled: busy || cand.loading,
-                              onChange: function (e) {
-                                var v = e.target.value
-                                if (v === '') { setForm({ provider: '', model: '' }); loadEfforts('', '') }
-                                else if (v !== '__custom__') {
-                                  var parts = v.split('\u0000')
-                                  setForm({ provider: parts[0], model: parts[1] })
-                                  // 档位跟模型走：换模型必须重拉（缓存命中时是同步的，不会闪）。
-                                  loadEfforts(parts[0], parts[1])
-                                } else { setForm({ model: modal.form.model || '' }); loadEfforts(modal.form.provider || '', modal.form.model || '') }
-                              },
-                            },
-                              React.createElement('option', { value: '' }, t('subagents.model.inherit')),
-                              (cand.models || []).map(function (m) {
-                                return React.createElement('option', { key: m.provider + '/' + m.id, value: m.provider + '\u0000' + m.id }, m.provider + ' · ' + m.name)
-                              }),
-                              React.createElement('option', { value: '__custom__' }, t('subagents.model.customOption')))),
-                          modelSelectValue() === '__custom__'
-                            ? React.createElement('input', {
-                                className: 'dsm-control',
-                                value: modal.form.model || '',
-                                placeholder: t('subagents.field.model.placeholder'),
-                                onChange: function (e) { setForm({ model: e.target.value }) },
-                                // 手填模型 id 时**不按键触发**拉取（一次一个字符 = 一串请求），
-                                // 失焦时再问一次；没变的话缓存会直接命中。
-                                onBlur: function () { loadEfforts(modal.form.provider || '', modal.form.model || '') },
-                              })
-                            : null),
-                        React.createElement('p', { className: 'dsm-help' }, cand.loading ? t('memory.loading') : t('subagents.field.model.hint'))),
-                      // 思考强度：值就是 adapter 给的档位 id（不校验合法性，官方在 provider I/O 前会拒）。
-                      React.createElement('div', { className: 'dsm-field' },
-                        React.createElement('span', { className: 'dsm-label' }, t('subagents.field.effort')),
-                        React.createElement('div', { className: 'dsm-select' },
-                          React.createElement('select', {
-                            className: 'dsm-control',
-                            value: String(modal.form.reasoningEffort || ''),
-                            disabled: busy || eff.loading || !modal.form.model,
-                            onChange: function (e) { setEffNotice(null); setForm({ reasoningEffort: e.target.value }) },
-                          },
-                            React.createElement('option', { value: '', title: defaultEffortTitle() }, t('subagents.effort.default')),
-                            currentEfforts().map(function (x) {
-                              return React.createElement('option', { key: x.id, value: x.id, title: x.description || undefined }, x.name)
-                            }))),
-                        React.createElement('p', { className: 'dsm-help' },
-                          !modal.form.model
-                            ? t('subagents.effort.needModel')
-                            : eff.loading
-                              ? t('subagents.effort.loading')
-                              : eff.error
-                                ? String(eff.error)
-                                : currentEfforts().length ? t('subagents.effort.hint') : t('subagents.effort.unavailable')),
-                        effNotice ? React.createElement('p', { className: 'dsm-feedback dsm-warning' }, effNotice) : null)),
-                    // provider 独立成一项：跨来源模型（如 sensenova）需要 provider+model 两个键同时给。
-                    React.createElement('label', { className: 'dsm-field' },
-                      React.createElement('span', { className: 'dsm-label' }, t('subagents.field.provider')),
-                      React.createElement('input', { className: 'dsm-control', value: modal.form.provider || '', placeholder: t('subagents.field.provider.placeholder'), onChange: function (e) { setForm({ provider: e.target.value }) } }),
-                      React.createElement('p', { className: 'dsm-help' }, t('subagents.field.provider.hint'))),
-                    // 目录注入深度：人设目录注入到哪些会话（默认 1 = 只在顶层）。用下拉而不是数字
-                    // 输入：只有 1/2/3 三个有意义的档，手写数字写错要到注入时才暴露。
-                    //
-                    // ⚠️ 它**不是**递归上限。2026-09-17 用户实测后改名（原名 maxDepth /「委派预算」）：
-                    // 官方 `dsh-tool-subagent` 默认 `maxDepth: 3`，子代理本来就能继续嵌套，本插件
-                    // 也不再向官方传 maxDepth。这个字段只决定常驻目录出现在哪些深度的会话里。
-                    React.createElement('label', { className: 'dsm-field' },
-                      React.createElement('span', { className: 'dsm-label' }, t('subagents.field.catalogDepth')),
-                      React.createElement('div', { className: 'dsm-select' },
-                        React.createElement('select', {
-                          className: 'dsm-control',
-                          value: String(typeof modal.form.catalogDepth === 'number' ? modal.form.catalogDepth : 1),
-                          disabled: busy,
-                          onChange: function (e) { setForm({ catalogDepth: Number(e.target.value) }) },
-                        }, [1, 2, 3, CATALOG_DEPTH_UNLIMITED].map(function (n) {
-                          // 选项文字不带序号：前面再加一个「2 ·」是同一件事说两遍（用户 2026-09-17
-                          // 指出）。下拉的 value 仍是数字，存的还是 catalogDepth 本身。
-                          return React.createElement('option', { key: n, value: String(n) }, catalogDepthLabel(n))
-                        }))),
-                      helpBullets(t, 'subagents.field.catalogDepth.hint')),
-                    // 工具限制：按 Agent 预设一行一个模式（默认全折叠、全部未启动，白/黑互斥）。
-                    // 旧格式的全局名单（老文件 / 别处导入）在这里只读呈现，点「转换」才搬进某个模式。
-                    legacyNotice(),
-                    modeRows(),
-                    cand.error ? React.createElement('div', { className: 'dsm-feedback dsm-warning' }, String(cand.error)) : null)
-                    : null),
-                modal.form.error ? React.createElement('div', { className: 'dsm-feedback dsm-error', role: 'alert' }, String(modal.form.error)) : null),
-              React.createElement('div', { className: 'dsm-modal-actions' },
-                React.createElement('button', { type: 'button', className: 'dsm-btn', disabled: busy || (modal.mode === 'create' && !String(modal.form.name || '').trim()) || !String(modal.form.body || '').trim(), onClick: submitEditor }, t('memory.btn.save')))) : null,
-            modal && modal.type === 'delete' ? React.createElement(Modal, { key: 'sdel2', title: t('subagents.delete.title'), closeLabel: t('btn.close'), onClose: function () { setModal(null) } },
-              React.createElement('p', { className: 'dsm-help' }, t('subagents.delete.desc', { name: modal.name })),
-              React.createElement('div', { className: 'dsm-modal-actions' },
-                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-danger', disabled: busy, onClick: function () { submitDelete(modal.name) } }, t('memory.btn.delete.confirm')))) : null,
-            modal && modal.type === 'import' ? React.createElement(ImportModal, { key: 'simp', t: t, title: t('subagents.import.title'), busy: busy, requirements: [t('upload.requirement.persona.1'), t('upload.requirement.persona.2'), t('upload.requirement.persona.3')], onClose: function () { setModal(null) }, onSubmit: submitImport }) : null,
-            modal && modal.type === 'export' ? React.createElement(ExportModal, {
-              key: 'export', t: t, title: t('export.subagents'),
-              items: data.subagents.map(function (p) { return { key: p.name, name: p.name, desc: p.description || '' } }),
-              busy: busy, result: result,
-              onClose: function () { setResult(null); setModal(null) },
-              onSubmit: function (names, outDir) {
-                setBusy(true); setResult(null);
-                apiCall('bundle-export', { kind: 'subagents', names: names, outDir: outDir }).then(function (res) {
-                  setBusy(false);
-                  if (res && res.ok) setResult({ ok: true, text: exportResultText(t, res) });
-                  else setResult({ ok: false, text: translateError(t, res) });
-                }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) });
-              },
-            }) : null,
-            trash ? React.createElement(TrashModal, {
-              t: t,
-              title: t('trash.title'),
-              groupTitle: t('trash.group.agents'),
-              groupSub: t('trash.section.agents.sub'),
-              locked: anyLocked,
-              entries: trash.entries,
-              loading: trash.loading,
-              error: trash.error,
-              busy: trashBusy,
-              onClose: function () { setTrash(null) },
-              onRestore: restorePersona,
-              onPurge: purgePersona,
-            }) : null)
-        }
-
-        /**
-         * 记忆页的视图（按场景分桶 + 过滤 + 排序）。
-         *
-         * 提到组件外是为了能被 `useMemo` 包住：这段要遍历全部记忆并逐桶排序，而本页的
-         * 编辑器弹窗每敲一个字都会重渲染整页（`editor` 是页内 state）。传进来的 `q` 已防抖。
+        // ---------- 子智能体页：人设文件（~/.dsh/subagents/*.md）管理 ----------
+        /**
+         * 「思考强度」档位的按 (provider, model) 缓存。
+         *
+         * 为什么放在**组件外**：放进组件里每次渲染都会重建，等于没有缓存，而档位清单要问
+         * adapter（`llm.resolveModelInfo`，异步、可能联网）—— 编辑人设时来回切模型不该每次都问。
+         * TTL 5 分钟：档位是模型能力声明，短时间内不会变；换模型时才重新问。
+         */
+        var EFFORT_CACHE_TTL_MS = 5 * 60 * 1000
+        var effortCacheByRoute = {}
+        function readEffortCache(key) {
+          var hit = effortCacheByRoute[key]
+          if (!hit) return null
+          if (Date.now() - hit.at > EFFORT_CACHE_TTL_MS) { delete effortCacheByRoute[key]; return null }
+          return hit.value
+        }
+        function writeEffortCache(key, value) { effortCacheByRoute[key] = { at: Date.now(), value: value } }
+        function SubagentsPage() {
+          var state = React.useState({ loading: true, error: null, subagents: [] })
+          var data = state[0], setData = state[1]
+          var bs = React.useState(false)
+          var busy = bs[0], setBusy = bs[1]
+          var rs = React.useState(null)
+          var result = rs[0], setResult = rs[1]
+          var ms = React.useState(null)
+          var modal = ms[0], setModal = ms[1]
+          /**
+           * 「思考强度」的加载状态。key = 已拉取/正在拉取的 `provider\0model`（空串 = 还没选模型）。
+           * 与 `cands` 分开两个 state：档位是**按模型**懒加载的，而候选目录是一次性拉的，
+           * 混在一起会让"切换模型"误触发整份候选重拉。
+           */
+          var es = React.useState({ key: '', loading: false, error: null, efforts: [], defaultEffort: null })
+          var eff = es[0], setEff = es[1]
+          /** 换模型导致已存档位被清掉时的一次性提示（下次换模型或关弹窗即消失）。 */
+          var ens = React.useState(null)
+          var effNotice = ens[0], setEffNotice = ens[1]
+          // 搜索词独立一处：`data` 在 refresh 时被整对象替换，寄在它里面会被刷新清空。
+          // 过滤用防抖值，输入框仍绑原值（与提示词页同一写法）。
+          var qs = React.useState('')
+          var query = qs[0], setQuery = qs[1]
+          var dq = useDebouncedValue(query)
+          // 场景锁定（v0.8）：任一场景锁定 = 五个域整体冻结；本页全部写控件禁用。
+          var anyLocked = data.anyLocked === true
+          // 场景内开关由档案定义：人设开关置灰（要改就去场景页的档案编辑器里改）。
+          var sceneName = data.activeScene || null
+          // 回收站：删除人设 = 移入回收站（宿主侧 subagent-delete），这里列出/恢复/永久删除。
+          var ts = React.useState(null)
+          var trash = ts[0], setTrash = ts[1]
+          var tb = React.useState(false)
+          var trashBusy = tb[0], setTrashBusy = tb[1]
+          var flipRef = React.useRef(null)
+          useFlipReorder(flipRef)
+          function loadTrash(keepOpen) {
+            setTrash(Object.assign({ loading: true, error: null, entries: [] }, keepOpen ? trash || {} : {}))
+            apiCall('subagent-trash-list', {}).then(function (res) {
+              if (res && res.ok) setTrash({ loading: false, error: null, entries: res.trash || [] })
+              else setTrash({ loading: false, error: (res && res.error) || t('trash.loadFailed'), entries: [] })
+            }).catch(function (e) { setTrash({ loading: false, error: errMsg(e), entries: [] }) })
+          }
+          function restorePersona(item) {
+            setTrashBusy(true)
+            apiCall('subagent-trash-restore', { id: item.id }).then(function (res) {
+              setTrashBusy(false)
+              if (res && res.ok) { var sw = stateSyncWarn(t, res); setResult({ ok: !sw, warning: !!sw, text: t('trash.restored', { name: item.name }) + (sw ? ' ' + sw : '') }); refresh(true); loadTrash(true) }
+              else setTrash(function (cur) { return Object.assign({}, cur, { error: (res && res.error) || t('mcp.msg.failed') }) })
+            }).catch(function (e) { setTrashBusy(false); setTrash(function (cur) { return Object.assign({}, cur, { error: errMsg(e) }) }) })
+          }
+          function purgePersona(item) {
+            setTrashBusy(true)
+            apiCall('subagent-trash-delete', { id: item.id }).then(function (res) {
+              setTrashBusy(false)
+              if (res && res.ok) { setResult({ ok: true, text: t('trash.purged', { name: item.name }) }); loadTrash(true) }
+              else setTrash(function (cur) { return Object.assign({}, cur, { error: (res && res.error) || t('mcp.msg.failed') }) })
+            }).catch(function (e) { setTrashBusy(false); setTrash(function (cur) { return Object.assign({}, cur, { error: errMsg(e) }) }) })
+          }
+          React.useEffect(function () { if (!result || result.ok !== true) return undefined; var timer = setTimeout(function () { setResult(null) }, 2600); return function () { clearTimeout(timer) } }, [result])
+          function refresh(silent) {
+            if (!silent) setData(function (prev) { return Object.assign({}, prev, { loading: true, error: null }) })
+            apiCall('subagent-list', {}).then(function (r) {
+              // `activeScene` 必须一起搬进来：这里是把 `data` 整对象替换掉（搜索词另存就是为了
+              // 不被冲掉），漏一个字段等于那个字段永远是初始值 —— 场景横幅因此从来没显示过
+              // （2026-09-19 用户报的：技能 / 子智能体 / 记忆三页都看不到"当前处于场景…"）。
+              if (r && r.ok) setData({ loading: false, error: null, subagents: r.subagents || [], anyLocked: r.anyLocked === true, activeScene: r.activeScene || null, toolFailures: Array.isArray(r.toolFailures) ? r.toolFailures : [] })
+              else setData({ loading: false, error: translateError(t, r), subagents: [], toolFailures: [] })
+            }).catch(function (e) { setData({ loading: false, error: errMsg(e), subagents: [], toolFailures: [] }) })
+          }
+          React.useEffect(function () { refresh() }, [])
+          /**
+           * 子智能体开关（与记忆页同一套交互）：停用 = 不注入目录段、subagent_manager_list/run
+           * 不可见；人设文件不动。开关联动全局状态，立即提交。
+           */
+          function togglePersona(p) {
+            var next = !(p.enabled !== false)
+            setBusy(true)
+            apiCall('subagent-toggle', { name: p.name, enabled: next }).then(function (r) {
+              setBusy(false)
+              if (r && r.ok) {
+                // 场景内改开关：人设改了、档案没跟上时说清楚（详见 sceneSyncWarn）。
+                var warn = sceneSyncWarn(t, r)
+                setResult(warn ? { ok: false, warning: true, text: warn } : null)
+                refresh(true)
+              } else if (r) setResult({ ok: false, text: translateError(t, r) })
+            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
+          }
+          /**
+           * 人设表单的候选数据（模型目录 / 全体预设工具并集）只在**首次展开高级选项**时拉取：
+           * 宿主枚举预设需要为尚未挂载的预设建立 standing mount，不该在打开弹窗时就付这个代价。
+           */
+          var cands = React.useState({ loaded: false, loading: false, error: null, models: [], providers: [], tools: [], presets: [] })
+          var cand = cands[0], setCand = cands[1]
+          function loadCandidates() {
+            if (cand.loaded || cand.loading) return
+            setCand(Object.assign({}, cand, { loading: true, error: null }))
+            Promise.all([apiCall('model-candidates', {}), apiCall('preset-tools', {})]).then(function (rs) {
+              var mres = rs[0], tres = rs[1]
+              var failed = (!mres || mres.ok === false) && (!tres || tres.ok === false)
+              setCand({
+                loaded: true, loading: false,
+                error: failed ? t('subagents.adv.loadFailed') : null,
+                models: (mres && mres.models) || [],
+                // providers 是去重后的来源清单，**不能**由 models 去重反推：适配器不提供
+                // listModels 时该来源一个模型都报不出来，而"来源有、目录里没模型"正是最需要
+                // 手填模型 id 的场景 —— 反推会让这类来源在「模型来源」下拉里整个消失。
+                providers: (mres && mres.providers) || [],
+                tools: (tres && tres.tools) || [],
+                // presets 必须原样带过来：四行模式的名字、顺序、每行的工具清单全靠它，
+                // 早先这里只留 models/tools，于是分组标题退回裸 id（中文界面里显示英文）。
+                presets: (tres && tres.presets) || [],
+              })
+            }).catch(function (e) {
+              setCand({ loaded: true, loading: false, error: errMsg(e), models: [], providers: [], tools: [], presets: [] })
+            })
+          }
+          /**
+           * 拉取某个 (provider, model) 的思考强度档位。**只有真正展开了高级选项、且选了模型**才会
+           * 被调到（三个调用点：展开高级选项、模型下拉变更、自定义模型输入失焦）。
+           *
+           * 两个语义要点（都来自官方源码，见 src/subagents/service.ts 的 `reasoningEffort` 注释）：
+           *   · 档位跟模型走 —— 换模型必须重拉，旧清单对新模型无效；
+           *   · **拉取失败一律不动已存的值**：只有"成功且当前值不在清单里"才清档。否则一次网络
+           *     抖动就把用户设置抹了，而失败本身已经有提示。
+           */
+          function loadEfforts(provider, model) {
+            setEffNotice(null)
+            var pv = String(provider || ''), md = String(model || '')
+            if (!pv || !md) { setEff({ key: '', loading: false, error: null, efforts: [], defaultEffort: null }); return }
+            var key = pv + '\u0000' + md
+            var cached = readEffortCache(key)
+            if (cached) {
+              setEff({ key: key, loading: false, error: cached.ok ? null : cached.error, efforts: cached.efforts || [], defaultEffort: cached.defaultEffort || null })
+              if (cached.ok) dropEffortIfGone(cached.efforts || [])
+              return
+            }
+            setEff({ key: key, loading: true, error: null, efforts: [], defaultEffort: null })
+            apiCall('model-reasoning', { provider: pv, model: md }).then(function (res) {
+              var value = res && res.ok !== false
+                ? { ok: true, efforts: res.efforts || [], defaultEffort: res.defaultEffort || null }
+                : { ok: false, error: (res && res.error) || t('subagents.effort.unavailable'), efforts: [], defaultEffort: null }
+              writeEffortCache(key, value)
+              setEff({ key: key, loading: false, error: value.ok ? null : value.error, efforts: value.efforts, defaultEffort: value.defaultEffort })
+              if (value.ok) dropEffortIfGone(value.efforts)
+            }).catch(function (e) {
+              var value = { ok: false, error: errMsg(e), efforts: [], defaultEffort: null }
+              writeEffortCache(key, value)
+              setEff({ key: key, loading: false, error: value.error, efforts: [], defaultEffort: null })
+            })
+          }
+          /**
+           * 自动清档：清单里没有当前存的那一档 → 清掉并给一次性提示。
+           *
+           * 为什么必须清：官方对**不支持**的显式档位是在 provider I/O 之前直接拒（不夹紧、不别名），
+           * 留着它 = 下一次委派直接起不来，而错误要到那时才看得见。
+           * 为什么只在"拉取成功"时判断：失败时清单是空的，拿空清单当"没有这一档"会把设置误清。
+           */
+          function dropEffortIfGone(list) {
+            if (!modal || modal.type !== 'editor') return
+            var cur = String(modal.form.reasoningEffort || '')
+            if (!cur) return
+            var has = (list || []).some(function (e) { return String(e && e.id) === cur })
+            if (has) return
+            setEffNotice(t('subagents.effort.dropped', { effort: cur }))
+            setForm({ reasoningEffort: '' })
+          }
+          /** 当前表单的 (provider, model) 路由键 —— 用来与 `eff.key` 比，确认清单属于当前模型。 */
+          function currentRouteKey() {
+            return String((modal && modal.form.provider) || '') + '\u0000' + String((modal && modal.form.model) || '')
+          }
+          /**
+           * 当前模型**已就绪**的档位。未就绪一律返回空数组：切换模型后 `eff` 里还留着上一个模型的
+           * 清单（新请求还没回来），照它渲染会让用户选中一个不属于这个模型的档位 —— 而官方对不支持的
+           * 档位是直接拒，等于埋一次"委派起不来"。
+           */
+          function currentEfforts() {
+            if (!modal || !modal.form.model || eff.loading || eff.error) return []
+            return eff.key === currentRouteKey() ? (eff.efforts || []) : []
+          }
+          /** 空档（不指定）那一行的悬停说明：把 adapter 给的默认档位名字显示出来（拿不到就不显示）。 */
+          function defaultEffortTitle() {
+            var id = eff.defaultEffort
+            if (!id || eff.key !== currentRouteKey()) return undefined
+            var hit = (eff.efforts || []).filter(function (e) { return String(e && e.id) === String(id) })[0]
+            return hit ? String(hit.name || hit.id) : String(id)
+          }
+          /** 高级选项：默认收起；已经在用模型/工具限制的人设自动展开（否则用户看不见自己配了什么）。 */
+          /** 「不限制嵌套」的取值（与 src/subagents/service.ts 的 UNLIMITED_PERSONA_CATALOG_DEPTH 同值）。 */
+          var CATALOG_DEPTH_UNLIMITED = 99
+          /** 目录注入深度的选项文案：下拉与折叠摘要共用一处，免得两处说法分叉。 */
+          function catalogDepthLabel(n) {
+            if (n === 1) return t('subagents.field.catalogDepth.onlyTop')
+            if (n === 2) return t('subagents.field.catalogDepth.toChild')
+            if (n >= CATALOG_DEPTH_UNLIMITED) return t('subagents.field.catalogDepth.unlimited')
+            return t('subagents.field.catalogDepth.toGrand')
+          }
+          function initialAdvanced(p) {
+            var modes = p && p.toolsByPreset ? Object.keys(p.toolsByPreset).length : 0
+            // 目录注入深度不是默认值（1）时也算"配过"：它决定常驻目录出现在哪些会话，
+            // 藏起来会让"为什么子会话看不到目录"变得无从查起。
+            var budget = !!(p && typeof p.catalogDepth === 'number' && p.catalogDepth !== 1)
+            // 允许追问同理：它改变的是"下一次委派会怎么跑"（回执一个 id 而不是产出），
+            // 藏在收起的高级选项里等于用户改过又忘了自己改过。
+            var continuable = !!(p && p.continuable === true)
+            // 思考强度同理：配过就得让人看得见 —— 它是"下一次委派会怎么跑"的一部分，
+            // 藏在收起的高级选项里等于用户改过又忘了自己改过。
+            return !!(budget || continuable || (p && (p.model || p.provider || p.reasoningEffort)) || (p && ((p.tools || []).length || (p.toolsDeny || []).length || modes)))
+          }
+          /** 编辑态里按模式分组的名单（深拷贝：取消编辑不留痕）。 */
+          function cloneRules(source) {
+            var out = {}
+            Object.keys(source || {}).forEach(function (id) {
+              var rule = source[id] || {}
+              out[id] = { mode: rule.mode === 'deny' ? 'deny' : 'allow', names: (rule.names || []).slice() }
+            })
+            return out
+          }
+          function openEditor(name) {
+            if (!name) {
+              setModal({ type: 'editor', mode: 'create', advanced: false, openMode: null, stoppedRules: {}, modeQuery: '', legacyTarget: '', form: { name: '', description: '', provider: '', model: '', reasoningEffort: '', catalogDepth: 1, continuable: false, tools: [], toolsDeny: [], toolsByPreset: {}, body: '', output: '', error: null } })
+              return
+            }
+            setBusy(true)
+            apiCall('subagent-get', { name: name }).then(function (res) {
+              setBusy(false)
+              if (res && res.ok) {
+                var p = res.persona || {}
+                var advanced = initialAdvanced(p)
+                setModal({ type: 'editor', mode: 'edit', originalName: String(p.name || name), advanced: advanced, openMode: null, stoppedRules: {}, modeQuery: '', legacyTarget: '', form: {
+                  name: p.name || name, description: p.description || '', provider: p.provider || '', model: p.model || '',
+                  // 思考强度：服务端回空串 = 这份人设没指定（不是"没有档位"）。空值不落盘，见 serializePersona。
+                  reasoningEffort: p.reasoningEffort || '',
+                  // 服务端回的是**生效值**（没写就是默认 1），所以这里不必再兜默认。
+                  catalogDepth: typeof p.catalogDepth === 'number' ? p.catalogDepth : 1,
+                  // 服务端回布尔；老服务端不带这个字段时按 false（一次性）算。
+                  continuable: p.continuable === true,
+                  tools: (p.tools || []).slice(), toolsDeny: (p.toolsDeny || []).slice(),
+                  toolsByPreset: cloneRules(p.toolsByPreset), body: p.body || '', output: p.output || '', error: null,
+                } })
+                // 已配过限制的人设**一打开就是展开的**（initialAdvanced）→ 候选数据必须在这里也拉，
+                // 否则四行模式先亮"宿主没有回传预设名单"，非得点两次「高级选项」才补上（用户实测）。
+                // 思考强度同理：展开着就要有档位清单（它按模型懒加载，所以这里显式带上 model）。
+                if (advanced) { loadCandidates(); loadEfforts(p.provider, p.model) }
+              } else setResult({ ok: false, text: translateError(t, res) })
+            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
+          }
+          function setForm(patch) { if (modal && modal.type === 'editor') setModal(Object.assign({}, modal, { form: Object.assign({}, modal.form, patch) })) }
+          /** 列表里增删一项（勾选语义：存在 = 勾上）。 */
+          function toggled(list, name) {
+            var next = (list || []).slice()
+            var i = next.indexOf(name)
+            if (i >= 0) next.splice(i, 1); else next.push(name)
+            return next
+          }
+          /**
+           * 模型下拉的当前值：`provider\0model` 复合键（与每个选项的 value 同构）。
+           *
+           * 目录里查不到这对 (来源, 模型) 时也**照原样给**，靠 `offCatalogModel()` 那条额外选项
+           * 显示出来。0.19.0 之前这里会退回一个「自定义 / 目录里没有…」菜单项并把输入框露出来，
+           * 2026-10-07 用户裁定删掉整条手填通道：来源与模型都只从宿主目录里选。
+           */
+          function modelSelectValue() {
+            if (!modal || modal.type !== 'editor') return ''
+            var f = modal.form
+            if (!f.model) return ''
+            return String(f.provider || '') + '\u0000' + String(f.model)
+          }
+          /**
+           * 存的 (来源, 模型) **不在**宿主目录里时，返回 `modelSelectValue()` 的那个值（多列一条
+           * 只读选项用）；在目录里、或模型为空时返回 ''。
+           *
+           * 为什么必须有这一条：0.19.0 之前这两个字段是纯文本框，现存人设里就有目录外的值；
+           * 下拉里找不到对应项时浏览器会显示第一项（「继承主会话」）—— **表单在说谎**，而保存时
+           * 又把那个看不见的值写回去。多列一条带标记的选项，值就永远看得见。
+           */
+          function offCatalogModel() {
+            if (!modal || modal.type !== 'editor') return ''
+            var f = modal.form
+            if (!f.model) return ''
+            var provider = String(f.provider || '')
+            var hit = (cand.models || []).filter(function (m) { return m.provider === provider && m.id === f.model })[0]
+            return hit ? '' : modelSelectValue()
+          }
+          /** 「模型来源」下拉的当前值 —— 就是存的来源本身（目录外的靠 `offCatalogProvider()` 显示）。 */
+          function providerSelectValue() {
+            if (!modal || modal.type !== 'editor') return ''
+            return String(modal.form.provider || '')
+          }
+          /** 存的来源不在宿主目录里时返回它（多列一条只读选项用）；在目录里或为空返回 ''。 */
+          function offCatalogProvider() {
+            if (!modal || modal.type !== 'editor') return ''
+            var v = String(modal.form.provider || '')
+            if (!v) return ''
+            var hit = (cand.providers || []).filter(function (p) { return p.id === v })[0]
+            return hit ? '' : v
+          }
+          /**
+           * 目录这次**真的读到了**吗。
+           *
+           * 「目录里没有」是一句断言，只有读成功才配说：读失败（`cand.error`）时清单是空的，
+           * 照断言会把"没读到"说成"不存在"。读不到时那条额外选项仍然渲染，只是不带标记。
+           */
+          function catalogReady() {
+            return !!(cand.loaded && !cand.loading && !cand.error)
+          }
+          /**
+           * 来源下拉的选项文字：显示名与 id 不同时两个都给（`DeepSeek · deepseek`）——
+           * 显示名给人看，id 是真正写进 frontmatter 的那个键，只给一个都算缺信息。
+           */
+          function providerLabel(p) {
+            var id = String((p && p.id) || '')
+            var name = String((p && p.name) || '')
+            return name && name !== id ? name + ' · ' + id : id
+          }
+          /**
+           * 模型下拉要列哪些模型：**来源选定后只列该来源的**（用户 2026-10-07）。
+           * 不按来源收窄时，一份几十条的扁平列表里选错来源是常态，而错配的 (来源, 模型) 要到
+           * 子代理真正启动时才由官方报错 —— 那时人已经在别的页面了。
+           * 来源留空则列全部：此时挑中哪一条，就把它的来源一并填上（见 onChange）。
+           */
+          function modelOptions() {
+            if (!modal || modal.type !== 'editor') return []
+            var all = cand.models || []
+            var p = modal.form.provider || ''
+            if (!p) return all
+            return all.filter(function (m) { return m.provider === p })
+          }
+          /** 模型选项文字：已按来源收窄时不再重复来源前缀（左边那一格就是来源）。 */
+          function modelOptionLabel(m) {
+            var narrowed = !!(modal && modal.type === 'editor' && modal.form.provider)
+            return narrowed ? String((m && (m.name || m.id)) || '') : m.provider + ' · ' + m.name
+          }
+          /**
+           * 「高级选项」收起态**第二行**的内容；返回 null = 这一行整个不出现。
+           * 只有真配了工具限制才报：收起态挂一句「模式限制：0 项；旧格式：白名单 0 / 黑名单 0」
+           * 是用一行废话占位置（用户 2026-10-07 指出）。
+           */
+          function advLimitLine() {
+            if (!modal || modal.type !== 'editor') return null
+            var modes = Object.keys(modal.form.toolsByPreset || {}).length
+            var allow = (modal.form.tools || []).length
+            var deny = (modal.form.toolsDeny || []).length
+            if (!modes && !allow && !deny) return null
+            return t('subagents.adv.summary2', {
+              modes: modes,
+              // 旧格式只在有值时报；分隔号写在词典值里（见 adv.summary 的 tail）。
+              tail: (allow || deny) ? t('subagents.adv.legacy', { allow: allow, deny: deny }) : '',
+            })
+          }
+          /**
+           * 官方四个预设的中英名走插件词典（官方 preset.yml 里只有中文名，直接用会让英文界面
+           * 露出中文）；**自建预设用它自己的名字，不翻译** —— 与官方 display 规则一致。
+           * 四个预设 id → 词典键的映射只认官方发布的这四个 id。
+           */
+          var SHIPPED_PRESET_IDS = { minimal: 1, standard: 1, ptc: 1, cordis: 1 }
+          function presetLabel(p) {
+            if (!p) return ''
+            var id = String(p.id || '')
+            if (SHIPPED_PRESET_IDS[id] === 1 && String(p.trust || 'system') !== 'user') return t('preset.name.' + id)
+            return String(p.name || id)
+          }
+          /**
+           * 该模式下可勾选的工具名 + 每个名字的归属组。
+           * `null` = 宿主没给出该模式的清单（读不到，不能假装是空）。
+           *
+           * `groups` 缺项（老服务端没这个字段）时按 `other` 处理 —— 落错组只是位置不对，
+           * 丢掉就是"界面上勾不到"，那是静默降级。
+           */
+          function modeTools(id) {
+            var hit = (cand.presets || []).filter(function (p) { return p.id === id })[0]
+            if (!hit || !Array.isArray(hit.tools)) return null
+            return { names: hit.tools, groups: hit.toolGroups || {} }
+          }
+          /** 三组的固定顺序：本插件 → 官方 → 其他。顺序即语义，别按字典序排。 */
+          var TOOL_ORIGINS = ['plugin', 'official', 'other']
+          function modeRule(id) { return (modal.form.toolsByPreset || {})[id] }
+          function setModeRule(id, rule) {
+            var next = Object.assign({}, modal.form.toolsByPreset || {})
+            if (rule) next[id] = rule; else delete next[id]
+            setModal(Object.assign({}, modal, {
+              form: Object.assign({}, modal.form, { toolsByPreset: next }),
+              openMode: modal.openMode === id && !rule ? null : modal.openMode,
+            }))
+          }
+          /** 模式行上的一句话状态：未开启 / 白名单 N 个 / 黑名单 N 个 / 已开启但没勾（= 不限制）。 */
+          function modeSummary(id) {
+            var rule = modeRule(id)
+            if (!rule) return { text: t('subagents.mode.off'), cls: 'dsm-mode-off' }
+            var n = (rule.names || []).length
+            if (!n) return { text: t('subagents.mode.empty'), cls: 'dsm-mode-off' }
+            return {
+              text: t(rule.mode === 'deny' ? 'subagents.mode.denyOn' : 'subagents.mode.allowOn', { count: n }),
+              cls: rule.mode === 'deny' ? 'dsm-mode-deny' : 'dsm-mode-allow',
+            }
+          }
+          /**
+           * 启动某一侧名单：生效 + 就地展开。同一模式内白/黑互斥 —— 启动一侧就把模式切过去，
+           * **已勾选的名字保留**（只换语义），这样"改成黑名单"不用从头再勾一遍。
+           */
+          function startMode(id, mode) {
+            // 刚被「关闭」掉的名字记在 stoppedRules 里：重新启用时带回，免得"关一下再开"把
+            // 已勾好的名单清空（用户实测踩到：以为「关闭白名单」是收起设置，再启用就空了）。
+            var prev = modeRule(id) || (modal.stoppedRules || {})[id]
+            var names = prev && Array.isArray(prev.names) ? prev.names.slice() : []
+            setModal(Object.assign({}, modal, {
+              openMode: id, modeQuery: '',
+              form: Object.assign({}, modal.form, {
+                toolsByPreset: Object.assign({}, modal.form.toolsByPreset || {}, { [id]: { mode: mode, names: names } }),
+              }),
+            }))
+          }
+          function stopMode(id) {
+            var prev = modeRule(id)
+            var stopped = Object.assign({}, modal.stoppedRules || {})
+            if (prev) stopped[id] = { mode: prev.mode, names: (prev.names || []).slice() }
+            var next = Object.assign({}, modal.form.toolsByPreset || {})
+            delete next[id]
+            setModal(Object.assign({}, modal, {
+              stoppedRules: stopped,
+              openMode: modal.openMode === id ? null : modal.openMode,
+              form: Object.assign({}, modal.form, { toolsByPreset: next }),
+            }))
+          }
+          function toggleModeTool(id, name) {
+            var rule = modeRule(id)
+            if (!rule) return
+            setModeRule(id, { mode: rule.mode, names: toggled(rule.names || [], name) })
+          }
+          /**
+           * 展开后的勾选区：只列**该模式自己的**工具，并按归属分三段
+           * （插件工具 / 官方工具 / 其他工具）。这样勾出来的名字天然都属于这个预设，
+           * 不会出现"在标准模式勾了只属于 PTC 的工具 → 换模式跑就启动失败"。
+           * MCP 工具不在这里（用户裁定）：子代理照旧能用当前在跑的 MCP，那份名单在运行时并入。
+           *
+           * 分组只是地标，**不改变勾选语义**：三段共用一个 `picked`，「全选 / 取消全选」仍跨组
+           * 对整份清单生效；空组不渲染，筛选后为空的组也不渲染。地标复用 `segGroup`（左内缩与
+           * `.dsm-pick` 同为 8px，天然对齐，所以不新增样式）。
+           *
+           * ⚠️ 分组买的是「一眼看出这是谁的东西」，不是「更快找到某个工具」—— 后者是上面那个
+           * 筛选框的活，分组不减少滚动量。
+           */
+          function modeEditor(p) {
+            var id = p.id
+            var rule = modeRule(id)
+            if (!rule) return null
+            var view = modeTools(id)
+            var all = view ? view.names : null
+            if (all === null || all.length === 0) {
+              return React.createElement('div', { className: 'dsm-mode-body' },
+                React.createElement('div', { className: 'dsm-pick-empty' }, p.broken ? t('subagents.mode.broken') : t('subagents.mode.noTools')))
+            }
+            var q = String(modal.modeQuery || '').trim().toLowerCase()
+            var list = q ? all.filter(function (n) { return n.toLowerCase().indexOf(q) >= 0 }) : all
+            var picked = rule.names || []
+            // 与其余「全选」同一口径：全勾了就只给「取消全选」（二合一，不并列）。
+            var allPickedAll = all.length > 0 && all.every(function (n) { return picked.indexOf(n) >= 0 })
+            // 按归属切段。认不出的归属（服务端没给这一项，或给了个没见过的值）一律落「其他」——
+            // 落错组只是位置不对，丢掉就是"界面上勾不到"。
+            var byOrigin = { plugin: [], official: [], other: [] }
+            list.forEach(function (name) {
+              var origin = view.groups[name]
+              byOrigin[origin === 'plugin' || origin === 'official' ? origin : 'other'].push(name)
+            })
+            var grid = []
+            TOOL_ORIGINS.forEach(function (origin) {
+              var names = byOrigin[origin]
+              if (!names.length) return
+              grid.push(segGroup(t('subagents.tools.group.' + origin)))
+              names.forEach(function (name) {
+                grid.push(pickRow({ key: 'm:' + id + ':' + name, disabled: busy, checked: picked.indexOf(name) >= 0, name: name, onChange: function () { toggleModeTool(id, name) } }))
+              })
+            })
+            return React.createElement('div', { className: 'dsm-mode-body' },
+              picked.length
+                ? React.createElement('div', { className: 'dsm-tools-chips' }, picked.map(function (name) {
+                    return React.createElement('span', { key: 'c:' + name, className: 'dsm-chip' + (rule.mode === 'deny' ? ' dsm-chip-deny' : '') },
+                      name,
+                      React.createElement('button', { type: 'button', title: t('subagents.tools.remove'), onClick: function () { toggleModeTool(id, name) } }, '×'))
+                  }))
+                : React.createElement('span', { className: 'dsm-adv-note' }, t(rule.mode === 'deny' ? 'subagents.mode.denyEmpty' : 'subagents.mode.allowEmpty')),
+              React.createElement('div', { className: 'dsm-combo-row' },
+                React.createElement('input', {
+                  className: 'dsm-control',
+                  value: modal.modeQuery || '',
+                  placeholder: t('subagents.tools.filter'),
+                  onChange: function (e) { setModal(Object.assign({}, modal, { modeQuery: e.target.value })) },
+                }),
+                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary dsm-btn-bulk', disabled: busy, onClick: function () { setModeRule(id, { mode: rule.mode, names: allPickedAll ? [] : all.slice() }) } }, bulkPair(allPickedAll ? t('bulk.unselectAll') : t('bulk.selectAll'), allPickedAll ? t('bulk.selectAll') : t('bulk.unselectAll')))),
+              list.length
+                ? React.createElement('div', { className: 'dsm-tools-grid' }, grid)
+                : React.createElement('div', { className: 'dsm-pick-empty' }, t('scenes.mem.noMatch')))
+          }
+          /**
+           * 一行一个 Agent 预设（roster 顺序：标准 / PTC / 极简 / 创造 / 自建预设）。
+           * 默认全部折叠、全部未启动；右侧两个按钮「启动 白名单」「启动 黑名单」互斥。
+           *
+           * 不再自带标题与说明（0.19.0 重排）：标题由所在分组头承担（`subagents.adv.group.tools`），
+           * 白/黑名单语义与「MCP 工具不在候选里」那一行移到分组头正下方。这两句原先挂在字段尾巴上，
+           * 叠上另外几处提示后，展开态读起来是一堵墙（用户 2026-10-07 指出）。
+           */
+          function modeRows() {
+            var presets = (cand.presets || []).slice()
+            if (!presets.length) {
+              return React.createElement('div', { className: 'dsm-pick-empty' }, cand.loading ? t('memory.loading') : t('subagents.mode.noPresets'))
+            }
+            return React.createElement('div', null,
+              React.createElement('div', { className: 'dsm-modes' }, presets.map(function (p) {
+                var id = p.id
+                var rule = modeRule(id)
+                var summary = modeSummary(id)
+                var startButton = function (mode, isDeny) {
+                  var active = !!rule && rule.mode === mode
+                  return React.createElement('button', {
+                    key: mode,
+                    type: 'button',
+                    className: 'dsm-btn dsm-btn-quiet' + (active ? (mode === 'deny' ? ' dsm-mode-btn-deny' : ' dsm-mode-btn-allow') : ''),
+                    disabled: busy,
+                    onClick: function () { if (active) stopMode(id); else startMode(id, mode) },
+                  }, t(active
+                    ? (isDeny ? 'subagents.mode.stopDeny' : 'subagents.mode.stopAllow')
+                    : (isDeny ? 'subagents.mode.startDeny' : 'subagents.mode.startAllow')))
+                }
+                var open = modal.openMode === id
+                return React.createElement('div', { className: 'dsm-mode-row' + (rule ? ' dsm-mode-on' : ''), key: id },
+                  React.createElement('div', { className: 'dsm-mode-head' },
+                    // 行首按钮 = 展开 / 收起名单（用户实测：已配好的模式只有「关闭白名单」可点，
+                    // 点下去是把模式停掉、名单设置再也进不去 —— 查看/编辑与启用/停用必须分开）。
+                    React.createElement('button', {
+                      type: 'button',
+                      className: 'dsm-mode-head-main',
+                      disabled: !rule,
+                      title: rule ? t('subagents.mode.toggleHint') : '',
+                      'aria-expanded': open ? 'true' : 'false',
+                      onClick: function () {
+                        setModal(Object.assign({}, modal, { openMode: open ? null : id, modeQuery: '' }))
+                      },
+                    },
+                      React.createElement('span', { className: 'dsm-mode-caret', 'aria-hidden': 'true' }, rule ? (open ? '▾' : '▸') : ''),
+                      React.createElement('span', { className: 'dsm-mode-name' }, presetLabel(p)),
+                      p.broken ? React.createElement('span', { className: 'dsm-tag dsm-tag-off' }, t('compat.reach.broken')) : null,
+                      React.createElement('span', { className: 'dsm-mode-sum ' + summary.cls }, summary.text)),
+                    React.createElement('span', { className: 'dsm-mode-actions' },
+                      startButton('allow', false),
+                      startButton('deny', true))),
+                  open ? modeEditor(p) : null)
+              })))
+          }
+          /**
+           * 旧格式（全局 `tools:` / `toolsDeny:`）的只读小结 + 转换入口。
+           * 旧键对所有模式生效，运行时仍然照旧执行；**不点转换就不动文件里的旧键**。
+           */
+          function legacyNotice() {
+            var allow = modal.form.tools || []
+            var deny = modal.form.toolsDeny || []
+            if (!allow.length && !deny.length) return null
+            var presets = cand.presets || []
+            var target = modal.legacyTarget || (presets[0] ? presets[0].id : '')
+            return React.createElement('div', { className: 'dsm-legacy' },
+              React.createElement('span', { className: 'dsm-adv-note' }, t('subagents.legacy.note', { allow: allow.length, deny: deny.length })),
+              React.createElement('div', { className: 'dsm-combo-row' },
+                React.createElement('div', { className: 'dsm-select' },
+                  React.createElement('select', {
+                    className: 'dsm-control',
+                    value: target,
+                    disabled: busy || !presets.length,
+                    onChange: function (e) { setModal(Object.assign({}, modal, { legacyTarget: e.target.value })) },
+                  }, presets.map(function (p) { return React.createElement('option', { key: p.id, value: p.id }, presetLabel(p)) }))),
+                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-quiet', disabled: busy || !target || !presets.length, onClick: function () {
+                  var rule = { mode: allow.length ? 'allow' : 'deny', names: (allow.length ? allow : deny).slice() }
+                  setModal(Object.assign({}, modal, {
+                    openMode: target,
+                    modeQuery: '',
+                    legacyTarget: target,
+                    form: Object.assign({}, modal.form, {
+                      tools: [], toolsDeny: [],
+                      toolsByPreset: Object.assign({}, modal.form.toolsByPreset || {}, { [target]: rule }),
+                    }),
+                  }))
+                } }, t('subagents.legacy.convert'))),
+              React.createElement('p', { className: 'dsm-help' }, t('subagents.legacy.hint')))
+          }
+          function toggleAdvanced() {
+            if (!modal || modal.type !== 'editor') return
+            var next = !modal.advanced
+            setModal(Object.assign({}, modal, { advanced: next }))
+            if (next) {
+              loadCandidates()
+              // 档位清单与候选目录**分开拉**：候选是本地目录（一次性），档位要问 adapter
+              // （按模型、可能联网），所以这里用表单里当前的模型去拉；没选模型就什么都不发。
+              loadEfforts(modal.form.provider, modal.form.model)
+            }
+          }
+          function submitEditor() {
+            if (!modal || modal.type !== 'editor') return
+            setBusy(true)
+            var op = modal.mode === 'create' ? 'subagent-create' : 'subagent-update'
+            // 编辑时名字可改：nextName 只在真的改过时才传（服务端按原名定位文件）。
+            var renamed = modal.mode === 'edit' && modal.originalName && modal.originalName !== modal.form.name
+            apiCall(op, {
+              name: renamed ? String(modal.originalName) : modal.form.name,
+              ...(renamed ? { nextName: String(modal.form.name || '').trim() } : {}),
+              description: modal.form.description,
+              provider: modal.form.provider, model: modal.form.model,
+              catalogDepth: modal.form.catalogDepth,
+              continuable: modal.form.continuable === true,
+              // 旧格式的全局名单原样回写（旧键不点转换就不动），新模式名单另存一块。
+              tools: modal.form.tools || [], toolsDeny: modal.form.toolsDeny || [],
+              toolsByPreset: modal.form.toolsByPreset || {},
+              body: modal.form.body,
+              output: modal.form.output || '',
+            }).then(function (res) {
+              setBusy(false)
+              if (res && res.ok) { var sw = stateSyncWarn(t, res); setModal(null); setResult({ ok: !sw, warning: !!sw, text: t('subagents.result.saved', { name: modal.form.name }) + (sw ? ' ' + sw : '') }); refresh(true) }
+              else setModal(Object.assign({}, modal, { form: Object.assign({}, modal.form, { error: translateError(t, res) }) }))
+            }).catch(function (e) { setBusy(false); setModal(Object.assign({}, modal, { form: Object.assign({}, modal.form, { error: errMsg(e) }) })) })
+          }
+          function submitDelete(name) {
+            setBusy(true)
+            apiCall('subagent-delete', { name: name }).then(function (res) {
+              setBusy(false); setModal(null)
+              if (res && res.ok) { var sw = stateSyncWarn(t, res); setResult({ ok: !sw, warning: !!sw, text: t('subagents.result.deleted', { name: name }) + (sw ? ' ' + sw : '') }); refresh(true) }
+              else setResult({ ok: false, text: translateError(t, res) })
+            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
+          }
+          // ── 导入人设（.md / .zip，多选或拖入；同名跳过并报告）──
+          function submitImport(files) {
+            if (!files || !files.length) return
+            setBusy(true)
+            apiCall('subagent-import', { files: files }).then(function (res) {
+              setBusy(false)
+              if (res && res.ok) {
+                setModal(null)
+                var names = res.imported || [], skipped = res.skipped || []
+                var text = names.length ? t('subagents.result.imported', { count: names.length, names: names.join('、') }) : t('import.none')
+                if (skipped.length) text += ' · ' + t('import.skipped', { items: skipped.map(function (s) { return s.name + '（' + s.reason + '）' }).join('；') })
+                var sw = stateSyncWarn(t, res)
+                if (sw) text += ' ' + sw
+                setResult({ ok: !sw, warning: !!sw, text: text }); refresh(true)
+              } else setResult({ ok: false, text: translateError(t, res) })
+            }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) })
+          }
+          // 过滤只跟数据与（防抖后的）搜索词有关：每次渲染重扫一整份列表没有必要。
+          // FLIP 的 key 仍是 `p.name`（过滤只改变"列表里有哪些"，不改变身份）。
+          var visibleSubagents = React.useMemo(function () {
+            return data.subagents.filter(function (p) { return matchPersonaQuery(p, dq) })
+          }, [data.subagents, dq])
+          // 「启用的排前面」（用户要求）：与过滤分开记忆 —— 只跟过滤结果有关，弹窗 / 结果提示条
+          // 之类的状态变化不再重跑分区。FLIP 的 data-flip-on 仍来自 p.enabled，未动。
+          var orderedSubagents = React.useMemo(function () {
+            return enabledFirst(visibleSubagents, function (p) { return p.enabled !== false; })
+          }, [visibleSubagents])
+          var limitedCount = React.useMemo(function () {
+            return data.subagents.filter(function (p) { return (p.tools && p.tools.length) || (p.toolsDeny && p.toolsDeny.length) || (p.toolsByPreset && Object.keys(p.toolsByPreset).length) }).length
+          }, [data.subagents])
+          return React.createElement('section', { className: 'dsm-section' },
+            React.createElement('div', { className: 'dsm-head' },
+              React.createElement('div', { className: 'dsm-title-block' },
+                React.createElement('div', { className: 'dsm-title-row' },
+                  React.createElement('h2', { className: 'dsm-title' }, t('subagents.title'))),
+                React.createElement('p', { className: 'dsm-desc' }, t('subagents.desc'))),
+              React.createElement('div', { className: 'dsm-actions' },
+                refreshButton(t, busy || data.loading, { className: 'dsm-btn dsm-btn-secondary', disabled: busy || data.loading, onClick: function () { refresh() } }),
+                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', disabled: busy || anyLocked, onClick: function () { openEditor(null) } }, t('subagents.new')),
+                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', disabled: busy || anyLocked, onClick: function () { setResult(null); setModal({ type: 'import' }) } }, t('subagents.import')),
+                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', disabled: busy || !data.subagents.length, onClick: function () { setResult(null); setModal({ type: 'export' }) } }, t('export.subagents')),
+                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-secondary', onClick: function () { loadTrash(false) } }, t('trash.btn.open')))),
+            anyLocked === true ? React.createElement('div', { className: 'dsm-feedback dsm-warning', role: 'status' }, t('lock.banner')) : null,
+            // 锁定期间不显示场景那条长句：开关全是灰的，"改动会同步写进档案"没有落点，
+            // 两条并排还会互相矛盾（用户 2026-09-19）。
+            (anyLocked !== true && sceneName) ? React.createElement('div', { className: 'dsm-feedback dsm-warning', role: 'status' }, t('scene.switch.banner', { scene: sceneName })) : null,
+            React.createElement('div', { className: 'dsm-summary', style: { '--dsm-stat-cols': '2' } },
+              [['total', data.subagents.length, t('subagents.stat.total')],
+                ['limited', limitedCount, t('subagents.stat.limited')]].map(function (item) {
+                return React.createElement('div', { key: item[0], className: 'dsm-stat' },
+                  React.createElement('strong', null, item[1]), item[2])
+              })),
+            // 搜索框：统计条之后（与 MCP / 技能 / 记忆 / 提示词页同一位置与样式）。
+            React.createElement('div', { className: 'dsm-filters' },
+              React.createElement('input', {
+                className: 'dsm-control dsm-search', value: query, 'aria-label': t('search'),
+                placeholder: t('subagents.search.placeholder'),
+                onChange: function (e) { setQuery(e.target.value) },
+              })),
+            React.createElement(Notice, { kind: result && result.warning ? 'warn' : result && result.ok ? 'ok' : 'err', text: result && result.text }),
+            // 走 Notice 而不是裸 div：令牌没过的提醒会在右侧自动多出一颗「填写令牌」按钮。
+            data.error ? React.createElement(Notice, { kind: 'err', text: String(data.error) }) : null,
+            // 注册失败的工具（`subagent_manager_list` / `_run`）：模型侧只会「查无此工具」，
+            // 这条横幅是用户唯一能看到的地方。名字与原因来自服务端，句子在这里按当前语言拼。
+            (data.toolFailures || []).length ? React.createElement(Notice, {
+              kind: 'warn',
+              text: t('subagents.toolFailed', {
+                names: (data.toolFailures || []).map(function (f) { return f.name }).join('、'),
+                reason: String(((data.toolFailures || [])[0] || {}).reason || ''),
+              }),
+            }) : null,
+            data.loading && !data.subagents.length ? React.createElement('div', { className: 'dsm-empty' }, t('memory.loading'))
+              : !data.subagents.length ? React.createElement('div', { className: 'dsm-empty' }, t('subagents.empty'))
+                : !visibleSubagents.length ? React.createElement('div', { className: 'dsm-empty' }, t('subagents.empty.search'))
+                  : React.createElement('div', { className: 'dsm-sources', ref: flipRef }, orderedSubagents.map(function (p) {
+                return React.createElement('div', { key: p.name, className: 'dsm-source', 'data-flip-key': p.name, 'data-flip-on': p.enabled !== false ? '1' : '0' },
+                  React.createElement('div', { className: 'dsm-source-head' },
+                    React.createElement('div', { className: 'dsm-source-head-main dsm-persona-main' },
+                      React.createElement('div', { className: 'dsm-persona-name-row' },
+                        React.createElement('span', { className: 'dsm-source-title', title: p.name }, p.name),
+                        // 两个状态都给胶囊：以前只在停用时挂标签，启用的一行什么都不留，
+                        // 用户没法一眼看出「没标签 = 启用」。
+                        p.enabled === false
+                          ? React.createElement(StatusTag, { tone: 'muted', text: t('subagents.disabled'), title: t('subagents.disabled.hint') })
+                          : React.createElement(StatusTag, { tone: 'ok', text: t('subagents.enabled') })),
+                      // 没有描述就不渲染这一行：空 div 仍占一行行高，行会变成一条无内容的空隙。
+                      p.description ? React.createElement('div', { className: 'dsm-persona-desc', title: p.description }, p.description) : null),
+                    React.createElement('div', { className: 'dsm-source-actions' },
+                      React.createElement(Switch, { on: p.enabled !== false, disabled: busy || anyLocked, label: t('subagents.toggle') + ' ' + p.name, onClick: function () { togglePersona(p) } }),
+                      React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-quiet', disabled: busy || anyLocked, onClick: function () { openEditor(p.name) } }, t('memory.edit')),
+                      React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-quiet dsm-btn-danger', disabled: busy || anyLocked, onClick: function () { setModal({ type: 'delete', name: p.name }) } }, t('memory.delete')))))
+              })),
+            modal && modal.type === 'editor' ? React.createElement(Modal, { key: 'sedit', wide: true, title: modal.mode === 'create' ? t('subagents.create') : t('subagents.edit') + ' · ' + modal.form.name, closeLabel: t('btn.close'), onClose: function () { setModal(null) } },
+              React.createElement('div', { className: 'dsm-form' },
+                React.createElement('label', { className: 'dsm-field' },
+                  React.createElement('span', { className: 'dsm-label' }, t('subagents.field.name')),
+                  React.createElement('input', { className: 'dsm-control', value: modal.form.name || '', placeholder: 'code-review', onChange: function (e) { setForm({ name: e.target.value }) } })),
+                React.createElement('label', { className: 'dsm-field' },
+                  // 描述会整段进「可委派的子智能体」目录，上限就是注入侧的截断长度（`CATALOG_DESC_MAX`）；
+                  // 存量人设的超长描述标红（服务端不校验这个长度，只有注入时截）。
+                  React.createElement('div', { className: 'dsm-budget-meta' },
+                    React.createElement('span', { className: 'dsm-label' }, t('subagents.field.description')),
+                    React.createElement('span', { className: 'dsm-char-count' + (String(modal.form.description || '').length > CATALOG_DESC_MAX ? ' dsm-char-over' : '') }, String(modal.form.description || '').length + ' / ' + CATALOG_DESC_MAX)),
+                  React.createElement('input', { className: 'dsm-control', value: modal.form.description || '', maxLength: CATALOG_DESC_MAX, placeholder: t('subagents.field.description.placeholder'), onChange: function (e) { setForm({ description: e.target.value }) } })),
+                React.createElement('label', { className: 'dsm-field' },
+                  React.createElement('span', { className: 'dsm-label' }, t('subagents.field.body')),
+                  React.createElement('textarea', { className: 'dsm-control dsm-textarea-md', value: modal.form.body || '', placeholder: t('subagents.field.body.placeholder'), onChange: function (e) { setForm({ body: e.target.value }) } })),
+                // 输出要求（frontmatter `output:`，一条一行）：单独成节写进子代理的系统提示词。
+                // 与正文分开是有意的 —— 正文是"这个角色是什么"（散文），这里放"产出必须长什么样"
+                // （可检验的硬要求）。混在一起时散文会把硬要求稀释成风格提示（用户实测）。
+                React.createElement('label', { className: 'dsm-field' },
+                  React.createElement('span', { className: 'dsm-label' }, t('subagents.field.output')),
+                  React.createElement('textarea', { className: 'dsm-control dsm-textarea-md', value: modal.form.output || '', placeholder: t('subagents.field.output.placeholder'), onChange: function (e) { setForm({ output: e.target.value }) } }),
+                  React.createElement('p', { className: 'dsm-help' }, t('subagents.field.output.hint'))),
+                // ── 高级选项（默认收起）──
+                // 模型 / 工具限制是「少数人才改」的字段，但一旦改错代价高（跨来源模型、工具名打错
+                // 会让子代理直接启动失败）。所以：收起来但**有值就自动展开**，并把候选做成选择器。
+                React.createElement('div', { className: 'dsm-adv' },
+                  React.createElement('button', { type: 'button', className: 'dsm-adv-head', 'aria-expanded': modal.advanced === true, onClick: toggleAdvanced },
+                    React.createElement('span', { className: 'dsm-adv-caret' }, modal.advanced ? '▼' : '▶'),
+                    React.createElement('span', { className: 'dsm-adv-title' }, t('subagents.adv.title')),
+                    modal.advanced ? null : React.createElement('span', { className: 'dsm-adv-note dsm-adv-sum' },
+                      // 摘要**最多两行，且只报有值的那几项**（用户 2026-10-07 定稿）：
+                      // 第一行是"下一次委派会怎么跑"（模型 / 思考强度 / 允许追问），
+                      // 第二行是工具限制的存量 —— 一项都没有时整行不渲染，不拿「0 项」占位置。
+                      // 目录注入不进摘要：它只决定目录出现在哪些会话，不影响委派本身。
+                      React.createElement('span', null, t('subagents.adv.summary', {
+                        model: modal.form.model ? (modal.form.provider ? modal.form.provider + '/' + modal.form.model : modal.form.model) : t('subagents.adv.inherit'),
+                        // 思考强度收起来也要看得见：它是"下一次委派会怎么跑"的一部分。
+                        // 没配时报「默认」而**不是**「继承」—— 官方语义里换模型会把继承来的那一档
+                        // 删掉（`dsh-subagent/lib/index.js:482`），报「继承」是句假话。
+                        effort: modal.form.reasoningEffort ? String(modal.form.reasoningEffort) : t('subagents.effort.none'),
+                        // 允许追问接在同一行尾巴上：它同样是"会怎么跑"，而且是**最容易忘**的一项
+                        // （结果变成异步回执）。分隔号写在词典值里，英文侧才不用跟着改代码。
+                        tail: modal.form.continuable === true ? t('subagents.adv.continuable') : '',
+                      })),
+                      advLimitLine() ? React.createElement('span', null, advLimitLine()) : null)),
+                  modal.advanced ? React.createElement('div', { className: 'dsm-adv-body' },
+                    // 三组：模型 / 运行方式 / 工具限制（0.19.0 重排）。重排前是五个字段平铺、
+                    // 九处提示文字混用三种形态（单行 dsm-help / 项目符号 / 选择器副标题），
+                    // 展开态读起来是一堵墙（用户 2026-10-07 裁定）。现在：分组头 + 一条细线划开；
+                    // 静态说明一律不进表单，只留**状态类**提示（拉取中 / 未选模型 / 拉不到 / 报错）。
+                    React.createElement('div', { className: 'dsm-adv-group' },
+                      React.createElement('div', { className: 'dsm-adv-group-head' }, t('subagents.adv.group.model')),
+                      // 模型来源与模型并排：官方把 (provider, model) 当一对解析，跨来源（如 sensenova）
+                      // 必须两个键同时给。顺序按解析顺序 —— 先来源，后模型。
+                      // 两个字段并排用 `.dsm-field-row`；`.dsm-combo-row` 是**字段内部**的
+                      // "下拉 + 它旁边的东西"（这里只剩下拉，`.dsm-combo-row .dsm-select{flex:1}`
+                      // 让它填满整格 —— 缺这条时下拉宽度由选项文字撑出，换来源后标签变短、框跟着缩）。
+                      React.createElement('div', { className: 'dsm-field-row' },
+                        // 模型来源：去重后的来源清单，只从宿主目录里选（手填通道 2026-10-07 删除）。
+                        // 换来源要重拉档位 —— 档位清单是按 (provider, model) 给的。
+                        // 换来源**不清模型**：清掉是"悄悄改掉用户已配好的值"，而留着会立刻显形 ——
+                        // 模型下拉找不到这对 (来源, 模型) 就多列一条带「目录里没有」标记的选项。
+                        React.createElement('div', { className: 'dsm-field' },
+                          React.createElement('span', { className: 'dsm-label' }, t('subagents.field.provider')),
+                          React.createElement('div', { className: 'dsm-combo-row' },
+                            React.createElement('div', { className: 'dsm-select' },
+                              React.createElement('select', {
+                                className: 'dsm-control',
+                                value: providerSelectValue(),
+                                disabled: busy || cand.loading,
+                                onChange: function (e) {
+                                  var v = e.target.value
+                                  setForm({ provider: v })
+                                  loadEfforts(v, modal.form.model || '')
+                                },
+                              },
+                                React.createElement('option', { value: '' }, t('subagents.provider.inherit')),
+                                (cand.providers || []).map(function (p) {
+                                  return React.createElement('option', { key: p.id, value: p.id }, providerLabel(p))
+                                }),
+                                // 目录外的旧值：列一条只读选项，值看得见、要改只能重选目录里的。
+                                offCatalogProvider()
+                                  ? React.createElement('option', { value: offCatalogProvider() },
+                                      catalogReady() ? t('subagents.field.offCatalog', { id: offCatalogProvider() }) : offCatalogProvider())
+                                  : null)))),
+                        // 模型：宿主 LLM 目录里的 (provider, model) 对，只从目录里选。
+                        React.createElement('div', { className: 'dsm-field' },
+                          React.createElement('span', { className: 'dsm-label' }, t('subagents.field.model')),
+                          React.createElement('div', { className: 'dsm-combo-row' },
+                            React.createElement('div', { className: 'dsm-select' },
+                              React.createElement('select', {
+                                className: 'dsm-control',
+                                value: modelSelectValue(),
+                                disabled: busy || cand.loading,
+                                onChange: function (e) {
+                                  var v = e.target.value
+                                  if (v === '') { setForm({ provider: '', model: '' }); loadEfforts('', '') }
+                                  else {
+                                    var parts = v.split('\u0000')
+                                    setForm({ provider: parts[0], model: parts[1] })
+                                    // 档位跟模型走：换模型必须重拉（缓存命中时是同步的，不会闪）。
+                                    loadEfforts(parts[0], parts[1])
+                                  }
+                                },
+                              },
+                                React.createElement('option', { value: '' }, t('subagents.model.inherit')),
+                                modelOptions().map(function (m) {
+                                  return React.createElement('option', { key: m.provider + '/' + m.id, value: m.provider + '\u0000' + m.id }, modelOptionLabel(m))
+                                }),
+                                // 目录外的旧值：同来源那条，列一条只读选项。
+                                offCatalogModel()
+                                  ? React.createElement('option', { value: offCatalogModel() },
+                                      catalogReady() ? t('subagents.field.offCatalog', { id: modal.form.model }) : modal.form.model)
+                                  : null))),
+                          // 目录还在读时给一行状态；读完了不占行 —— 这里原来放的是"留空继承主会话"
+                          // 那句静态说明，已随 0.19.0 重排移出表单。
+                          cand.loading ? React.createElement('p', { className: 'dsm-help' }, t('memory.loading')) : null)),
+                      // 思考强度：值就是 adapter 给的档位 id（不校验合法性，官方在 provider I/O 前会拒）。
+                      // 单独占左半列（`.dsm-adv-half`），与上一行的列边界对齐。
+                      React.createElement('div', { className: 'dsm-field dsm-adv-half' },
+                        React.createElement('span', { className: 'dsm-label' }, t('subagents.field.effort')),
+                        React.createElement('div', { className: 'dsm-select' },
+                          React.createElement('select', {
+                            className: 'dsm-control',
+                            value: String(modal.form.reasoningEffort || ''),
+                            disabled: busy || eff.loading || !modal.form.model,
+                            onChange: function (e) { setEffNotice(null); setForm({ reasoningEffort: e.target.value }) },
+                          },
+                            React.createElement('option', { value: '', title: defaultEffortTitle() }, t('subagents.effort.default')),
+                            currentEfforts().map(function (x) {
+                              return React.createElement('option', { key: x.id, value: x.id, title: x.description || undefined }, x.name)
+                            }))),
+                        // 状态行只在"这一格为什么用不了 / 没有档位"的四种情况下出现；有档位可选时
+                        // 这一行不存在 —— 原来这里常驻的是"当前可选择多种思考强度"那句同义反复。
+                        !modal.form.model || eff.loading || eff.error || !currentEfforts().length
+                          ? React.createElement('p', { className: 'dsm-help' },
+                              !modal.form.model
+                                ? t('subagents.effort.needModel')
+                                : eff.loading
+                                  ? t('subagents.effort.loading')
+                                  : eff.error
+                                    ? String(eff.error)
+                                    : t('subagents.effort.unavailable'))
+                          : null,
+                        effNotice ? React.createElement('p', { className: 'dsm-feedback dsm-warning' }, effNotice) : null)),
+                    // ── 运行方式：这份人设"什么时候跑、跑在哪些会话里" ──
+                    React.createElement('div', { className: 'dsm-adv-group' },
+                      React.createElement('div', { className: 'dsm-adv-group-head' }, t('subagents.adv.group.runtime')),
+                      // 目录注入深度：人设目录注入到哪些会话（默认 1 = 只在顶层）。用下拉而不是数字
+                      // 输入：只有 1/2/3 三个有意义的档，手写数字写错要到注入时才暴露。
+                      //
+                      // ⚠️ 它**不是**递归上限。2026-09-17 用户实测后改名（原名 maxDepth /「委派预算」）：
+                      // 官方 `dsh-tool-subagent` 默认 `maxDepth: 3`，子代理本来就能继续嵌套，本插件
+                      // 也不再向官方传 maxDepth。这个字段只决定常驻目录出现在哪些深度的会话里。
+                      React.createElement('label', { className: 'dsm-field dsm-adv-half' },
+                        React.createElement('span', { className: 'dsm-label' }, t('subagents.field.catalogDepth')),
+                        React.createElement('div', { className: 'dsm-select' },
+                          React.createElement('select', {
+                            className: 'dsm-control',
+                            value: String(typeof modal.form.catalogDepth === 'number' ? modal.form.catalogDepth : 1),
+                            disabled: busy,
+                            onChange: function (e) { setForm({ catalogDepth: Number(e.target.value) }) },
+                          }, [1, 2, 3, CATALOG_DEPTH_UNLIMITED].map(function (n) {
+                            // 选项文字不带序号：前面再加一个「2 ·」是同一件事说两遍（用户 2026-09-17
+                            // 指出）。下拉的 value 仍是数字，存的还是 catalogDepth 本身。
+                            return React.createElement('option', { key: n, value: String(n) }, catalogDepthLabel(n))
+                          })))),
+                      // 允许追问（frontmatter `continuable: true`）：这条通道的**产出是异步的** ——
+                      // 委派只回执一个 agent id，子代理在后台跑、完成后自己把结果发回来，
+                      // 之后可以用宿主自带的 `send_message` 追问、`interrupt_agent` 中止。
+                      // 默认关：它占用宿主"可继续子代理"的名额（`maxActiveSubagents`，默认 8），
+                      // 且要求宿主加载了持久化与 session query 两个服务。
+                      // 机制与代价的完整说明记在 CHANGELOG / README，不进表单（0.19.0 重排）。
+                      React.createElement('label', { className: 'dsm-pick' },
+                        React.createElement('input', { type: 'checkbox', checked: modal.form.continuable === true, disabled: busy, onChange: function (e) { setForm({ continuable: e.target.checked === true }) } }),
+                        React.createElement('span', { className: 'dsm-pick-main' },
+                          React.createElement('span', { className: 'dsm-pick-name' }, t('subagents.field.continuable')),
+                          React.createElement('span', { className: 'dsm-pick-desc' }, t('subagents.field.continuable.short'))))),
+                    // ── 工具限制：按 Agent 预设一行一个模式（默认全折叠、全部未启动，白/黑互斥）。
+                    // 旧格式的全局名单（老文件 / 别处导入）在这里只读呈现，点「转换」才搬进某个模式。
+                    React.createElement('div', { className: 'dsm-adv-group' },
+                      React.createElement('div', { className: 'dsm-adv-group-head' }, t('subagents.adv.group.tools')),
+                      // 这是整块里唯一留下的静态说明，两条理由：它回答"这一屏会不会生效"，
+                      // 而且藏着一条反直觉的事实（MCP 工具不在候选里）—— 删掉会让人以为能限制 MCP。
+                      // 白/黑名单语义那三句已移出表单（词面自解释，按钮与模式摘要里都在用）。
+                      React.createElement('p', { className: 'dsm-help' }, t('subagents.field.modes.hint')),
+                      legacyNotice(),
+                      modeRows()),
+                    cand.error ? React.createElement('div', { className: 'dsm-feedback dsm-warning' }, String(cand.error)) : null)
+                    : null),
+                modal.form.error ? React.createElement('div', { className: 'dsm-feedback dsm-error', role: 'alert' }, String(modal.form.error)) : null),
+              React.createElement('div', { className: 'dsm-modal-actions' },
+                React.createElement('button', { type: 'button', className: 'dsm-btn', disabled: busy || (modal.mode === 'create' && !String(modal.form.name || '').trim()) || !String(modal.form.body || '').trim(), onClick: submitEditor }, t('memory.btn.save')))) : null,
+            modal && modal.type === 'delete' ? React.createElement(Modal, { key: 'sdel2', title: t('subagents.delete.title'), closeLabel: t('btn.close'), onClose: function () { setModal(null) } },
+              React.createElement('p', { className: 'dsm-help' }, t('subagents.delete.desc', { name: modal.name })),
+              React.createElement('div', { className: 'dsm-modal-actions' },
+                React.createElement('button', { type: 'button', className: 'dsm-btn dsm-btn-danger', disabled: busy, onClick: function () { submitDelete(modal.name) } }, t('memory.btn.delete.confirm')))) : null,
+            modal && modal.type === 'import' ? React.createElement(ImportModal, { key: 'simp', t: t, title: t('subagents.import.title'), busy: busy, requirements: [t('upload.requirement.persona.1'), t('upload.requirement.persona.2'), t('upload.requirement.persona.3')], onClose: function () { setModal(null) }, onSubmit: submitImport }) : null,
+            modal && modal.type === 'export' ? React.createElement(ExportModal, {
+              key: 'export', t: t, title: t('export.subagents'),
+              items: data.subagents.map(function (p) { return { key: p.name, name: p.name, desc: p.description || '' } }),
+              busy: busy, result: result,
+              onClose: function () { setResult(null); setModal(null) },
+              onSubmit: function (names, outDir) {
+                setBusy(true); setResult(null);
+                apiCall('bundle-export', { kind: 'subagents', names: names, outDir: outDir }).then(function (res) {
+                  setBusy(false);
+                  if (res && res.ok) setResult({ ok: true, text: exportResultText(t, res) });
+                  else setResult({ ok: false, text: translateError(t, res) });
+                }).catch(function (e) { setBusy(false); setResult({ ok: false, text: errMsg(e) }) });
+              },
+            }) : null,
+            trash ? React.createElement(TrashModal, {
+              t: t,
+              title: t('trash.title'),
+              groupTitle: t('trash.group.agents'),
+              groupSub: t('trash.section.agents.sub'),
+              locked: anyLocked,
+              entries: trash.entries,
+              loading: trash.loading,
+              error: trash.error,
+              busy: trashBusy,
+              onClose: function () { setTrash(null) },
+              onRestore: restorePersona,
+              onPurge: purgePersona,
+            }) : null)
+        }
+
+        /**
+         * 记忆页的视图（按场景分桶 + 过滤 + 排序）。
+         *
+         * 提到组件外是为了能被 `useMemo` 包住：这段要遍历全部记忆并逐桶排序，而本页的
+         * 编辑器弹窗每敲一个字都会重渲染整页（`editor` 是页内 state）。传进来的 `q` 已防抖。
          */
         function memoryView(data, q, sceneFilter) {
           function matchRule(r) {