dsh-armory 1.9.1 → 1.9.3

package/README.en.md

@@ -25,7 +25,7 @@ dsh plugin --profile web add dsh-armory
 dsh plugin --profile web add github:2026heshao/dsh-armory
 ```
 
-Restart DSH, then open **Skills · MCP · Experts** from the global panel list at the top of the sidebar (or the floating button bottom-right). Desktop users on the `desktop` profile: swap `--profile web` for `--profile desktop`. You can also search `armory` and one-click install inside [dsh-market](https://github.com/dsh-market/dsh-market#readme).
+Restart DSH, then open **Skills · MCP · Experts** from the global panel list at the top of the sidebar (or the floating button bottom-right). Desktop users on the `desktop` profile: swap `--profile web` for `--profile desktop`.
 
 ## What it solves
 
@@ -84,6 +84,11 @@ A **unified board** for DeepSeek Harness (Web and desktop): five top-level tabs
   - **Summoning** = appending one independent **agent preset** row to the profile patch (a `@deepseek-ai/dsh-agent-preset` entry that mirrors the built-in `standard` preset, with only the persona prefix swapped for the expert's full persona). New sessions then offer **WorkBuddy Expert · …** and that expert takes over the session, while the standard tools / planning / compaction / delegation stay intact. Multiple experts coexist; writes go through the existing patch pipeline (file lock + version check + atomic write), preserving other rows, comments and `!!js` expressions
   - **Bundled skills**: tick to install them too — a full local WorkBuddy cache (`~/.workbuddy/plugins/cache/experts/`) is copied wholesale into `~/.agents/skills/` (prefixed `wbexpert__`, discovered by the skill registry immediately); without a cache it falls back to the CDN's single `SKILL.md` and labels the source honestly
   - **Dismissing** removes that preset and its skill directory (hot-reloaded, no restart); team-type experts (expert team) are read-only for now
+- **Summon menu (in-session quick access, enhanced in 1.9.3)** — the small board icon at the right of the composer toolbar opens three categories (**Skills / MCP / Experts**); hovering a category expands its submenu, and clicking an entry writes a reference into the composer (skills = `/skill-name`, MCP = names the `mcp__server__*` tools, experts = attaches to the current session):
+  - **Six rows per screen, scrollable**: a submenu shows six entries at a time and scrolls for the rest (thin themed scrollbar), while the **Manage skills / MCP / experts…** button stays pinned to the bottom instead of scrolling away
+  - **Most-recently-used first**: entries you just used float to the top with a "recent" badge, the rest keep their original order; the recency pool holds 40 entries
+  - **Experts attach / swap / detach at any time**: click one to take over the current session (including one already mid-conversation), click another to replace it, click the chip's × to drop it. It affects **only that session** — no tool catalog changes, nothing persisted
+  - **What you see is what's active**: once an expert is attached, the session header shows the expert that is **actually in effect** (the host's "preset chosen at session creation" label steps aside while an expert is attached); the header badge, the composer chip and the menu stay in sync within the same frame after attach / swap / detach
 - Import MCP configuration from other clients installed on this machine: Claude Code, Codex (`config.toml`), OpenCode (including `.jsonc`), pi, Claude Desktop, Cursor, Windsurf, VS Code, Gemini CLI, Roo Code, and the cross-tool shared config. Everything is previewed before writing, with "merge" and "replace" modes
 - Follows the DSH dark/light theme and adapts to narrow/mobile widths
 - Update notice and **one-click upgrade**: a dismissible banner when a newer release exists (at most one check per day; disable with `DSH_ARMORY_DISABLE_UPDATE_CHECK`). Nothing happens until you press Upgrade — it **never auto-updates**; the upgrade itself is executed by DSH's official pluginManager, which handles version checks and rollback. Local dev copies installed via `link:` / `file:` / `github:` get no button (it would replace your link with an npm package)

package/README.md

@@ -25,7 +25,7 @@ dsh plugin --profile web add dsh-armory
 dsh plugin --profile web add github:2026heshao/dsh-armory
 ```
 
-装完**重启 DSH**，侧栏顶部「全局面板」里点 **技能 · MCP · 专家**（或右下角悬浮按钮）。桌面端装在 `desktop` profile 时把 `--profile web` 换成 `--profile desktop`。也可以在装了 [dsh-market](https://github.com/dsh-market/dsh-market#readme) 的 DSH 里搜 `armory` 一键安装。
+装完**重启 DSH**，侧栏顶部「全局面板」里点 **技能 · MCP · 专家**（或右下角悬浮按钮）。桌面端装在 `desktop` profile 时把 `--profile web` 换成 `--profile desktop`。
 
 ## 它解决什么
 
@@ -74,6 +74,11 @@ dsh plugin --profile web add github:2026heshao/dsh-armory
   - **召唤** = 往 profile 补丁写入一条**独立 Agent 预设**（`@deepseek-ai/dsh-agent-preset` 行，plugins 复刻内置 standard 预设、仅 persona 的 prefix 换成专家人设全文）——新建会话时选择「WorkBuddy 专家 · …」即专家接管该会话，标准工具/规划/压缩/委派原样保留；多个专家可共存，写入走既有 patch 写链（文件锁 + 版本校验 + 原子写），其余条目、注释与 `!!js` 表达式原样保留
   - **捆绑技能**：召唤时可勾选一并安装——本机 WorkBuddy 缓存（`~/.workbuddy/plugins/cache/experts/`）有完整技能树就整目录复制到 `~/.agents/skills/`（`wbexpert__` 前缀，即刻被技能注册表发现）；无缓存时按 CDN 的 SKILL.md 单文件兜底并如实标注来源
   - **送还** = 摘除该召唤预设与对应技能目录（热加载，无需重启）；团队型（expert team）暂只读展示
+- **召唤菜单（会话内快速调用，1.9.3 增强）**：会话输入框工具行右侧的看板小图标 → 「技能 / MCP / 专家」三分类，悬停展开子菜单，点一条即把引用写进输入框（技能 = `/技能名`、MCP = 点名 `mcp__服务__*`、专家 = 挂到当前会话）——
+  - **每屏 6 行 + 滚动**：子菜单一次显示 6 条，超出的往下滚（细滚动条跟随主题）；「管理技能 / MCP / 专家…」固定在底部，不被列表滚走
+  - **最近使用置顶**：刚用过的条目自动排到最前并带「最近」标记，其余保持原有顺序；最近使用记录池 40 条
+  - **专家随时挂 / 换 / 摘**：点一个专家即接管当前会话（包括已经聊了一半的），再点别的直接替换，点 chip 的 × 立刻取消；**只影响这一个会话**，不动工具目录、不写任何持久化配置
+  - **显示与实效一致**：挂专家后，会话标题栏显示的始终是**当前真正生效**的专家（宿主那条「会话创建时的预设」标签在挂载期间自动让位）；三处显示（标题栏徽章、输入框 chip、菜单）挂/换/摘后同帧同步
 
 ## 安装
 

package/lib/client.js

@@ -352,32 +352,52 @@ const MCP_CSS = `body{--mcp-accent:var(--dsw-alias-brand-primary);--mcp-ok:var(-
 .dsh-mcp-quick-count{margin-left:auto;color:var(--mcp-accent);font-size:11px;font-variant-numeric:tabular-nums}
 .dsh-mcp-quick-arrow{margin-left:5px;color:var(--mcp-mut);font-size:11px}
 /* 子菜单：与锚点行垂直居中（top:50% + translateY(-50%)），比顶对齐更贴近 WorkBuddy；
-   出场动画只动 opacity/transform（动效克制），替代上一版「整块突现」的残影来源。 */
-.dsh-mcp-quick-sub{position:absolute;top:50%;left:calc(100% + 6px);z-index:951;width:216px;max-height:min(264px,40vh);overflow:auto;padding:5px;border:1px solid var(--mcp-line);border-radius:var(--mcp-r-lg);background:var(--mcp-bg-1);box-shadow:var(--dsw-elevation-overlay,0 8px 28px rgba(0,0,0,.14));transform:translateY(-50%);transform-origin:left center;animation:dshMcpQuickIn .13s ease-out}
+   出场动画只动 opacity/transform（动效克制），替代上一版「整块突现」的残影来源。
+   面板本体 max-height 由「6 行列表 + 底部固定管理按钮」精确算出（6×28 + 5×2 padding
+   + 30 按钮 + 4 间距 + 边框），列表自身滚动，管理按钮永远贴底可见。 */
+.dsh-mcp-quick-sub{position:absolute;top:50%;left:calc(100% + 6px);z-index:951;display:flex;flex-direction:column;width:232px;max-height:min(216px,40vh);padding:5px;border:1px solid var(--mcp-line);border-radius:var(--mcp-r-lg);background:var(--mcp-bg-1);box-shadow:var(--dsw-elevation-overlay,0 8px 28px rgba(0,0,0,.14));transform:translateY(-50%);transform-origin:left center;animation:dshMcpQuickIn .13s ease-out}
+/* 可滚动列表：最多 6 行（6 × 28px），溢出即滚动；隐藏水平溢出防止拖宽面板 */
+.dsh-mcp-quick-list{min-height:0;max-height:168px;overflow-y:auto;overflow-x:hidden;border-radius:var(--mcp-r-sm)}
+/* 细滚动条（跟随主题 token，悬停加深；hover 之外 6px 宽半透明，几乎不占视觉） */
+.dsh-mcp-quick-list{scrollbar-width:thin;scrollbar-color:color-mix(in srgb,var(--mcp-line) 90%,transparent) transparent}
+.dsh-mcp-quick-list::-webkit-scrollbar{width:6px}
+.dsh-mcp-quick-list::-webkit-scrollbar-track{background:transparent}
+.dsh-mcp-quick-list::-webkit-scrollbar-thumb{background:color-mix(in srgb,var(--mcp-line) 90%,transparent);border-radius:3px}
+.dsh-mcp-quick-list:hover::-webkit-scrollbar-thumb{background:color-mix(in srgb,var(--dsw-alias-label-tertiary) 45%,transparent)}
+.dsh-mcp-quick-list:focus-visible{outline:2px solid var(--mcp-accent);outline-offset:-1px}
 /* 视口下缘不够时 JS 加 flip：子菜单改为向锚点行上方展开 */
 .dsh-mcp-quick-row.flip .dsh-mcp-quick-sub{top:auto;bottom:50%;transform:translateY(50%)}
 .dsh-mcp-quick-row.flip .dsh-mcp-quick-sub{animation-name:dshMcpQuickInFlip}
 @keyframes dshMcpQuickIn{from{opacity:0;transform:translateY(-50%) translateX(-4px)}to{opacity:1;transform:translateY(-50%)}}
 @keyframes dshMcpQuickInFlip{from{opacity:0;transform:translateY(50%) translateX(-4px)}to{opacity:1;transform:translateY(50%)}}
 @media (prefers-reduced-motion: reduce){.dsh-mcp-quick-sub{animation:none}}
-.dsh-mcp-quick-sub.empty{padding:9px 11px;color:var(--mcp-mut);font-size:12px}
-.dsh-mcp-quick-sub-note{padding:6px 9px;color:var(--mcp-mut);font-size:11px}
-.dsh-mcp-quick-manage{display:flex;align-items:center;width:100%;margin-top:4px;padding:6px 9px;border:none;border-top:1px solid var(--mcp-line);border-radius:0 0 var(--mcp-r-sm) var(--mcp-r-sm);background:transparent;color:var(--mcp-accent);font-family:inherit;font-size:11px;text-align:left;cursor:pointer;transition:background .12s}
+.dsh-mcp-quick-sub.empty{display:block;padding:9px 11px;color:var(--mcp-mut);font-size:12px}
+.dsh-mcp-quick-sub-note{padding:6px 9px;color:var(--mcp-mut);font-size:11px;white-space:normal}
+.dsh-mcp-quick-manage{display:flex;align-items:center;flex:none;width:100%;margin-top:4px;padding:6px 9px;border:none;border-top:1px solid var(--mcp-line);border-radius:0 0 var(--mcp-r-sm) var(--mcp-r-sm);background:transparent;color:var(--mcp-accent);font-family:inherit;font-size:11px;text-align:left;cursor:pointer;transition:background .12s}
 .dsh-mcp-quick-manage:hover{background:var(--dsw-alias-interactive-bg-hover)}
 .dsh-mcp-quick-manage:focus-visible{outline:2px solid var(--mcp-accent);outline-offset:-1px}
-.dsh-mcp-quick-item{display:flex;align-items:baseline;gap:7px;width:100%;padding:6px 9px;border:none;border-radius:var(--mcp-r-sm);background:transparent;color:var(--dsw-alias-label-primary);font-family:inherit;font-size:12px;line-height:16px;text-align:left;cursor:pointer;transition:background .12s}
+.dsh-mcp-quick-item{display:flex;align-items:baseline;gap:7px;flex:none;width:100%;height:28px;padding:6px 9px;border:none;border-radius:var(--mcp-r-sm);background:transparent;color:var(--dsw-alias-label-primary);font-family:inherit;font-size:12px;line-height:16px;text-align:left;cursor:pointer;transition:background .12s}
 .dsh-mcp-quick-item:hover{background:var(--dsw-alias-interactive-bg-hover)}
 .dsh-mcp-quick-item:focus-visible{outline:2px solid var(--mcp-accent);outline-offset:-1px}
 .dsh-mcp-quick-item-name{flex:none;max-width:120px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .dsh-mcp-quick-item-badge{flex:none;padding:1px 5px;border-radius:var(--mcp-r-xs);background:color-mix(in srgb,var(--mcp-accent) 14%,transparent);color:var(--mcp-accent);font-size:10px;line-height:12px}
 .dsh-mcp-quick-item-desc{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--mcp-mut);font-size:11px}
 .dsh-mcp-quick-loading,.dsh-mcp-quick-err{padding:9px 11px;color:var(--mcp-mut);font-size:12px}
+/* ── 会话头「当前生效专家」徽章（SessionExpertBadge）─────────────────────
+   尺寸/配色对齐宿主 AgentPresetLabel（.b06baG_label：22px 高、12px 字号、
+   tertiary 色、180px 上限），并排显示不突兀；窄窗（≤540px 容器）跟随宿主隐藏。
+   宿主用 container query，这里没有对应容器名，用媒体查询近似同一断点。 */
+.dsh-mcp-head-expert{display:inline-flex;align-items:center;gap:4px;max-width:180px;height:22px;padding:0 2px 0 0;border-radius:var(--dsw-radius-xs,var(--mcp-r-sm));background:var(--dsw-alias-fill-tsp-secondary,transparent);color:var(--dsw-alias-label-tertiary,var(--mcp-mut));font-size:12px;line-height:22px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.dsh-mcp-head-expert-icon{flex:none;opacity:.7}
+.dsh-mcp-head-expert-name{min-width:0;overflow:hidden;text-overflow:ellipsis}
+/* 陈旧预设标签：挂上专家后由 SessionExpertBadge 动态加此 class（只命中带
+   WorkBuddy 专家 前缀的那条宿主标签）。不删节点、不改 DOM 结构，只视觉隐身——
+   摘掉专家时 class 被移除，标签原样回来（React 始终是这些节点的所有者）。 */
+.dsh-mcp-hide-stale-preset{display:none!important}
+@media (max-width:560px){.dsh-mcp-head-expert{display:none}}
 .dsh-mcp-quick-note{padding:7px 11px;margin-bottom:4px;border-radius:var(--mcp-r-sm);background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary);font-size:11px;line-height:15px;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:3;overflow:hidden;white-space:normal;word-break:break-word}
 .dsh-mcp-quick-note.err{color:var(--mcp-err)}
 .dsh-mcp-quick-note.ok{color:var(--mcp-ok)}
-.dsh-mcp-quick-new-session{width:calc(100% - 8px);margin:0 4px 6px;border:1px solid color-mix(in srgb,var(--mcp-accent) 35%,transparent);border-radius:var(--mcp-r-sm);background:color-mix(in srgb,var(--mcp-accent) 10%,transparent);color:var(--mcp-accent);font:inherit;font-size:12px;line-height:26px;cursor:pointer;display:flex;align-items:center;justify-content:center;gap:6px;white-space:nowrap;overflow:hidden}
-.dsh-mcp-quick-new-session:hover{background:color-mix(in srgb,var(--mcp-accent) 18%,transparent)}
-.dsh-mcp-quick-new-session span{overflow:hidden;text-overflow:ellipsis}
 .dsh-mcp-quick-err{color:var(--mcp-err)}
 /* ── 主面板页（main slot，和「插件」同级的入口页）────────────────────────
    入口型页面要用 --dsh-frame-top-clearance 让出窗口顶带（官方 ui-layout 的约定：
@@ -2859,9 +2879,25 @@ const ExpertMarket = ({ call }) => {
 const QUICK_MENU_KINDS = [
   { key: 'skill', label: '技能', icon: 'skill', hint: '技能按需触发：选择后以 /技能名 插入输入框' },
   { key: 'mcp', label: 'MCP', icon: 'plug', hint: 'MCP 工具按 server 生效：选择后点名 mcp__服务__* 工具' },
-  { key: 'expert', label: '专家', icon: 'expert', hint: '专家挂到当前会话：整个会话由该专家人设接管' },
+  { key: 'expert', label: '专家', icon: 'expert', hint: '专家随时挂/换/摘：点一个即接管本会话，再点别的直接换，点 chip 的 × 取消' },
 ];
-const QUICK_RECENT_LIMIT = 6;
+// 子菜单列表每屏固定 6 行（6 × 28px），更多条目在 .dsh-mcp-quick-list 里纵向滚动；
+// 「最近」徽章只标最近池里的前 6 名（首屏可见的那批），避免整列都是徽章。
+// 专家预设显示名前缀：召唤时写死的 `WorkBuddy 专家 · <显示名>`（见 expert-market.js
+// buildExpertPresetRow），宿主的会话头预设标签原样显示它——用来识别「那条会过期的标签」。
+const EXPERT_PRESET_LABEL_PREFIX = 'WorkBuddy 专家 · ';
+// 专家挂载状态的最小事件总线：快速菜单挂/换/摘专家后立刻通知会话头徽章与菜单 chip，
+// 三处显示同一帧内对齐（不再各自等重挂载）。低频轮询只作兜底，覆盖「别的入口挂的专家」。
+const expertChangeListeners = new Set();
+const emitExpertChange = () => {
+  for (const listener of [...expertChangeListeners]) {
+    try { listener(); } catch { /* 单个订阅者失败不影响其它订阅者 */ }
+  }
+};
+const onExpertChange = (listener) => {
+  expertChangeListeners.add(listener);
+  return () => { expertChangeListeners.delete(listener); };
+};
 // 引用文本格式（对齐宿主真实语义，避免「同名空文档」）：
 //   skill → /name：slash token 命中技能源 lexicon（dsh-client-ui-skill 的 skill source，
 //     trigger "/"），发送后走官方 skill gesture，模型真正调起技能——@name 会落进
@@ -2893,7 +2929,8 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
   const cancelClose = () => { if (closeTimer.current) { clearTimeout(closeTimer.current); closeTimer.current = null; } };
   // scheduleClose 在 JSX 前定义（rootHoverProps 用它）；此处不重复声明。
 
-  // 菜单打开时拉一次各类清单（每类 ≤6）。三类并行取，任何一类失败不影响其它类。
+  // 菜单打开时拉一次各类清单。清单取全量（不做 6 条截断），交给子菜单自己
+  // 「最近使用置顶 + 每屏 6 行滚动」展示；三类并行取，任何一类失败不影响其它类。
   // MCP 行字段是 serverName（gateway list() 的行形状，与面板列表同一来源）；禁用的不进菜单。
   const loadRecent = useCallback(async () => {
     setListError('');
@@ -2904,9 +2941,9 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
       call('wbExpertInstalled'),
     ]);
     const kinds = recentRes?.ok && recentRes.kinds ? recentRes.kinds : {};
-    const skillRows = skillsRes?.ok && Array.isArray(skillsRes.skills) ? skillsRes.skills.slice(0, QUICK_RECENT_LIMIT) : [];
-    const mcpRows = mcpRes?.ok && Array.isArray(mcpRes.servers) ? mcpRes.servers.filter((server) => !server.disabled && server.serverName).slice(0, QUICK_RECENT_LIMIT) : [];
-    const expertRows = expertRes?.ok && Array.isArray(expertRes.presets) ? expertRes.presets.slice(0, QUICK_RECENT_LIMIT) : [];
+    const skillRows = skillsRes?.ok && Array.isArray(skillsRes.skills) ? skillsRes.skills : [];
+    const mcpRows = mcpRes?.ok && Array.isArray(mcpRes.servers) ? mcpRes.servers.filter((server) => !server.disabled && server.serverName) : [];
+    const expertRows = expertRes?.ok && Array.isArray(expertRes.presets) ? expertRes.presets : [];
     setRecent({
       skill: skillRows.map((row) => ({ name: row.name, description: row.description || row.whenToUse || '' })),
       mcp: mcpRows.map((row) => ({ name: row.serverName, description: row.url || row.command || row.transport || '' })),
@@ -3015,8 +3052,8 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
     } catch { /* 剪贴板不可用：静默 */ }
   };
 
-  // 子菜单排序：最近使用的条目按 usedAt 新→旧置顶（带「最近」标记），未命中最近记录的
-  // 排在后面保持注册表原序。主键 per kind：skill/mcp=条目名，expert=plugin。
+  // 子菜单排序：最近使用的条目按 usedAt 新→旧置顶（带「最近」标记，只标首屏 6 个），
+  // 未命中最近记录的排在后面保持注册表原序。主键 per kind：skill/mcp=条目名，expert=plugin。
   const recentListFor = (kind) => (kind === 'skill' ? recent.recentSkill : kind === 'mcp' ? recent.recentMcp : recent.recentExpert);
   const itemKeyOf = (kind, item) => String(kind === 'expert' ? (item.plugin || item.name || '') : (item.name || ''));
   const orderSubItems = (kind, items) => {
@@ -3030,7 +3067,7 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
         return { item, index, rank: rank === undefined ? Number.MAX_SAFE_INTEGER : rank, usedAt: rank === undefined ? 0 : recentRows[rank].usedAt || 0 };
       })
       .sort((a, b) => a.rank - b.rank || (b.usedAt - a.usedAt) || a.index - b.index)
-      .map((entry) => ({ ...entry.item, __recentRank: entry.rank }));
+      .map((entry) => ({ ...entry.item, __recentRank: entry.rank, __badge: entry.rank < 6 }));
   };
 
   const subItems = (kind) => {
@@ -3042,109 +3079,82 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
   const itemLabel = (kind, item) => (kind === 'expert' ? item.name || item.plugin : item.name);
   const itemDesc = (kind, item) => (kind === 'mcp' ? (item.transport ? item.transport : '') : (item.description || '').slice(0, 48));
 
-  // ── 挂专家（WorkBuddy 式）：条目点击 = agentPresets.select(sessionId, presetId) ──
-  // 官方会话头部的预设选择器同款通道：blank 会话立即生效（整个会话由专家人设接管）；
-  // 已开始的会话宿主拒绝（agent-preset/locked），此时提示改为新会话生效。挂载状态
-  // 由本组件自持（chip 显示 + 移除按钮）；移除 = select 回默认预设。
+  // ── 挂专家（WorkBuddy 式：随时挂 / 换 / 摘）──────────────────────────────
+  // 主通道是宿主新的会话级人设 RPC expertAttach/expertDetach：它把专家人设作为
+  // systemPrompt 的「本会话作用域 section」注入（与 dsh-persona / dsh-subagent 同款
+  // deployment:persona-prefix 遮蔽机制），因此：
+  //   - 不受 agent-preset/locked 限制 —— 会话已开过口也能挂、能换、能摘；
+  //   - 只影响这一个会话，不动工具目录、不写任何持久化配置；
+  //   - 反复点不同专家 = 直接替换（Host 先摘旧的再装新的），不再是一次性。
+  // 挂载只走人设通道（预设通道 agentPresets.select 会在会话投影里留下永不更新的
+  // 专家名，造成「顶栏显示 A、实际生效 B」的分叉——见 SessionExpertBadge 注释）。
   // sessionId 来源：conversation.input.right 是 session 座位，slot 渲染时把 sessionId
   // 作为 prop 显式传入（apply() 注册处 inject: (sessionId) => ({ call, sessionId })）；
   // 会话 summary 行本身不带 id 字段（id 只走 props），所以不能从 useSession 投影里取。
-  const MODULE = MODULE_CTX.ctx;
-  const [attached, setAttached] = useState(null); // { plugin, name, presetId }
+  const [attached, setAttached] = useState(null); // { plugin, name, mode: 'persona' }
   const [attachBusy, setAttachBusy] = useState(false);
   const [attachNote, setAttachNote] = useState('');
-  // locked 后的「带专家新建会话」待办：宿主硬规则是已开始的会话不能换预设
-  // （agent-preset/locked），但官方 hero 预设选择器对 blank 会话可用——所以
-  // 提供「新建会话并挂上该专家」的一键路径：sessions.create() → agentPresets.select() →
-  // uiWorkspace.openSession()，与官方「新会话选预设」语义完全一致，只是自动化了。
-  const [pendingExpert, setPendingExpert] = useState(null);
   const sessionId = typeof sessionIdProp === 'string' && sessionIdProp !== '' ? sessionIdProp : null;
-  const expertPresetIdOf = (item) => 'wbexpert-' + String(item.plugin || '').toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
-  const createWithExpert = async (item) => {
-    const ctx = MODULE;
-    if (!ctx || typeof ctx.get !== 'function') { setAttachNote('宿主上下文不可用，无法新建会话'); return; }
-    const sessions = ctx.get('sessions');
-    const uiWorkspace = ctx.get('uiWorkspace');
-    const remote = ctx.get('remote.agentPresets');
-    if (!sessions || typeof sessions.create !== 'function') { setAttachNote('宿主未提供会话创建接口（sessions 不可用）'); return; }
-    if (!uiWorkspace || typeof uiWorkspace.openSession !== 'function') { setAttachNote('宿主未提供会话导航接口（uiWorkspace 不可用）'); return; }
-    if (!remote || typeof remote.select !== 'function') { setAttachNote('宿主未提供 agentPresets 接口（remote.agentPresets 不可用）'); return; }
-    setAttachBusy(true); setAttachNote('');
-    try {
-      // 继承当前会话的工作目录（拿不到就让宿主用默认 workspace）。
-      const cwd = sessionId && sessions.list && typeof sessions.list.getSnapshot === 'function'
-        ? sessions.list.getSnapshot().byId[sessionId]?.cwd : undefined;
-      // ClientSessions.create 成功直接返回 sessionId 字符串，失败抛 SessionCreateError
-      // （workspace-client 的 reuseOrCreateBlank 同款走法）。
-      const newId = await sessions.create(cwd ? { cwd } : {});
-      if (typeof newId !== 'string' || !newId) throw new Error('创建会话未返回会话 id');
-      const presetId = expertPresetIdOf(item);
-      const selected = await remote.select(newId, presetId);
-      if (!selected || !selected.ok) {
-        throw new Error('专家预设挂载失败：' + ((selected && selected.error && (selected.error.message || selected.error.code)) || '未知错误'));
-      }
-      uiWorkspace.openSession(newId);
-      setAttached({ plugin: item.plugin, name: item.name || item.plugin, presetId: (selected.value && selected.value) || presetId });
-      setPendingExpert(null);
-      setAttachNote('✓ 已新建专家会话：' + (item.name || item.plugin) + '（人设全程接管）');
-      call('wbExpertRecordUse', { kind: 'expert', row: { plugin: item.plugin, name: item.name || item.plugin } }).catch(() => {});
-    } catch (e) {
-      setAttachNote('新建专家会话失败：' + String((e && e.message) || e));
-    } finally {
-      setAttachBusy(false);
-    }
-  };
-  const attachExpert = async (item) => {
+  const attachExpert = async (item, { quiet = false } = {}) => {
     setHoverKind(null);
-    setPendingExpert(null);
-    // 结果显示回菜单内（菜单不关）：成功 ✓ + 挂载名；失败显示真实报错。
-    // 上一版把 attachNote 从界面拿掉导致失败无声，用户无从判断「为什么没显示」。
-    if (!sessionId) { setPendingExpert(item); setAttachNote('没有活动会话：可直接带该专家新建会话'); return; }
-    const presetId = expertPresetIdOf(item);
-    const remote = MODULE && typeof MODULE.get === 'function' ? MODULE.get('remote.agentPresets') : null;
-    if (!remote || typeof remote.select !== 'function') { setAttachNote('宿主未提供 agentPresets 接口（remote.agentPresets 不可用）'); return; }
+    if (!sessionId) { setAttachNote('没有活动会话：请先进入一个会话再挂专家'); return; }
     setAttachBusy(true); setAttachNote('');
     try {
-      const result = await remote.select(sessionId, presetId);
-      if (result && result.ok) {
-        setAttached({ plugin: item.plugin, name: item.name || item.plugin, presetId: (result.value && result.value) || presetId });
-        setAttachNote('✓ 已挂到当前会话：' + (item.name || item.plugin));
+      // 只走会话级人设通道（expertAttach）：随时挂 / 换 / 摘，会话开过口也不锁。
+      // 不再先试 agentPresets.select 预设通道——它成功时会把专家预设写进会话投影，
+      // 会话顶栏从此固定显示那个专家，且会话一旦开过口 select 永久锁死，换专家
+      // 只换人设不动投影 → 「顶栏显示 A、实际生效 B」的假象。人设通道两边一致。
+      const res = await call('expertAttach', { sessionId, plugin: item.plugin });
+      if (res && res.ok) {
+        setAttached({ plugin: item.plugin, name: res.name || item.name || item.plugin, mode: 'persona' });
+        setAttachNote('✓ 已挂到当前会话：' + (res.name || item.name || item.plugin) + (res.replaced ? '（已替换原专家）' : ''));
         call('wbExpertRecordUse', { kind: 'expert', row: { plugin: item.plugin, name: item.name || item.plugin } }).catch(() => {});
+        // 立即广播：会话头徽章 + 陈旧预设标签的隐藏同步生效，三处显示同帧对齐。
+        emitExpertChange();
       } else {
-        const locked = result && result.error && /locked/i.test(String(result.error.code || '') + String(result.error.message || ''));
-        if (locked) {
-          // 宿主硬规则：会话已开始（有 turn）就不允许换预设。给出一键替代路径
-          // 而不是让用户自己去预设选择器里翻——见 createWithExpert。
-          setPendingExpert(item);
-          setAttachNote('该会话已开始对话，无法中途挂专家（宿主规则：预设只在空白会话可换）；可一键带该专家新建会话');
-        } else {
-          setAttachNote('挂载失败：' + ((result && result.error && (result.error.message || result.error.code)) || JSON.stringify(result && result.error) || '未知错误'));
-        }
+        setAttachNote('挂载失败：' + ((res && res.error) || '未知错误'));
       }
     } catch (e) {
-      setAttachNote('挂载异常：' + String((e && e.message) || e));
+      if (!quiet) setAttachNote('挂载异常：' + String((e && e.message) || e));
     } finally {
       setAttachBusy(false);
     }
   };
   const detachExpert = async () => {
-    if (!attached || !sessionId) return;
-    const remote = MODULE && typeof MODULE.get === 'function' ? MODULE.get('remote.agentPresets') : null;
-    if (!remote || typeof remote.list !== 'function' || typeof remote.select !== 'function') { setAttached(null); return; }
-    setAttachBusy(true);
+    if (!sessionId) return;
+    setAttachBusy(true); setAttachNote('');
     try {
-      const list = await remote.list();
-      const options = list && list.ok && Array.isArray(list.presets) ? list.presets : [];
-      const fallback = (options.find((row) => row.isDefault) || options[0] || {}).id;
-      if (fallback) await remote.select(sessionId, fallback);
+      // 只清会话级人设。挂载只走人设通道（见 attachExpert），不存在「当初走了预设」
+      // 的分支，也就无需回退默认预设——预设选择器保持用户自己的选择，不被插件触碰。
+      const res = await call('expertDetach', { sessionId }).catch(() => null);
       setAttached(null);
-      setAttachNote('');
+      setAttachNote(res && res.ok && res.removed ? '✓ 已取消本会话的专家' : '本会话没有挂着专家');
+      // 摘掉也要广播：会话头徽章退场、被隐身的预设标签复原。
+      emitExpertChange();
     } catch (e) {
-      setAttachNote(String((e && e.message) || e));
+      setAttachNote('取消失败：' + String((e && e.message) || e));
     } finally {
       setAttachBusy(false);
     }
   };
+  // 会话切换 / 组件重挂时对齐真实状态：宿主是唯一真源（专家可能由别的入口挂上，
+  // 或会话被重启），不能只信组件自己的 state。挂/换/摘后由总线立即触发；
+  // 5s 低频轮询兜底外部入口的变更（代价极小：expertActive 只读内存表）。
+  useEffect(() => {
+    if (!sessionId) return undefined;
+    let cancelled = false;
+    const sync = () => {
+      call('expertActive').then((res) => {
+        if (cancelled || !res || !res.ok || !Array.isArray(res.sessions)) return;
+        const mine = res.sessions.find((row) => row.sessionId === sessionId);
+        setAttached(mine ? { plugin: mine.plugin, name: mine.name, mode: 'persona' } : null);
+      }).catch(() => { /* 对齐失败保持现状：不影响使用 */ });
+    };
+    sync();
+    const off = onExpertChange(sync);
+    const poll = setInterval(sync, 5000);
+    return () => { cancelled = true; off(); clearInterval(poll); };
+  }, [sessionId, call]);
 
   // ── 悬停开合（整树统一管理）───────────────────────────────────────────
   // enter/leave 挂组件根，而不是每行：菜单顶部还有提示条/错误行/新建会话按钮，
@@ -3161,7 +3171,7 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
     // 挂载的专家：图标左侧的内联小 chip（与 trigger 同一行，不撑宽不换行）。
     // attachNote 不再渲染独立气泡——错误/提示走 trigger 的 title（悬停可见）。
     attached
-      ? h('span', { className: 'dsh-mcp-quick-chip', title: '本会话由该专家人设接管；点 × 摘掉切回默认预设' },
+      ? h('span', { className: 'dsh-mcp-quick-chip', title: '本会话由该专家人设接管；点 × 摘掉（不动预设选择器）' },
           h(Icon, { d: ICONS.expert, size: 11 }),
           h('span', { className: 'dsh-mcp-quick-chip-name' }, attached.name),
           h('button', {
@@ -3187,19 +3197,6 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
           copied ? h('div', { className: 'dsh-mcp-quick-note' }, '已复制，粘贴到输入框：' + copied) : null,
           attachBusy ? h('div', { className: 'dsh-mcp-quick-note' }, '正在挂载专家…') : null,
           attachNote ? h('div', { className: 'dsh-mcp-quick-note' + (/^✓/.test(attachNote) ? ' ok' : ' err'), role: 'alert' }, attachNote) : null,
-          // locked / 无会话时的一键替代路径：带该专家新建会话（createWithExpert）。
-          // 按钮挂在 attachNote 下方，只在该动作可用时出现；busy 期间禁用防连点。
-          pendingExpert && !attachBusy
-            ? h('button', {
-                type: 'button',
-                className: 'dsh-mcp-quick-new-session',
-                title: '新建一个空白会话并立即挂上「' + (pendingExpert.name || pendingExpert.plugin) + '」预设，人设全程接管',
-                onClick: (e) => { e.stopPropagation(); createWithExpert(pendingExpert); },
-              },
-                h(Icon, { d: ICONS.expert, size: 12 }),
-                h('span', null, '带「' + (pendingExpert.name || pendingExpert.plugin) + '」新建会话'),
-              )
-            : null,
           listError ? h('div', { className: 'dsh-mcp-quick-err' }, listError) : null,
           !recent && !listError ? h('div', { className: 'dsh-mcp-quick-loading' }, '正在读取…') : null,
           QUICK_MENU_KINDS.map((kind) => {
@@ -3232,22 +3229,24 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
               hoverKind === kind.key
                 ? h('div', { className: 'dsh-mcp-quick-sub' + (Array.isArray(items) && items.length ? '' : ' empty'), role: 'menu', 'aria-label': kind.label + '可选项' },
                     Array.isArray(items) && items.length
-                      ? items.map((item, index) => h('button', {
-                          key: item.name || item.plugin || index,
-                          type: 'button',
-                          role: 'menuitem',
-                          className: 'dsh-mcp-quick-item',
-                          title: kind.key === 'expert' ? '挂到当前会话：整个会话由该专家接管' : (itemDesc(kind.key, item) || itemLabel(kind.key, item)),
-                          onClick: (e) => { e.stopPropagation(); if (kind.key === 'expert') attachExpert(item); else pick(kind.key, item, quickMentionText(kind.key, item)); },
-                        },
-                          kind.key === 'expert' && attached && attached.plugin === item.plugin
-                            ? h(Badge, { cls: 's-on' }, '已挂')
-                            : typeof item.__recentRank === 'number' && item.__recentRank !== Number.MAX_SAFE_INTEGER
-                              ? h('span', { className: 'dsh-mcp-quick-item-badge', 'aria-label': '最近使用' }, '最近')
-                              : null,
-                          h('span', { className: 'dsh-mcp-quick-item-name' }, itemLabel(kind.key, item)),
-                          itemDesc(kind.key, item) ? h('span', { className: 'dsh-mcp-quick-item-desc' }, itemDesc(kind.key, item)) : null,
-                        ))
+                      ? h('div', { className: 'dsh-mcp-quick-list', role: 'group', 'aria-label': kind.label + '列表（最多显示 6 行，滚动查看更多）' },
+                          items.map((item, index) => h('button', {
+                            key: item.name || item.plugin || index,
+                            type: 'button',
+                            role: 'menuitem',
+                            className: 'dsh-mcp-quick-item',
+                            title: kind.key === 'expert' ? '挂到当前会话（可随时换或取消）；再点别的专家 = 直接替换' : (itemDesc(kind.key, item) || itemLabel(kind.key, item)),
+                            onClick: (e) => { e.stopPropagation(); if (kind.key === 'expert') attachExpert(item); else pick(kind.key, item, quickMentionText(kind.key, item)); },
+                          },
+                            kind.key === 'expert' && attached && attached.plugin === item.plugin
+                              ? h(Badge, { cls: 's-on' }, '已挂')
+                              : item.__badge
+                                ? h('span', { className: 'dsh-mcp-quick-item-badge', 'aria-label': '最近使用' }, '最近')
+                                : null,
+                            h('span', { className: 'dsh-mcp-quick-item-name' }, itemLabel(kind.key, item)),
+                            itemDesc(kind.key, item) ? h('span', { className: 'dsh-mcp-quick-item-desc' }, itemDesc(kind.key, item)) : null,
+                          )),
+                        )
                       : h('div', { className: 'dsh-mcp-quick-sub-note' }, '暂无可选项'),
                     h('button', {
                       type: 'button',
@@ -3266,6 +3265,100 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
       : null,
   );
 };
+// ── 会话头「当前生效专家」徽章（conversation.session.header.actions）──────
+// 宿主的 AgentPresetLabel 只读会话的 agentPreset 投影（会话开过口后不再变化），
+// 与本插件「随时换专家」的人设通道天然脱节：换专家后顶栏仍显示第一次的预设名。
+// 这个 slot 条目显示的是真正生效中的专家（expertActive 对账），与输入框 chip 同源
+// 同步——哪个专家在管这个会话，顶栏一眼可见；没挂专家时不渲染任何东西。
+// 样式对齐宿主 AgentPresetLabel（同高 22px、同 token），与预设标签并排不突兀；
+// 宿主标签在 540px 以下隐藏，本徽章跟随同一断点（container query 无法跨包复用，
+// 用媒体查询近似窄窗行为）。
+const SessionExpertBadge = ({ call, sessionId }) => {
+  const [attached, setAttached] = useState(null);
+  const [ready, setReady] = useState(false);
+  const badgeRef = useRef(null);
+  // 同步真源：宿主 expertActive 是唯一真源（别的入口挂的专家也要认）。挂/换/摘之后
+  // 由总线立即触发一次，5s 低频轮询只兜底外部变化；组件重挂载也走同一条路径。
+  useEffect(() => {
+    if (!sessionId) { setAttached(null); setReady(true); return undefined; }
+    let cancelled = false;
+    const sync = () => {
+      call('expertActive').then((res) => {
+        if (cancelled) return;
+        const mine = res && res.ok && Array.isArray(res.sessions)
+          ? res.sessions.find((row) => row.sessionId === sessionId)
+          : null;
+        setAttached(mine ? { plugin: mine.plugin, name: mine.name } : null);
+        setReady(true);
+      }).catch(() => { if (!cancelled) setReady(true); });
+    };
+    setReady(false);
+    sync();
+    const off = onExpertChange(sync);
+    const poll = setInterval(sync, 5000);
+    return () => { cancelled = true; off(); clearInterval(poll); };
+  }, [sessionId, call]);
+  // 挂上专家时，把同容器里那条**陈旧的预设标签**藏掉：它读的是会话创建时的
+  // agentPreset 投影（宿主只读、换专家不动它），所以换到第二个专家后它仍显示第一个，
+  // 与真正生效的人设相反——三处显示里唯一会「说谎」的一处。只藏带本插件专家预设
+  // 前缀（WorkBuddy 专家）的那条，默认预设标签与其他插件条目一律不碰；摘掉专家后
+  // 立即恢复（原生 <span> 一直被 React 管着，我们只临时加 class，不移动/不删除节点）。
+  // 对账幂等：每轮把「现在不该藏」的还原回显；观察 class 变化是为了宿主重渲染覆盖
+  // className 后能补回（React 只在 props 变化时才写，稳态不会抖）。
+  useEffect(() => {
+    if (!attached || typeof document === 'undefined') return undefined;
+    let stop = null;
+    const isStalePreset = (node) => String(node.textContent || '').trim().startsWith(EXPERT_PRESET_LABEL_PREFIX);
+    // 作用域 = 能同时容纳「本徽章」与「宿主播条目」的最近祖先（正常就是 headerActions
+    // 容器）；若父层只是个包装且里面没有目标条目，再上探一层（最多 3 层，防止飘到整页
+    // 把看板/菜单里同名前缀的文本一起误藏）。
+    const resolveScope = () => {
+      const own = badgeRef.current;
+      if (!own) return null;
+      let node = own.parentElement;
+      for (let i = 0; i < 3 && node; i++) {
+        const others = [...node.querySelectorAll('span')].filter((s) => s !== own && !s.contains(own));
+        if (others.some(isStalePreset)) return node;
+        node = node.parentElement;
+      }
+      return own.parentElement;
+    };
+    const reconcile = () => {
+      const scope = resolveScope();
+      const own = badgeRef.current;
+      if (!scope || !own) return;
+      for (const node of scope.querySelectorAll('span')) {
+        const keep = node === own || node.contains(own) || !isStalePreset(node);
+        if (keep) node.classList.remove('dsh-mcp-hide-stale-preset');
+        else node.classList.add('dsh-mcp-hide-stale-preset');
+      }
+    };
+    const raf = requestAnimationFrame(() => {
+      reconcile();
+      const scope = resolveScope();
+      if (!scope) return;
+      stop = new MutationObserver(reconcile);
+      stop.observe(scope, { childList: true, subtree: true, characterData: true, attributes: true, attributeFilter: ['class'] });
+    });
+    return () => {
+      cancelAnimationFrame(raf);
+      stop?.disconnect();
+      // 摘掉专家 / 组件卸载：全部复原（只摘我们加的那个 class）。
+      for (const node of document.querySelectorAll('.dsh-mcp-hide-stale-preset')) {
+        node.classList.remove('dsh-mcp-hide-stale-preset');
+      }
+    };
+  }, [attached]);
+  if (!ready || !attached) return null;
+  return h('span', {
+    className: 'dsh-mcp-head-expert',
+    ref: badgeRef,
+    title: '当前生效专家（人设接管本会话；可在输入框工具行的专家菜单随时换/摘）',
+  },
+    h(Icon, { d: ICONS.expert, size: 13, className: 'dsh-mcp-head-expert-icon' }),
+    h('span', { className: 'dsh-mcp-head-expert-name' }, attached.name),
+  );
+};
 const wbFormatCount = (value) => {
   const n = Number(value) || 0;
   if (n >= 1_000_000) return (n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1) + 'M';
@@ -3858,6 +3951,8 @@ const McpBoardPage = (props) => {
   }, []);
   // 顶层分类计数：Skill 条数单独取，避免两条加载互相等待。
   const [skillCount, setSkillCount] = useState(null);
+  // MCP 计数：与其他分类标签保持一致（此前只有 skill/tailor/expert 有数量，MCP 没有是遗漏）。
+  const [mcpCount, setMcpCount] = useState(null);
   // 工具裁缝计数：只在用户切到该分类时拉一次，避免打开页面就扫日志。
   const [tailorCount, setTailorCount] = useState(null);
   useEffect(() => {
@@ -3866,6 +3961,10 @@ const McpBoardPage = (props) => {
     call('listSkills', skillScopeArg('global')).then((res) => {
       if (alive && res && res.ok) setSkillCount(Array.isArray(res.skills) ? res.skills.length : null);
     }).catch(() => {});
+    // MCP 计数与 Skill 同批取（都在打开页面时取一次；global 层与 McpTab 的默认视图一致）。
+    call('list').then((res) => {
+      if (alive && res && res.ok && Array.isArray(res.servers)) setMcpCount(res.servers.length);
+    }).catch(() => {});
     return () => { alive = false; };
   }, [call, category]);
   useEffect(() => {
@@ -3903,6 +4002,7 @@ const McpBoardPage = (props) => {
           },
             h(Icon, { d: ICONS[cat.icon], size: 14 }),
             cat.label,
+            cat.key === 'mcp' && mcpCount !== null ? h('span', { className: 'dsh-mcp-cat-count' }, mcpCount) : null,
             cat.key === 'skill' && skillCount !== null ? h('span', { className: 'dsh-mcp-cat-count' }, skillCount) : null,
             cat.key === 'tailor' && tailorCount !== null ? h('span', { className: 'dsh-mcp-cat-count' }, tailorCount) : null,
             cat.key === 'expert' && expertCount !== null ? h('span', { className: 'dsh-mcp-cat-count' }, expertCount) : null,
@@ -4336,7 +4436,12 @@ const MCP_CONTRIBUTION = {
     { id: 'dsh-armory#mcpManager/wbExpertDismiss', service: 'mcpManager', namespace: 'mcpManager', method: 'wbExpertDismiss', invocation: { kind: 'direct' }, parameters: [mcpParam('payload', 'ImportPayload')], result: mcpCodec('NoteResult') },
     { id: 'dsh-armory#mcpManager/wbExpertInstalled', service: 'mcpManager', namespace: 'mcpManager', method: 'wbExpertInstalled', invocation: { kind: 'direct' }, parameters: [], result: mcpCodec('WbExpertInstalledResult') },
     { id: 'dsh-armory#mcpManager/wbExpertRecent', service: 'mcpManager', namespace: 'mcpManager', method: 'wbExpertRecent', invocation: { kind: 'direct' }, parameters: [], result: mcpCodec('WbExpertRecentResult') },
-    { id: 'dsh-armory#mcpManager/wbExpertRecordUse', service: 'mcpManager', namespace: 'mcpManager', method: 'wbExpertRecordUse', invocation: { kind: 'direct' }, parameters: [mcpParam('payload', 'ImportPayload')], result: mcpCodec('NoteResult') }
+    { id: 'dsh-armory#mcpManager/wbExpertRecordUse', service: 'mcpManager', namespace: 'mcpManager', method: 'wbExpertRecordUse', invocation: { kind: 'direct' }, parameters: [mcpParam('payload', 'ImportPayload')], result: mcpCodec('NoteResult') },
+    // 会话级专家人设（随时挂 / 换 / 摘）：不受 agent-preset/locked 限制。
+    // 与宿主 method、typert.js 三处必须同步，漏一处这条通道就恒 404。
+    { id: 'dsh-armory#mcpManager/expertAttach', service: 'mcpManager', namespace: 'mcpManager', method: 'expertAttach', invocation: { kind: 'direct' }, parameters: [mcpParam('payload', 'ImportPayload')], result: mcpCodec('NoteResult') },
+    { id: 'dsh-armory#mcpManager/expertDetach', service: 'mcpManager', namespace: 'mcpManager', method: 'expertDetach', invocation: { kind: 'direct' }, parameters: [mcpParam('payload', 'ImportPayload')], result: mcpCodec('NoteResult') },
+    { id: 'dsh-armory#mcpManager/expertActive', service: 'mcpManager', namespace: 'mcpManager', method: 'expertActive', invocation: { kind: 'direct' }, parameters: [], result: mcpCodec('ExpertActiveResult') }
   ].map((descriptor) => ({ ...descriptor, sourceLocation: { file: 'dsh-armory/lib/typert.js', line: 7, column: 1 } }))
 };
 async function apply(ctx) {
@@ -4387,10 +4492,16 @@ async function apply(ctx) {
     // 点开 = 技能/MCP/专家三分类 + 悬停最近使用子菜单。声明感知注入（会话 slot 由 conversation
     // 包声明，加载顺序不保证）；菜单组件自管开关与外部点击关闭。
     // sessionId 由 slot 渲染作为 prop 显式传入（session 座位约定：id 只走 props，不走 summary 投影），
-    // 「挂专家」的 agentPresets.select 用它寻址当前会话。
+    // 「挂专家」的人设通道 RPC 用它寻址当前会话。
     ctx.slots.inject('conversation.input.right', () =>
       ctx.slots.register({ name: 'conversation.input.right', id: PANEL_ID + '-quick', order: 40, label: PANEL_LABEL, inject: (sessionId) => ({ call, sessionId }) }, SummonQuickMenu),
     );
+    // 会话头「当前生效专家」徽章（conversation.session.header.actions，list 型 slot）：
+    // 与宿主 AgentPresetLabel 同列——但显示的是人设通道真正生效的专家（expertActive），
+    // 修复「换专家后顶栏仍显示第一次预设名」的显示/实效分叉。
+    ctx.slots.inject('conversation.session.header.actions', () =>
+      ctx.slots.register({ name: 'conversation.session.header.actions', id: PANEL_ID + '-head-expert', order: -5, label: PANEL_LABEL, inject: (sessionId) => ({ call, sessionId }) }, SessionExpertBadge),
+    );
     // 左上角全局面板行（sidebar.panellist）：「插件」旁边，主入口。行点击由宿主承担——
     // layout.selectPanel(PANEL_ID) 要求 main slot 里存在同 key 条目，上面的注册保证了这点。
     // 面板行不能用「渲染 null」隐藏（label 来自注册 options，不来自组件），所以按偏好

package/lib/expert-market.js

@@ -578,8 +578,9 @@ export function removeExpertPreset(content, plugin) {
 // 持久化在 ~/.dsh/wb-market/experts/recent.json：三类各存一份轻量记录
 // （skill: 技能名+来源目录名；mcp: serverName+作用域；expert: plugin+召唤预设名）。
 // 只在「可观察的使用动作」发生时写入：召唤/送还专家、召唤菜单里选中一项（由客户端
-// 显式上报）。上限各 8 条，新的顶到最前，去重按主键。文件损坏静默重置（纯增值数据）。
-const RECENT_LIMIT = 8;
+// 显式上报）。上限各 40 条（召唤菜单每屏 6 行 + 滚动，排序需要较深的最近记录池），
+// 新的顶到最前，去重按主键。文件损坏静默重置（纯增值数据）。
+const RECENT_LIMIT = 40;
 function recentPath() {
   return join(cacheDir(), "recent.json");
 }

package/lib/index.js

@@ -15,6 +15,7 @@ import { allMcpEntries, entriesForName, projectToolSchema, revisionOf, toolInven
 import { WHATS_NEW } from "./whats-new.js";
 import { wbConnectorCatalog, wbConnectorPreview, wbSkillCatalog, wbSkillDetail, wbSkillFiles, wbSkillInstall, wbSkillInstalled, wbSkillUninstall } from "./wb-market.js";
 import { installExpertSkills, listExpertRecent, listExpertSkills, readExpertPresets, recordExpertRecent, removeExpertPreset, uninstallExpertSkills, wbExpertCatalog, wbExpertDetail, writeExpertPreset } from "./expert-market.js";
+import { attachPersona, detachPersona, listPersonas, reconcilePersonas } from "./session-persona.js";
 import { scanSessionLedger } from "./tool-ledger.js";
 import { evaluateEnvExpression, jsExpressionToTemplate } from "./workspace-config.js";
 import { canonicalWorkspacePath, installAgentRuntime, listWorkspaceRecords, liveWorkspaceAgentCount, projectConnectionsView, readWorkspaceConfigCached, reconcileWorkspaceConnections, reconcileWorkspaceRestricts, reconnectWorkspaceServer, withWorkspaceWrite, workspaceConnectionStatus, workspaceMountErrorsView, workspaceRestrictErrorView, workspaceScopeErrorsView, workspaceToolSchemas, writeWorkspaceConfigFile } from "./workspace-runtime.js";
@@ -1460,6 +1461,32 @@ let McpManagerGateway = (() => {
 	// 数据与安装逻辑都在 lib/expert-market.js；这里只做 RPC 转发与 patch 写盘收尾。
 	// 召唤 = 往 profile patch 插入一条独立 @deepseek-ai/dsh-agent-preset 行（persona.prefix
 	// = 专家人设），DSH 热加载后新会话即可在预设选择器里选它——多专家共存，卸载即摘除。
+	// ── 会话级专家人设（随时挂 / 换 / 摘，不受 agent-preset/locked 限制）──────
+	// 机制与边界见 lib/session-persona.js 顶部注释：走 systemPrompt 的会话作用域
+	// section，遮蔽该会话的部署人设前缀；不动工具目录、不写任何持久化配置。
+	async expertAttach(payload) {
+		const sessionId = String(payload?.sessionId || "").trim();
+		const plugin = String(payload?.plugin || "").trim();
+		if (!sessionId) throw new Error("缺少 sessionId");
+		if (!plugin) throw new Error("缺少 plugin");
+		const detail = await wbExpertDetail({ plugin });
+		const result = attachPersona(this.ctx, sessionId, {
+			plugin,
+			name: detail.name,
+			personaText: detail.persona,
+		});
+		await recordExpertRecent("expert", { plugin, name: detail.name, profession: detail.profession, presetId: `session-${plugin}` }).catch(() => {});
+		return { ...result, profession: detail.profession };
+	}
+	async expertDetach(payload) {
+		const sessionId = String(payload?.sessionId || "").trim();
+		if (!sessionId) throw new Error("缺少 sessionId");
+		return detachPersona(this.ctx, sessionId);
+	}
+	async expertActive() {
+		reconcilePersonas(this.ctx);
+		return { sessions: listPersonas() };
+	}
 	async wbExpertCatalog() {
 		return wbExpertCatalog();
 	}

package/lib/session-persona.js

@@ -0,0 +1,120 @@
+// 会话级专家人设注入 —— 让「专家」像 WorkBuddy 一样可随时挂/换/摘，不受 agent-preset/locked 限制。
+//
+// 为什么需要这条独立通道：宿主的 agentPresets.select() 有硬锁（会话一旦开过口就
+// `agent-preset/locked`），因为**预设**决定工具目录与提示词结构，中途换会破坏前后一致。
+// 但用户要的是 WorkBuddy 式体验：任何会话、任何时刻都能换专家或摘掉。可行的原因是
+// 人设（persona）与预设是两件事——preset 的 persona 行只是一段提示词 section：
+//
+//   dsh-persona 的注释写明该行是 **scope-only**：挂进某个 agent 预设时，它只遮蔽
+//   「那一个会话」的部署人设。dsh-subagent 也用同一手法给子会话装人设：
+//     childCtx.systemPrompt.section({ name: "deployment:persona-prefix",
+//       order: childCtx.systemPrompt.getSectionOrder("DEPLOYMENT_PERSONA_PREFIX"),
+//       text: persona })
+//
+// 而 systemPrompt.section() 的归属 scope 取自定义层自身 ctx 的 kScope（见 dsh-scope
+// 的 scopeOf / ScopedLayers.effect），cordis 的 tracker 代理会把服务方法的 this.ctx
+// 重绑为**调用方 ctx** —— 所以用 `agent.ctx.systemPrompt.section(...)` 注册，段就落在
+// 该会话自己的 scope 层：只影响这个会话，且 ctx.effect 返回的 disposer 可随时撤销。
+//
+// 与「召唤预设」的分工：召唤写 profile patch，管**新会话的预设选择器**（长期身份）；
+// 本模块管**当前会话的即时人设**（会话内挂/换/摘）。两者互不干扰：预设仍在，随时可用；
+// 会话内挂的专家只是这段提示词 section 的替换，不动工具目录与任何持久化配置。
+
+/** 与 dsh-persona / dsh-subagent 共用的 section 名（同名即遮蔽，最近 scope 胜出）。 */
+const PERSONA_PREFIX_SECTION = "deployment:persona-prefix";
+/** 单个会话最多保留的撤销记录（防泄漏；正常使用远小于此）。 */
+const MAX_SESSIONS = 64;
+/** sessionId -> { plugin, name, disposer } */
+const activePersonas = new Map();
+
+function agentCtxOf(ctx, sessionId) {
+	const agents = typeof ctx?.get === "function" ? ctx.get("agents") : undefined;
+	if (!agents || typeof agents.get !== "function") return { error: "宿主未提供 agents 服务（agentRegistry 不可用），无法定位会话" };
+	const agent = agents.get(sessionId);
+	if (agent === undefined) return { error: "会话不在运行中（可能已归档或尚未激活）：" + sessionId };
+	const agentCtx = agent.ctx;
+	if (agentCtx === undefined) return { error: "该会话没有可用的作用域上下文" };
+	return { agentCtx };
+}
+
+/**
+ * 摘掉某会话当前注入的人设（若有）。
+ * @returns {boolean} 是否真的摘掉了一段。
+ */
+function clearPersona(sessionId) {
+	const current = activePersonas.get(sessionId);
+	if (!current) return false;
+	activePersonas.delete(sessionId);
+	try {
+		current.disposer?.();
+	} catch { /* 撤销失败不回滚状态：section 已随 scope 失效，重复撤销无害 */ }
+	return true;
+}
+
+/** 当前挂在某会话上的专家（供客户端 chip 显示真实状态）。 */
+export function personaOf(sessionId) {
+	const row = activePersonas.get(sessionId);
+	return row ? { plugin: row.plugin, name: row.name } : null;
+}
+
+/** 所有会话的挂载快照（会话被销毁后由 reconcile 清理）。 */
+export function listPersonas() {
+	return [...activePersonas.entries()].map(([sessionId, row]) => ({ sessionId, plugin: row.plugin, name: row.name }));
+}
+
+/** 会话已不在运行 → 清掉它的撤销记录（disposer 早已随 scope 失效）。 */
+export function reconcilePersonas(ctx) {
+	const agents = typeof ctx?.get === "function" ? ctx.get("agents") : undefined;
+	if (!agents || typeof agents.get !== "function") return;
+	const live = new Set(agents.list().map((agent) => agent.id));
+	for (const sessionId of [...activePersonas.keys()]) {
+		if (!live.has(sessionId)) activePersonas.delete(sessionId);
+	}
+}
+
+/**
+ * 给一个运行中的会话注入（或替换）专家人设。同一会话可反复调用：先摘旧的再装新的。
+ * @param {object} ctx - 插件宿主上下文。
+ * @param {string} sessionId - 目标会话。
+ * @param {object} spec - { plugin, name, personaText }。
+ * @returns {{ok: true, plugin: string, name: string, replaced: boolean}}
+ */
+export function attachPersona(ctx, sessionId, spec) {
+	const id = String(sessionId || "").trim();
+	if (!id) throw new Error("缺少会话 id");
+	const text = String(spec?.personaText || "").trim();
+	if (!text) throw new Error("人设内容为空，无法挂载");
+	const { agentCtx, error } = agentCtxOf(ctx, id);
+	if (error) throw new Error(error);
+	const prompt = agentCtx.systemPrompt;
+	if (!prompt || typeof prompt.section !== "function") {
+		throw new Error("该会话没有 systemPrompt 服务，无法注入人设");
+	}
+	const replaced = clearPersona(id);
+	// 与 dsh-persona 同款：同名 section + 同一处 order = 遮蔽该会话的部署人设前缀。
+	const disposer = prompt.section({
+		name: PERSONA_PREFIX_SECTION,
+		order: typeof prompt.getSectionOrder === "function"
+			? prompt.getSectionOrder("DEPLOYMENT_PERSONA_PREFIX")
+			: 0,
+		text,
+	});
+	activePersonas.set(id, {
+		plugin: String(spec?.plugin || ""),
+		name: String(spec?.name || spec?.plugin || "专家"),
+		disposer,
+	});
+	// 防泄漏：超出上限时丢掉最早的记录（其 disposer 一并撤销）。
+	while (activePersonas.size > MAX_SESSIONS) {
+		const oldest = activePersonas.keys().next().value;
+		clearPersona(oldest);
+	}
+	return { ok: true, plugin: String(spec?.plugin || ""), name: String(spec?.name || spec?.plugin || "专家"), replaced };
+}
+
+/** 摘掉某会话的专家人设。@returns {{ok: true, removed: boolean}} */
+export function detachPersona(ctx, sessionId) {
+	const id = String(sessionId || "").trim();
+	if (!id) throw new Error("缺少会话 id");
+	return { ok: true, removed: clearPersona(id) };
+}

package/lib/typert.js

@@ -101,6 +101,11 @@ export const TYPERT = {
     mv('wbExpertInstalled', [], 'WbExpertInstalledResult'),
     mv('wbExpertRecent', [], 'WbExpertRecentResult'),
     mv('wbExpertRecordUse', [payloadParam], 'NoteResult'),
+    // 会话级专家人设（随时挂/换/摘）：走 systemPrompt 的会话作用域 section，
+    // 不受 agent-preset/locked 限制。payload 交给 lib/session-persona.js 校验。
+    mv('expertAttach', [payloadParam], 'NoteResult'),
+    mv('expertDetach', [payloadParam], 'NoteResult'),
+    mv('expertActive', [], 'ExpertActiveResult'),
   ],
   model: { services: [], events: [], objects: [] },
 }

package/lib/whats-new.js

@@ -229,4 +229,42 @@ export const WHATS_NEW = [
       },
     ],
   },
+  {
+    version: '1.9.2',
+    items: [
+      {
+        text: '专家升级为 WorkBuddy 式「随时挂 / 换 / 摘」：任何会话（包括已经聊了一半的）都能挂专家、直接点另一个专家就换掉、点 chip 的 × 立刻取消——不再有「会话已开始，无法中途挂专家」的死路，也不再是一个对话只能引用一次',
+        where: '会话输入框工具行右侧的看板小图标 → 专家',
+      },
+      {
+        text: '换专家会明确告诉你「已替换原专家」，取消后点别的专家又能重新挂上；组件重挂或切换会话时自动向宿主对账，chip 显示的始终是真实状态（专家也能由预设选择器等其他入口挂上）',
+        where: '专家 chip 与召唤菜单内的提示条',
+      },
+    ],
+  },
+  {
+    version: '1.9.3',
+    items: [
+      {
+        text: '召唤菜单的「技能 / MCP / 专家」子菜单升级为**全量列表 + 滚动浏览**：每屏固定显示 6 行，超出的往下滚（细滚动条跟随主题）；「管理技能/MCP/专家…」按钮固定在底部，不再被列表滚走。以前每类只列前 6 条，第 7 个技能在菜单里根本找不到',
+        where: '会话输入框工具行右侧的看板小图标',
+      },
+      {
+        text: '子菜单按**最近使用**排序：你刚用过的条目自动置顶并带「最近」标记（首屏 6 个），其余按原有顺序排在后面。最近使用记录池从 8 条加深到 40 条，排序更贴合真实使用习惯',
+        where: '召唤菜单 → 技能 / MCP / 专家',
+      },
+      {
+        text: '修复「换了专家，会话最上方还显示第一个专家」：会话头那条**预设标签**读的是会话创建时的事实、换专家不会变（宿主只读）。现在挂上专家后它会自动让位，改由一枚显示**当前真正生效**专家的徽章接管，并随换随新',
+        where: '会话标题栏（挂专家后）',
+      },
+      {
+        text: '修复专家显示的「三名不一致」：以前预设标签、输入框 chip、会话头三处各查一次状态，换完专家要等重挂才刷新。现在挂/换/摘后立即同帧同步，另有 5 秒兜底对账（覆盖从预设选择器等别的入口挂上的专家）',
+        where: '会话标题栏 + 输入框专家 chip',
+      },
+      {
+        text: '专家挂载不再走「预设通道」：那条路会在会话投影里写下一个**永不更新**的专家名，是上面那个「顶栏显示 A、实际生效 B」的根因。现在统一走会话级人设通道——随时挂/换/摘，显示与实效从此一致',
+        where: '召唤菜单 → 专家',
+      },
+    ],
+  },
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-armory",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "Unified Skill + MCP + Expert board for DeepSeek Harness (desktop app and Web GUI) — global panel page, JSON import, WorkBuddy connector & SkillHub & Expert market installs, tool-usage tailor, and profile-backed Host Remote management.",
   "repository": {
     "type": "git",
@@ -75,13 +75,19 @@
   },
   "keywords": [
     "deepseek-harness",
+    "deepseek",
     "dsh",
     "dsh-plugin",
     "cordis",
     "mcp",
+    "mcp-client",
     "armory",
     "skill",
-    "expert"
+    "skill-manager",
+    "expert",
+    "agent-preset",
+    "workbuddy",
+    "plugin"
   ],
   "license": "MIT"
 }