dsh-armory 1.9.1 → 1.9.2

package/lib/client.js

@@ -375,9 +375,6 @@ const MCP_CSS = `body{--mcp-accent:var(--dsw-alias-brand-primary);--mcp-ok:var(-
 .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,7 +2856,7 @@ 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;
 // 引用文本格式（对齐宿主真实语义，避免「同名空文档」）：
@@ -3042,109 +3039,92 @@ 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）作为 blank 会话的增强：它连工具目录一起接管，语义更
+  // 彻底；只在「该专家已被召唤 + 会话还是空白」时成功，失败就自动退回人设通道——
+  // 两条路都不通的情况不存在，所以「换专家」永远有出路。
   // 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'|'preset' }
   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; }
+    if (!sessionId) { 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; }
     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));
+      // ① blank 会话 + 已召唤 → 先用预设通道（连工具目录一起接管，最彻底）。
+      const remote = MODULE && typeof MODULE.get === 'function' ? MODULE.get('remote.agentPresets') : null;
+      if (remote && typeof remote.select === 'function') {
+        const result = await remote.select(sessionId, presetId).catch(() => null);
+        if (result && result.ok) {
+          setAttached({ plugin: item.plugin, name: item.name || item.plugin, mode: 'preset' });
+          setAttachNote('✓ 已挂到当前会话：' + (item.name || item.plugin));
+          call('wbExpertRecordUse', { kind: 'expert', row: { plugin: item.plugin, name: item.name || item.plugin } }).catch(() => {});
+          return;
+        }
+      }
+      // ② 其余情况（会话已开始 / 未召唤 / 无 agentPresets）→ 会话级人设通道，必定可用。
+      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(() => {});
       } 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);
+      // 会话级人设一定清（不管当初走的是哪条路）；预设通道只在当初走预设时回退默认。
+      const res = await call('expertDetach', { sessionId }).catch(() => null);
+      const remote = MODULE && typeof MODULE.get === 'function' ? MODULE.get('remote.agentPresets') : null;
+      if (attached?.mode === 'preset' && remote && typeof remote.list === 'function' && typeof remote.select === 'function') {
+        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);
+        } catch { /* 预设回退失败不影响「已摘掉」这一事实 */ }
+      }
       setAttached(null);
-      setAttachNote('');
+      setAttachNote(res && res.ok && res.removed ? '✓ 已取消本会话的专家' : '本会话没有挂着专家');
     } catch (e) {
-      setAttachNote(String((e && e.message) || e));
+      setAttachNote('取消失败：' + String((e && e.message) || e));
     } finally {
       setAttachBusy(false);
     }
   };
+  // 会话切换 / 组件重挂时对齐真实状态：宿主是唯一真源（专家可能由别的入口挂上，
+  // 或会话被重启），不能只信组件自己的 state。
+  useEffect(() => {
+    if (!sessionId) return undefined;
+    let cancelled = false;
+    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(() => { /* 对齐失败保持现状：不影响使用 */ });
+    return () => { cancelled = true; };
+  }, [sessionId, call]);
 
   // ── 悬停开合（整树统一管理）───────────────────────────────────────────
   // enter/leave 挂组件根，而不是每行：菜单顶部还有提示条/错误行/新建会话按钮，
@@ -3187,19 +3167,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) => {
@@ -3237,7 +3204,7 @@ const SummonQuickMenu = ({ call, inputActions, sessionId: sessionIdProp }) => {
                           type: 'button',
                           role: 'menuitem',
                           className: 'dsh-mcp-quick-item',
-                          title: kind.key === 'expert' ? '挂到当前会话：整个会话由该专家接管' : (itemDesc(kind.key, item) || itemLabel(kind.key, 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
@@ -4336,7 +4303,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) {

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,17 @@ export const WHATS_NEW = [
       },
     ],
   },
+  {
+    version: '1.9.2',
+    items: [
+      {
+        text: '专家升级为 WorkBuddy 式「随时挂 / 换 / 摘」：任何会话（包括已经聊了一半的）都能挂专家、直接点另一个专家就换掉、点 chip 的 × 立刻取消——不再有「会话已开始，无法中途挂专家」的死路，也不再是一个对话只能引用一次',
+        where: '会话输入框工具行右侧的看板小图标 → 专家',
+      },
+      {
+        text: '换专家会明确告诉你「已替换原专家」，取消后点别的专家又能重新挂上；组件重挂或切换会话时自动向宿主对账，chip 显示的始终是真实状态（专家也能由预设选择器等其他入口挂上）',
+        where: '专家 chip 与召唤菜单内的提示条',
+      },
+    ],
+  },
 ]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-armory",
-  "version": "1.9.1",
-  "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.",
+  "version": "1.9.2",
+  "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",
     "url": "git+https://github.com/2026heshao/dsh-armory.git"