dsh-soul 0.7.2 → 0.9.0

package/client/index.mjs

@@ -48,7 +48,7 @@ window.__ModuleLoader__.load({
     // -------------------------------------------------------------------------
 
     const NS = 'soul'
-    const VERSION = '0.7.2'
+    const VERSION = '0.9.0'
     const INITIAL = {
       enabled: true,
       nickname: '',
@@ -73,6 +73,46 @@ window.__ModuleLoader__.load({
       activePersona: null,
       // 预设列表请求失败的原因（成功时清空）。用于把「加载中」与「加载失败」区分开
       personasError: null,
+      // 会话作用域解析结果：sessionId → { activePersona, source, workspaceTitle, ... }。
+      //
+      // 为什么放进**全局 store**而不是组件自己的 useState：
+      // · 会话「人设」tab 与 header 的人设标签是**两个组件**，都要看同一份数据；
+      // · 之前 header 标签只在 sessionId 变化时取一次 ⇒ 会话里切换人设后，
+      //   标签仍显示旧值（用户报的 bug）；
+      // · 放 store 后，saveSessionScope 成功即写入，所有订阅者一起刷新 ——
+      //   不必再各自去轮询或监听。
+      //
+      // 值是普通对象（不是 Map）：store 的更新走浅比较，Map 原地改不会触发。
+      sessionScopes: {},
+      // 变更记录（0.8.0）：null = 还没拉过，[] = 拉过且确实没有记录。
+      // 两者必须分得开 —— 否则「没有记录」与「还没加载」在界面上是同一种空白。
+      history: null,
+      // 记录可能不完整的原因（读取窗口切掉、坏行、压实、写入失败），服务端给的原文
+      historyWarning: null,
+      historyError: null,
+      // 容量上限（服务端 HISTORY_MAX_ENTRIES）。由响应带回而不是写死在客户端：
+      // 两边各写一份迟早会不一致，而「最多保留 N 条」是一句会被人当真的承诺。
+      historyMax: null,
+      // 变更记录保留条数（配置字段，用户可改）。与 historyMax 不同：
+      // historyMax 是「当前配置承诺的上限」（响应带回），historyMaxEntries 是
+      // 设置表单里的那份值 —— 保存成功后两者应相等。
+      historyMaxEntries: 200,
+      // —— 工作区绑定（0.8.1）——
+      // 与 history 同款：null = 还没拉过，[] = 拉过且确实没有绑定。
+      // 「这个项目还没绑过」与「还没去看」是两件事，界面上不给它们同一种空白。
+      bindings: null,
+      // 失效引用（绑定的人设已不存在）与坏行丢弃数，都由服务端如实标注
+      bindingsInvalid: [],
+      bindingsDropped: null,
+      // 「记录可能不完整」的原因，不是失败（同 historyWarning）
+      bindingsWarning: null,
+      bindingsError: null,
+      // 服务端承诺的上限（MAX_BINDINGS / MAX_PATH_LENGTH），由响应带回，
+      // 不在客户端写死 —— 两边各写一份迟早会不一致
+      bindingsMax: null,
+      bindingsMaxPath: null,
+      // 活动会话的解析结果（只读状态：哪个目录现在用的是谁）
+      bindingsSessions: [],
       saving: false,
       error: null
     }
@@ -127,6 +167,16 @@ window.__ModuleLoader__.load({
       return ka.every((key) => shallowEqual(a[key], b[key]))
     }
 
+    // 变更记录只在「追加一条」或「被清空」时变化，两者的**id 序列**都不一样 ——
+    // 所以逐条深比是白费力气（每条含 before/after/personas，深比一次的代价远超收益）。
+    // 比 id 序列足够，且顺带覆盖了「压实后旧条目被淘汰」这种变化。
+    const sameHistory = (a, b) => {
+      if (a === b) return true
+      if (!Array.isArray(a) || !Array.isArray(b)) return false
+      if (a.length !== b.length) return false
+      return a.every((item, index) => item && b[index] && item.id === b[index].id)
+    }
+
     function hostBase() {
       const origin = globalThis.location?.origin
       return origin !== void 0 && origin !== 'null' ? origin : 'http://dsh.internal'
@@ -398,6 +448,8 @@ window.__ModuleLoader__.load({
         s.trailColor = config.trailColor || TRAIL_COLOR_FALLBACK
         s.trailSpeed = config.trailSpeed || 'slow'
         s.trailWidth = config.trailWidth || 'thin'
+        // 变更记录保留条数：服务端 migrate 已夹取到 50–500，这里只兜「缺席」
+        s.historyMaxEntries = Number.isFinite(config.historyMaxEntries) ? config.historyMaxEntries : 200
       }
 
       async loadConfig() {
@@ -500,8 +552,12 @@ window.__ModuleLoader__.load({
         }
       }
 
-      async savePersona(name) {
-        return await this.postJSON('/api/soul/personas/save', { name })
+      // draft（可选）：设置页**还没保存**的草稿字段（0.9.0-r）。
+      // 不带它的话，用户改完表单直接点「存为预设」会存下旧配置（实测过的 bug）。
+      async savePersona(name, draft = null) {
+        const body = { name }
+        if (draft && typeof draft === 'object') body.draft = draft
+        return await this.postJSON('/api/soul/personas/save', body)
       }
 
       async usePersona(name) {
@@ -521,6 +577,235 @@ window.__ModuleLoader__.load({
         return await this.postJSON('/api/soul/personas/delete', { name })
       }
 
+      // —— 变更记录（0.8.0）——
+      async fetchHistory() {
+        return await this.postJSON('/api/soul/history', null, { method: 'GET' })
+      }
+
+      // 拉取记录并写入 store。
+      //
+      // 与 loadPersonas 同款：失败必须留下痕迹，否则界面永远停在「加载中」，
+      // 与「真的还没有记录」无从区分 —— 而「到底有没有记录」正是这一组的全部意义。
+      async loadHistory() {
+        if (this.disposed) return
+        try {
+          const payload = await this.fetchHistory()
+          this.store.update((s) => {
+            // 内容相同就保留旧引用，理由同 loadPersonas：每 2s 轮询都会解析出**新数组**，
+            // 直接赋值会让 store 的浅比较永远判「变了」，整页白重渲染。
+            const next = Array.isArray(payload.entries) ? payload.entries : []
+            s.history = sameHistory(s.history, next) ? s.history : next
+            // warning 是「记录可能不完整」，不是失败：不写进 historyError，
+            // 否则界面会把「只显示了最近 1000 条」报成红色错误。
+            s.historyWarning = payload.warning ? String(payload.warning) : null
+            s.historyMax = Number.isFinite(payload.max) ? payload.max : s.historyMax
+            s.historyError = null
+          })
+        } catch (err) {
+          this.store.update((s) => {
+            s.historyError = messageOf(err)
+          })
+        }
+      }
+
+      // 撤销：把配置退回到目标记录**发生之前**。
+      //
+      // 409（diverged）与 400（找不到 / 记录被压实淘汰）都是**预期内的拒绝**，
+      // 不是网络故障 —— 直接把服务端文案抛给调用方，由界面原样展示。
+      // 服务端已经把原因写得能读懂（「记录与当前配置对不上，可能有人手工改过配置文件」），
+      // 这里再包一层「撤销失败：...」只会把关键信息埋起来。
+      async rollbackHistory(id) {
+        const payload = await this.postJSON('/api/soul/history/rollback', { id })
+        if (!this.disposed) {
+          this.store.update((s) => {
+            this.applyConfig(s, payload.config)
+            s.error = null
+          })
+        }
+        return payload
+      }
+
+      async restorePersona(id) {
+        const payload = await this.postJSON('/api/soul/history/restore-persona', { id })
+        if (!this.disposed) {
+          this.store.update((s) => {
+            this.applyConfig(s, payload.config)
+            s.error = null
+          })
+        }
+        return payload
+      }
+
+      async clearHistory() {
+        return await this.postJSON('/api/soul/history/clear')
+      }
+
+      // —— 工作区绑定（0.8.1）——
+      async fetchBindings() {
+        return await this.postJSON('/api/soul/bindings', null, { method: 'GET' })
+      }
+
+      // 把服务端返回的绑定视图整块写进 store。
+      //
+      // 绑定的每个字段都是「服务端说了算」：失效引用由服务端按当前预设库算出，
+      // sessions 的生效人设由服务端走与真实装配同一条解析路径得出。客户端只负责
+      // 原样保留 —— 自己再算一遍只会有两种结果：算对了白算，算错了两个地方打架。
+      applyBindings(s, payload) {
+        // bindings 是**对象**（目录 → 人设名），不是数组 —— 服务端 bindingsView
+        // 直接透传 soul-bindings.json 的映射。上一版这里写的是 Array.isArray 兜底，
+        // 一旦为假就会把整张表静默吞成空：界面显示「还没有绑定任何目录」而文件里
+        // 其实有。故按对象判，且**缺字段时保留旧值**而不是清空。
+        const raw = payload.bindings
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) s.bindings = raw
+        else if (raw === null || Array.isArray(raw)) s.bindings = {}
+        s.bindingsInvalid = Array.isArray(payload.invalid) ? payload.invalid : []
+        s.bindingsDropped = Number.isFinite(payload.dropped) ? payload.dropped : 0
+        // warning 是「看到的不是全部」，不是失败，所以不写进 bindingsError
+        s.bindingsWarning = payload.warning ? String(payload.warning) : null
+        s.bindingsMax = Number.isFinite(payload.max) ? payload.max : s.bindingsMax
+        s.bindingsMaxPath = Number.isFinite(payload.maxPathLength)
+          ? payload.maxPathLength
+          : s.bindingsMaxPath
+        s.bindingsSessions = Array.isArray(payload.sessions) ? payload.sessions : []
+      }
+
+      // 拉取绑定视图并写 store。
+      //
+      // 失败必须留下痕迹（同 loadHistory）：界面停在「加载中」与「确实没有绑定」
+      // 长得一样，而这一组的全部意义就是回答「我这个项目现在是谁」。
+      async loadBindings() {
+        if (this.disposed) return
+        try {
+          const payload = await this.fetchBindings()
+          this.store.update((s) => {
+            this.applyBindings(s, payload)
+            s.bindingsError = null
+          })
+        } catch (err) {
+          this.store.update((s) => {
+            s.bindingsError = messageOf(err)
+          })
+        }
+      }
+
+      // 新增或改绑一个目录。写成功的结果里带回完整视图，直接铺进 store，
+      // 省掉一次「写完立刻再拉一遍」的往返。
+      async saveBinding(dir, persona) {
+        const payload = await this.postJSON('/api/soul/bindings', { dir, persona })
+        if (!this.disposed) {
+          this.store.update((s) => {
+            this.applyBindings(s, payload)
+            s.bindingsError = null
+          })
+        }
+        return payload
+      }
+
+      async removeBinding(dir) {
+        const payload = await this.postJSON('/api/soul/bindings/delete', { dir })
+        if (!this.disposed) {
+          this.store.update((s) => {
+            this.applyBindings(s, payload)
+            s.bindingsError = null
+          })
+        }
+        return payload
+      }
+
+      // —— 会话级覆盖（0.9.0-d）——
+      //
+      // 与绑定刻意分开：会话覆盖是**状态**（随会话生灭），绑定是**配置**。
+      // 因此这里不写 store 的全局字段，由调用组件自己持有结果 —— 一份覆盖只对
+      // 它所属的那个会话有意义，塞进全局 store 会让两个会话的 tab 互相串味。
+      async fetchSessionScope(sessionId) {
+        const query = `?sessionId=${encodeURIComponent(sessionId)}`
+        return await this.postJSON(`/api/soul/session-scope${query}`, null, { method: 'GET' })
+      }
+
+      // 当前会话的作用域（生效人设 + 来源层级）。与 fetchSessionScope 同源，
+      // 但走固定路径：这个端点给「输入框下方的标签」用 —— 它在会话外，
+      // 拿不到 sessionId，只能由宿主通过 scope:'session' 槽位的标准 props 传进来。
+      async fetchCurrentSessionScope(sessionId) {
+        const query = `?sessionId=${encodeURIComponent(sessionId)}`
+        return await this.postJSON(`/api/soul/session-scope/current${query}`, null, { method: 'GET' })
+      }
+
+      // personaName：用户实际点的预设名。一并提交，服务端把它记进 sidecar ——
+      // 否则「当前生效的是哪个预设」只能靠字段反查，而反查在多个预设字段相同时不确定。
+      // 写 store：会话作用域变了 → 所有看它的人（header 标签、会话 tab）一起刷新。
+      //
+      // 不可变更新（新建对象）—— store 是浅比较，原地改同一个对象不会触发订阅者。
+      setSessionScope(sessionId, scope) {
+        if (this.disposed) return
+        this.store.update((s) => {
+          s.sessionScopes = { ...s.sessionScopes, [String(sessionId)]: scope }
+        })
+      }
+
+      async saveSessionScope(sessionId, overrides, personaName = null) {
+        const body = { sessionId, overrides }
+        if (typeof personaName === 'string' && personaName !== '') body.personaName = personaName
+        const payload = await this.postJSON('/api/soul/session-scope', body)
+        // 服务端已经回了解析结果（activePersona / source / workspaceTitle）——
+        // 直接落进 store，header 标签立刻就是新值，不必再发一次请求。
+        if (payload && typeof payload === 'object') {
+          this.setSessionScope(sessionId, {
+            activePersona: typeof payload.activePersona === 'string' ? payload.activePersona : null,
+            recordedPersona: typeof payload.recordedPersona === 'string' ? payload.recordedPersona : null,
+            globalPersona: typeof payload.globalPersona === 'string' ? payload.globalPersona : null,
+            source: typeof payload.source === 'string' ? payload.source : null,
+            workspaceId: payload.workspaceId || null,
+            workspaceTitle: typeof payload.workspaceTitle === 'string' ? payload.workspaceTitle : null,
+            override: payload.override || null
+          })
+        }
+        return payload
+      }
+
+      async clearSessionScope(sessionId) {
+        const payload = await this.postJSON('/api/soul/session-scope', { sessionId, clear: true })
+        if (payload && typeof payload === 'object') {
+          this.setSessionScope(sessionId, {
+            activePersona: typeof payload.activePersona === 'string' ? payload.activePersona : null,
+            recordedPersona: null,
+            globalPersona: typeof payload.globalPersona === 'string' ? payload.globalPersona : null,
+            source: typeof payload.source === 'string' ? payload.source : null,
+            workspaceId: payload.workspaceId || null,
+            workspaceTitle: typeof payload.workspaceTitle === 'string' ? payload.workspaceTitle : null,
+            override: null
+          })
+        }
+        return payload
+      }
+
+      // —— 工作区人设（0.9.0-e）——
+      //
+      // 与绑定、会话覆盖都不同：工作区列表是**宿主**的，插件只能列与改，
+      // 不能增删（那是侧边栏的职责）。所以这里只有读 + 绑定/解绑。
+      async fetchWorkspaces() {
+        return await this.postJSON('/api/soul/workspaces', null, { method: 'GET' })
+      }
+
+      async saveWorkspacePersona(workspaceId, persona) {
+        return await this.postJSON('/api/soul/workspaces', { workspaceId, persona })
+      }
+
+      async removeWorkspacePersona(workspaceId) {
+        return await this.postJSON('/api/soul/workspaces/delete', { workspaceId })
+      }
+
+      // —— 会话覆盖清理（0.9.0-f）——
+      //
+      // 默认 dry-run：不传 apply 就**绝不会删**。真删必须显式 apply:true ——
+      // 这个默认值站在"不删"那一侧，因为删除不可逆。
+      async scanSessionScopeGc() {
+        return await this.postJSON('/api/soul/session-scope/gc', {})
+      }
+
+      async applySessionScopeGc() {
+        return await this.postJSON('/api/soul/session-scope/gc', { apply: true })
+      }
+
       // 统一请求：body 为 null 时不携带请求体（GET 用）
       async postJSON(path, body, overrides = {}) {
         const url = new URL(path, hostBase())
@@ -605,12 +890,28 @@ window.__ModuleLoader__.load({
       '.soul-accordion-icon{flex:0 0 18px;color:var(--dsw-alias-label-secondary);font-size:18px;line-height:1;text-align:center}',
       // 收起态只有触发器一个子元素 ⇒ 四角都要圆（展开态由上面的顶圆角规则负责）
       '.soul-accordion:not(.soul-accordion-open) .soul-accordion-trigger{border-radius:calc(var(--dsw-radius-xl) - .5px)}',
+      // 折叠标题旁的问号提示已取消（说明改放展开区内的 .soul-note）：
+      // head 层随之删除 —— 触发器恢复成 section 的直接子元素，无需 flex 包裹。
       '.soul-accordion-body{padding:14px;border-top:.5px solid var(--dsw-alias-settings-card-stroke);background:transparent}',
       '.soul-field select:focus,.soul-field textarea:focus,.soul-field input[type=text]:focus{outline:none;border-color:var(--dsw-alias-brand-primary);box-shadow:0 0 0 2px color-mix(in srgb, var(--dsw-alias-brand-primary) 25%, transparent)}',
       '.soul-toggle{display:flex;align-items:center;gap:8px;margin-bottom:14px}',
       '.soul-toggle label{margin:0;font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary)}',
       '.soul-buttons{display:flex;gap:8px;margin-top:2px}',
-      '.soul-quick-toggle{position:relative;isolation:isolate;display:inline-flex;align-items:center;gap:6px;min-height:28px;overflow:hidden;padding:4px 10px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:transparent;color:var(--dsw-alias-label-secondary);font:inherit;font-size:12px;line-height:18px;cursor:pointer;white-space:nowrap}',
+      // 允许换行、不裁切。
+      //
+      // 为什么必须改容器（而不只是放宽 max-width）：
+      // · white-space:nowrap 让整串强制一行 —— 输入框左侧空间有限，必然溢出；
+      // · overflow:hidden 把溢出部分**直接裁掉** —— 这就是「展示不全」的直接原因；
+      // · inline-flex + align-items:center 在多行时也对不齐。
+      //
+      // max-width:min(100%, 22em) 给个上限：太长的自定义预设名不至于把整条输入框撑开。
+      // overflow:hidden 是**扫光特效的裁切边界**，不能去掉：
+      // 扫光（::before）从 translateX(100%) 扫到 translateX(-100%)，两端都会超出按钮。
+      //
+      // ⚠️ 0.9.0-g 为了让文字完整显示曾把它去掉 —— 结果特效溢出到按钮外面。
+      // 两者并不真正冲突：文字现在允许换行且有 max-width 上限，**不会溢出**内容盒；
+      // 真正溢出的只有扫光伪元素。所以 overflow:hidden 裁的是扫光，不裁文字。
+      '.soul-quick-toggle{position:relative;isolation:isolate;display:inline-flex;align-items:center;flex-wrap:wrap;gap:2px 6px;min-height:28px;max-width:min(100%,22em);overflow:hidden;padding:4px 10px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:transparent;color:var(--dsw-alias-label-secondary);font:inherit;font-size:12px;line-height:18px;cursor:pointer;white-space:normal}',
       '.soul-quick-toggle:hover{border-color:var(--dsw-alias-brand-primary);color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-hover)}',
       '.soul-quick-toggle[data-enabled="true"]{color:var(--dsw-alias-brand-primary)}',
       '.soul-quick-toggle[data-enabled="true"]:hover{border-color:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-state-error-primary);box-shadow:0 0 0 2px color-mix(in srgb,var(--dsw-alias-state-error-primary) 18%,transparent)}',
@@ -632,7 +933,46 @@ window.__ModuleLoader__.load({
       '@keyframes soul-status-pulse{0%,100%{box-shadow:0 0 0 0 color-mix(in srgb,var(--dsw-alias-state-success-primary) 35%,transparent);opacity:.75}50%{box-shadow:0 0 0 4px color-mix(in srgb,var(--dsw-alias-state-success-primary) 0%,transparent);opacity:1}}',
       '@media (prefers-reduced-motion:reduce){.soul-quick-toggle[data-enabled="true"] .soul-quick-toggle-dot{animation:none}.soul-quick-toggle[data-enabled="true"]:hover::before,.soul-quick-toggle[data-enabled="false"]:hover::before{animation:none;transform:none}}',
       // 快捷开关里追加的人设名（B）：同样单行省略，避免把底栏撑宽
-      '.soul-quick-toggle-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:9em;opacity:.85}',
+      '.soul-quick-toggle-name{min-width:0;opacity:.85;overflow-wrap:anywhere}',
+      // 来源层级标签（全局 / 工作区 / 本会话覆盖）：次要色小字，与人设名分开 ——
+      // 它是注解不是主信息。max-width 限制它别把人设名挤掉。
+      '.soul-quick-toggle-scope{flex:none;color:var(--dsw-alias-label-tertiary);font-size:10px;line-height:14px;overflow-wrap:anywhere}',
+      // —— 会话 header 的人设标签（0.9.0-h）——
+      //
+      // 规格抄宿主的 AgentPresetLabel（同一位置的「创造模式」标签）——
+      // 但**底色 token 换掉了**：它用的 --dsw-alias-fill-tsp-secondary 在宿主主题里
+      // **没有定义**（只被那个包自己引用，var() 会静默回退），抄过来就是抄一个失效值。
+      // 这里用真实存在的 --dsw-alias-bg-module-platform。
+      // 22px 高、次要底色、圆角、小字、inline-flex。
+      // 宿主在窄容器时会把 header 标签隐藏（@container (width<=540px)），
+      // 我们跟着做 —— 空间不够时宁可不显示，也不要挤坏标题行。
+      '.soul-session-persona-label{display:inline-flex;align-items:center;gap:6px;max-width:min(100%,320px);height:22px;padding:0 8px;border-radius:var(--dsw-radius-xs);background:var(--dsw-alias-bg-module-platform);color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:22px;white-space:nowrap;overflow:hidden}',
+      // hero 区（新会话行）的落点：与邻居（工作区 chip / 创造模式）同一行右对齐。
+      // flex:none 防止被 chip 的 flex 收缩挤扁。
+      '.soul-session-persona-label[data-in-hero="true"]{flex:none}',
+      '.soul-session-persona-label-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+      // 图标：与文字同色但略淡（图标是标识，文字是主信息）
+      '.soul-session-persona-label-icon{flex:none;opacity:.75}',
+      // 侧栏会话行 hover 面具徽标（0.9.0-ab）：与行内其它 hover 按钮对齐
+      '.soul-sidebar-persona-badge{display:inline-flex;align-items:center;justify-content:center;width:20px;height:20px;color:var(--dsw-alias-label-tertiary)}',
+      '.soul-sidebar-persona-badge-icon{display:block}',
+      // hover 信息卡里的「人设」一行（0.9.0-al）：逐项对齐宿主同槽位住户
+      // （ui-schedule SessionScheduleHover 的 .task / .taskIcon / .taskName / .taskTiming）：
+      //   .task{display:flex;align-items:flex-start;gap:8px;min-width:0}
+      //   .taskIcon{color:#cfd3d6;flex:none;height:16px;display:inline-flex}
+      //   .taskName{color:#fff;font-size:12px;line-height:16px}
+      //   .taskTiming{color:#cfd3d6;font-size:12px;line-height:16px}
+      //
+      // ⚠️ 这里必须用**不随主题翻转的 static 色**，不能用 --dsw-alias-* 主题 token：
+      // 宿主的 hover 卡片永远是深色的（它的 #fff / #cfd3d6 也是写死的），
+      // 而 alias token 会随主题翻转 —— 浅色主题下是深色值，照搬就成了深字压深底。
+      // #fff = bluish-00、#cfd3d6 = bluish-300（静态色板里的同值项，见 ui-theme）。
+      '.soul-hover-persona{display:flex;align-items:flex-start;gap:8px;min-width:0}',
+      '.soul-hover-persona-icon{flex:none;display:inline-flex;align-items:center;height:16px;color:var(--dsw-static-neutral-bluish-300)}',
+      '.soul-hover-persona-label{flex:none;color:var(--dsw-static-neutral-bluish-300);font-size:12px;line-height:16px}',
+      '.soul-hover-persona-name{min-width:0;color:var(--dsw-static-neutral-bluish-00);font-size:12px;line-height:16px;overflow-wrap:break-word}',
+      '.soul-session-persona-label-scope{flex:none;font-size:11px;opacity:.8}',
+      '@container (width<=540px){.soul-session-persona-label{display:none}}',
       // 错误提示：颜色改用宿主真实存在的 state-error-primary（原先引用不存在的 token ⇒ 渲染成黑色）
       '.soul-error{margin-top:8px;padding:10px 12px;background:var(--dsw-alias-interactive-bg-hover-danger,rgba(236,19,19,.05));border:.5px solid var(--dsw-alias-state-error-primary);border-radius:var(--dsw-radius-sm);color:var(--dsw-alias-state-error-primary);font-size:12px;line-height:18px;width:100%;box-sizing:border-box}',
       '.soul-hint{position:relative;display:inline-flex;align-items:center;margin-left:6px;color:var(--dsw-alias-label-secondary);cursor:help;vertical-align:middle}',
@@ -643,6 +983,15 @@ window.__ModuleLoader__.load({
       '.soul-hint:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px;border-radius:3px}',
       '.soul-hint:focus-visible .soul-hint-tip{opacity:1;visibility:visible}',
       '.soul-status{margin-top:6px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary)}',
+      // 说明块：一组「读到就够、不需要操作」的文字（预设收录范围 + 变更记录去哪了）。
+      // 与 .soul-status 同排印，但允许多行分行 —— 多条说明挤成一段会像一句话里
+      // 混了两件事。行距靠 line-height 自然撑开，不上边框（不是引用也不是分隔）。
+      '.soul-note{margin-top:10px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary)}',
+      '.soul-note > div + div{margin-top:2px}',
+      // 一句话 + 一个问号：正文不再换行成段，问号挂在句子末尾（0.8.1 文案瘦身）。
+      // align-items:baseline 让问号与 12px 文字同基线 —— 用 center 会让它看起来浮起来。
+      '.soul-note-inline{display:flex;align-items:baseline;gap:6px;flex-wrap:wrap}',
+      '.soul-note-text{min-width:0}',
       '.soul-dirty{color:var(--dsw-alias-state-warn-primary)}',
       // —— 人设预设：竖版卡牌 + 堆叠轮播 ——
       // 方案 B：插画是卡面主视觉（方形满铺），名称与摘要压在图上由渐变承接，
@@ -740,6 +1089,8 @@ window.__ModuleLoader__.load({
       '.soul-persona-art-title{position:absolute;left:12px;right:12px;bottom:10px;display:flex;flex-direction:column;gap:2px;min-width:0}',
       '.soul-persona-name{display:flex;align-items:center;gap:6px;min-width:0;color:var(--dsw-static-neutral-bluish-00,#fff);font-size:14px;font-weight:600;line-height:20px}',
       '.soul-persona-label{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;text-shadow:0 1px 6px rgba(0,0,0,.5)}',
+      // 作用域标注（全局）：小一号、半透明，跟在预设名后面 —— 注解而非主信息。
+      '.soul-persona-scope-tag{flex:none;padding:0 5px;border-radius:999px;background:rgba(255,255,255,.18);color:inherit;font-size:9px;font-weight:600;line-height:14px;letter-spacing:.2px;opacity:.75}',
       '.soul-persona-meta{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-static-neutral-bluish-100,#d3dbf5);font-size:11px;line-height:16px;text-shadow:0 1px 6px rgba(0,0,0,.5)}',
       // 内置徽标：图上用半透明玻璃底（白底徽标在深色图上会太跳）
       '.soul-persona-badge{position:absolute;top:10px;left:10px;flex:none;padding:2px 7px;border-radius:999px;border:1px solid rgba(255,255,255,.34);background:rgba(255,255,255,.2);color:var(--dsw-static-neutral-bluish-00,#fff);font-size:10px;font-weight:600;line-height:14px;letter-spacing:.3px;backdrop-filter:blur(8px)}',
@@ -791,7 +1142,12 @@ window.__ModuleLoader__.load({
       // 类名保留是为了兼容既有断言与「空占位不能是可点控件」这条历史契约。
       '.soul-persona-slot{display:none}',
       // 徽标：对齐宿主的 rowTag 规格（.5px 描边、radius-xs、11px/16px）
-      '.soul-persona-badge{border:.5px solid var(--dsw-alias-border-l3);border-radius:var(--dsw-radius-xs);color:var(--dsw-alias-label-secondary);flex:none;padding:0 6px;font-size:11px;line-height:16px;white-space:nowrap}',
+      // ⚠️ 这条是**卡背头**的徽标样式（描边式、inline、灰字），必须限定在 .soul-persona-back-head 内。
+      // 若不限定，它会覆盖卡面那条（absolute、玻璃底、白字）—— 而它自己又不写 position，
+      // 于是卡面徽标变成「白字玻璃底 + absolute 定位 + 描边式字号」的混合体，在插画上漂。
+      // 会话「人设」tab 的卡面徽标曾因此漂移：它没有 .soul-persona-back-head 包裹，
+      // 上面那条 position:static 的重置不生效。
+      '.soul-persona-back-head .soul-persona-badge{border:.5px solid var(--dsw-alias-border-l3);border-radius:var(--dsw-radius-xs);color:var(--dsw-alias-label-secondary);flex:none;padding:0 6px;font-size:11px;line-height:16px;white-space:nowrap}',
       // ——「存为新预设」命名弹层（方案 A）——
       // 遮罩用 fixed 全屏 + 半透明；层级要低于 toast（toast 是 10000），
       // 因为保存成功后 toast 要能盖在弹层之上被看到。
@@ -802,6 +1158,17 @@ window.__ModuleLoader__.load({
       // 「将保存 / 不含」两行说明：这是消除「不知道存了哪些值」的关键，用弱化样式但仍可读
       '.soul-modal-note{display:flex;flex-direction:column;gap:4px;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
       '.soul-modal-note-excl{color:var(--dsw-alias-label-tertiary)}',
+      // 「保存后立即应用」复选框（0.9.0-t）
+      '.soul-modal-check{display:flex;align-items:flex-start;gap:8px;font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary);cursor:pointer}',
+      '.soul-modal-check input{flex:none;margin-top:3px;width:14px;height:14px;cursor:pointer}',
+      '.soul-modal-check-hint{flex:none;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}',
+      // 「更新到预设」列表（0.9.0-s）：每行一个可选预设名。
+      '.soul-update-list{display:flex;flex-direction:column;gap:4px;max-height:240px;overflow:auto}',
+      '.soul-update-item{box-sizing:border-box;display:flex;align-items:center;gap:8px;width:100%;padding:8px 10px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;line-height:20px;text-align:left;cursor:pointer}',
+      '.soul-update-item:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover);border-color:var(--dsw-alias-brand-primary)}',
+      '.soul-update-item:disabled{cursor:wait;opacity:.6}',
+      '.soul-update-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex:1 1 auto}',
+      '.soul-update-badge{flex:none;color:var(--dsw-alias-brand-primary);font-size:11px;line-height:16px}',
       '.soul-modal-actions{display:flex;justify-content:flex-end;gap:8px}',
       // 二次确认态：描边 → 实心危险色，**并放宽按钮**。
       // 放宽是必须的：普通态按「删除」两字定宽 43px，而「确认删除？」是五个字，
@@ -869,6 +1236,283 @@ window.__ModuleLoader__.load({
       '.soul-trail-preview{position:relative;margin-top:6px;padding:16px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-xl);background:var(--dsw-alias-settings-card-fill)}',
       '.soul-trail-preview[data-soul-trail="on"]{border-color:transparent}',
       '.soul-trail-preview-text{font-size:12px;color:var(--dsw-alias-label-tertiary)}',
+      // —— 变更记录（0.8.0）——
+      // 顶部状态行 + 右侧「清空记录」：与 .soul-drift 同款（space-between），
+      // 因为它也是「一句话 + 一个行动」的形态。
+      '.soul-history-head{display:flex;align-items:center;justify-content:space-between;gap:8px;margin-top:6px}',
+      '.soul-history-count{margin-top:0}',
+      // —— 插件详情页外壳（0.8.1 双入口）：对齐宿主 detailSection 排版 ——
+      // 宿主 .detailSection = flex column / gap 12px；.sectionHead = baseline 对齐；
+      // .sectionTitle = 14px/500/20px；.sectionCount = 12px 次要色（fO69Vq_ 前缀）。
+      '.soul-detail-history{display:flex;flex-direction:column;gap:12px}',
+      '.soul-detail-history-head{display:flex;align-items:baseline;gap:10px}',
+      '.soul-detail-history-title{margin:0;font-size:14px;font-weight:500;line-height:20px;color:var(--dsw-alias-label-primary)}',
+      '.soul-detail-history-count{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // —— 会话「人设」tab（0.9.0-d）——
+      // 它是 conversation.view 的一种，宿主把它画在对话区里，所以要自带内边距与
+      // 最大宽度（不像设置页有外层容器）。参数抄宿主的 viewArea 排版：
+      // 内容左对齐、与对话区同宽的上限，宽屏下不铺满整行。
+      // 与宿主 conversation 输入框同宽：直接读 --dsh-chat-content-width
+      // （宿主 body 规则里定义为 clamp(680px, 64%, 920px)）。宿主调宽窄、tab 跟着变，
+      // 比硬编码 720px 更稳；变量缺失时回退 720px（与上一版一致）。
+      '.soul-session-persona{display:flex;flex-direction:column;gap:16px;max-width:var(--dsh-chat-content-width,720px);width:100%;margin:0 auto;padding:20px 4px;box-sizing:border-box;color:var(--dsw-alias-label-primary)}',
+      '.soul-session-head{display:flex;align-items:baseline;gap:8px}',
+      '.soul-session-title{margin:0;font-size:14px;font-weight:500;line-height:20px}',
+      // 容器内间距全部交给 gap:16px 统一 —— .soul-field 自带的 margin-bottom:14px
+      // 会让「临时改用」与下方卡牌的间距比上方标题的 16px 小，视觉不齐（用户反馈）。
+      // ⚠️ 0.9.0-af 补全：光清 .soul-field 不够 —— 前置排查发现容器内还有多处
+      // 自带纵向 margin：.soul-field-label(8px bottom)、.soul-status(top)、
+      // .soul-session-split(top:2px)、.soul-session-clear-row(top)、
+      // .soul-session-detail-actions(top)、.soul-session-scope-hint(top)。
+      // 每漏一处，三段间距就有一段不齐（用户连续报了两次）。
+      // 通配清零容器内所有子元素的纵向 margin —— 间距语义只归 gap 一处管。
+      // 面板内部的 margin（detail-actions/scope-hint 的 margin-top）不受影响：
+      // 它们在 .soul-session-detail 里，不是本容器的直接子元素。
+      '.soul-session-persona > *{margin-top:0;margin-bottom:0}',
+      // 「有覆盖」标记：一眼看出这个会话与外面的设置不同，避免用户以为改的是全局
+      '.soul-session-badge{padding:0 6px;border-radius:var(--dsw-radius-sm);background:color-mix(in srgb,var(--dsw-alias-brand-primary) 12%,transparent);color:var(--dsw-alias-brand-primary);font-size:11px;line-height:18px}',
+      // 当前生效卡：与设置页 .soul-bindings-current 同款观感（描边 + 浅底）
+      '.soul-session-current{display:flex;flex-direction:column;gap:2px;padding:10px 12px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-layer-1)}',
+      // 名称加粗（0.9.0-aa）：这是 tab 里最重要的信息，500 不够突出
+      '.soul-session-current-name{font-size:14px;line-height:22px;font-weight:700}',
+      // 特质突出点（非默认维度）小字：与名称同行，弱于名称
+      '.soul-session-current-traits{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:22px;font-weight:400}',
+      '.soul-session-current-source{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // 人设胶囊：可点即选，选中的用主色实心（与设置页的「使用中」同一套色彩语义）
+      '.soul-session-chips{display:flex;flex-wrap:wrap;gap:8px}',
+      // 与「使用中」按钮（.soul-persona-action，36px / radius-md）并排，
+      // 高度与圆角必须一致 —— 否则同一行里一高一低。
+      // .soul-session-chip 现在只剩「取消本会话的临时人设」这一个使用点
+      // （0.9.0-d 移除了旧胶囊选择器），直接对齐规格；配色保持描边式（次要动作）。
+      '.soul-session-chip{box-sizing:border-box;display:inline-flex;align-items:center;height:36px;padding:0 14px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-md,12px);background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;line-height:18px;cursor:pointer}',
+      '.soul-session-chip:hover{border-color:var(--dsw-alias-brand-primary);color:var(--dsw-alias-brand-primary)}',
+      '.soul-session-chip:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
+      '.soul-session-chip:disabled{opacity:.5;cursor:default}',
+      '.soul-session-chip-active{border-color:var(--dsw-alias-brand-primary);background:var(--dsw-alias-brand-primary);color:var(--dsw-alias-label-primary-foreground)}',
+      // 「取消本会话的临时人设」用次要色：它可逆，不是破坏性动作
+      '.soul-session-chip-clear{border-color:var(--dsw-alias-brand-primary);color:var(--dsw-alias-brand-primary)}',
+      '.soul-session-clear-row{display:flex;margin-top:10px}',
+      // —— 会话「人设」：左卡牌网格 + 右详情（0.9.0-d 改版）——
+      //
+      // 与设置页的人设卡牌**共用同一套视觉语言**（圆角、描边、浅底、插画 + 压图标题），
+      // 但布局从「叠层轮播 + 3D 翻面」改成「左侧网格选中 + 右侧详情面板」：
+      // 会话面板横向空间窄，左侧是**叠层轮转**而非平铺：中心大卡 + 两侧各露边一张。
+      // 比例：左栏 260px（正好容下 260px 的叠层）+ 右栏自适应；放不下时整体换行。
+      '.soul-session-split{display:flex;gap:18px;align-items:flex-start;flex-wrap:wrap}',
+      // 叠层容器：卡片绝对定位到同一格，靠内联 transform 偏移（与设置页同构）。
+      // overflow:hidden 让两侧露边卡在容器边缘被自然裁掉，观感与设置页一致。
+      // 叠层容器：**1:1**（高度 = 卡宽 210px）。
+      //
+      // 为什么是 1:1：插画资源全是 512×512 正方形，而容器若是竖长的（比如 210×380），
+      // 配合 object-fit:cover 就会**上下裁掉约 44%**，只剩中间一条 —— 看起来像「插画不够大」。
+      // 1:1 容器让插画完整显示，且比原来看到的那条中间带大得多。
+      // 轮播容器：叠层卡 + 下方导航（同一列，纵向）
+      '.soul-session-carousel{flex:0 0 300px;min-width:300px;display:flex;flex-direction:column;align-items:center;gap:10px}',
+      // 0.9.0-ag：soul-field 是普通块容器 —— split 与 detail 垂直堆叠（detail 被
+      // 挤到卡牌下方），这才是「三段间距不一致」的真身。改 flex 行布局后
+      // detail 回到卡牌右侧，split(338) 与 detail(338) 等高。
+      '.soul-field.soul-persona-field{display:flex;gap:18px;align-items:flex-start;flex-wrap:wrap}',
+      '.soul-session-grid{position:relative;width:100%;height:300px;overflow:hidden}',
+      // 单张卡：结构抄 .soul-persona-card 的正面（去掉 3D 翻面 —— 翻面由右栏详情承担）。
+      // ⚠️ 这里**不得**写任何 transform：叠层偏移由内联 style 持有（translateX/scale）；
+      // 若 CSS 也给 transform，两者会互相覆盖。
+      // 插画铺满整张卡：art 绝对定位 inset:0，卡本身只提供定位上下文与圆角裁切。
+      '.soul-session-card{position:absolute;top:0;bottom:0;left:0;right:0;width:300px;margin:0 auto;display:block;overflow:hidden;border-radius:var(--dsw-radius-xl);border:.5px solid var(--dsw-alias-settings-card-stroke);background:var(--dsw-alias-settings-card-fill);box-shadow:var(--dsw-shadow-lv2,0 2px 8px rgba(0,0,0,.08));box-sizing:border-box;font-size:12px;line-height:18px;transition:transform .3s cubic-bezier(.22,.61,.36,1),opacity .3s ease;cursor:pointer}',
+      '.soul-session-card:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}',
+      // 生效中的那张：**不加描边**（0.9.0-u）。
+      //
+      // 历史：曾用主色描边 + 1px 光晕表达「生效」，但主色在浅色主题下解析为近黑
+      // （#0f1115），压在插画上是一圈很重的黑框 —— 用户反馈太丑。
+      // 生效标识已有**左下角的 ★ 角标**（半透明深底圆 + 白字，不依赖遮罩），
+      // 描边是重复信号，去掉后 ★ 成为唯一依据，观感干净得多。
+      // 若将来要恢复描边，注意别与 hover 的 translateY 合成同一个 transform。
+      '.soul-session-card[data-effective="true"]{box-shadow:var(--dsw-shadow-lv2,0 2px 8px rgba(0,0,0,.08))}',
+      // 选中的那张：**只抬高一档 + 投影加深**，不再加描边。
+      //
+      // 为什么去掉那圈 1px 光晕：它与上面「生效」的描边是同一个主色，浅色主题下两者都是
+      // 近黑 ⇒ 生效卡与选中卡叠在一起时是「双层黑框」，完全分不出哪个是「正在生效」、
+      // 哪个是「正在浏览」。把描边独占给「生效」，选中只留位移与投影，两个状态就分开了。
+      '.soul-session-card[data-selected="true"]{transform:translateY(-1px);box-shadow:0 4px 14px rgba(0,0,0,.18),var(--dsw-shadow-lv2,0 2px 8px rgba(0,0,0,.08))}',
+      // 生效 **且** 选中（最常见：中心卡正是生效的那张）⇒ 投影取两者中更重的一档。
+      '.soul-session-card[data-selected="true"][data-effective="true"]{transform:translateY(-1px);box-shadow:0 4px 14px rgba(0,0,0,.18)}',
+      // 插画区：**绝对定位铺满整张卡**。
+      // 原来它在文档流里（1:1 的画面 + 下方文字区），现在没有文字区了 ⇒ 直接铺满，
+      // 画面大得多。aspect-ratio 不再需要（高度由容器决定）。
+      '.soul-session-card .soul-persona-art{position:absolute;inset:0;width:100%;height:100%;aspect-ratio:auto}',
+      // 生效标记 ★：放左下角（右上角被「i / n」占了，左上角被内置徽标占了）。
+      // 半透明深底 + 白字 —— 不依赖遮罩，在任何底图上都读得清。
+      '.soul-session-card-star{position:absolute;left:10px;bottom:10px;width:22px;height:22px;display:flex;align-items:center;justify-content:center;border-radius:50%;background:rgba(10,14,35,.55);color:var(--dsw-static-neutral-bluish-00,#fff);font-size:13px;line-height:1;backdrop-filter:blur(6px)}',
+      // 右栏详情：复用设置页卡背的元素（.soul-persona-dims / .soul-persona-fulltext），
+      // 这里只补容器与滚动。高度上限避免长文把整个面板撑得比卡牌栏高太多。
+      // 详情面板：**固定高度**（0.9.0-z）。
+      //
+      // 为什么不用 max-height：那会让面板高度跟着内容走 —— 每个人设的
+      // 自定义指令长度不同，切换时面板一高一低地跳，左侧轮播也跟着晃。
+      // 固定 height 后切换任何预设面板都不变，只有内容区滚动。
+      //
+      // 340px = 原上限值，实测能容纳六维度 + 约 12 行指令；更长的指令在内部滚动。
+      '.soul-session-detail{flex:1 1 220px;min-width:200px;display:flex;flex-direction:column;gap:8px;padding:12px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-xl);background:var(--dsw-alias-settings-card-fill);height:338px;box-sizing:border-box;overflow:hidden}',
+      '.soul-session-detail-empty{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      '.soul-session-detail-head{display:flex;align-items:center;gap:6px;flex-wrap:wrap}',
+      '.soul-session-detail-name{font-size:14px;font-weight:600;line-height:20px;color:var(--dsw-alias-label-primary)}',
+      '.soul-session-detail-actions{display:flex;gap:8px;flex-wrap:wrap;margin-top:2px}',
+      '.soul-session-detail-actions .soul-persona-action{flex:1 1 auto}',
+      // 作用范围说明（0.9.0-z）：小字次要色，一行即可
+      '.soul-session-scope-hint{margin-top:2px;color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px}',
+      // 覆盖里的字段名：等宽，便于与配置键对上
+      '.soul-session-fields{display:flex;flex-wrap:wrap;gap:6px}',
+      '.soul-session-field{padding:1px 6px;border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary);font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:11px;line-height:18px}',
+      // —— 工作区人设平铺卡片（0.9.0-e）——
+      // 竖排卡片而非下拉：工作区通常 3–10 个，每张要同时表达「名字 + 路径 + 绑定态」。
+      '.soul-ws-list{display:flex;flex-direction:column;gap:8px}',
+      '.soul-ws-card{display:flex;align-items:center;gap:12px;flex-wrap:wrap;padding:10px 12px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-layer-1)}',
+      // 已绑定：左侧一道主色竖条（与「命中当前目录」同一套视觉语义）
+      '.soul-ws-card-bound{box-shadow:inset 2px 0 0 var(--dsw-alias-brand-primary)}',
+      '.soul-ws-main{display:flex;flex-direction:column;gap:2px;min-width:0;flex:1}',
+      '.soul-ws-title{font-size:13px;line-height:20px;font-weight:500;color:var(--dsw-alias-label-primary);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+      '.soul-ws-path{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-secondary);font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:11px;line-height:18px}',
+      '.soul-ws-invalid{display:flex;flex-wrap:wrap;gap:6px;color:var(--dsw-alias-state-error-primary);font-size:12px;line-height:18px}',
+      '.soul-ws-actions{display:flex;align-items:center;gap:8px;flex:none}',
+      '.soul-ws-persona{color:var(--dsw-alias-brand-primary);font-size:12px;line-height:18px}',
+      '.soul-ws-unbound{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}',
+      // 工作区卡片上的文字按钮（0.9.0-ao）：规格照抄宿主设置-模型页的
+      // 「编辑 / 删除」（ui-settings-models 的 .secondaryButton / .dangerButton）。
+      //
+      // 编辑（secondaryButton）：描边 + label-primary 文字 + hover 浅灰底
+      //   {border:.5px solid border-l3;color:label-primary;background:0 0}
+      //   {border-radius:sm;height:28px;padding:0 10px;font-size:12px;line-height:18px}
+      //   :hover{background:interactive-bg-hover-solid}
+      // 删除（dangerButton）：**无描边** + 红字 + hover 浅红底
+      //   {color:state-error-primary;background:0 0;border:none}
+      //   :hover{background:interactive-bg-hover-danger}
+      '.soul-ws-btn{box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;gap:4px;border:.5px solid var(--dsw-alias-border-l3);border-radius:var(--dsw-radius-sm);height:28px;padding:0 10px;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;line-height:18px;cursor:pointer}',
+      '.soul-ws-btn:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover-solid)}',
+      '.soul-ws-btn:disabled{opacity:.4;cursor:default}',
+      '.soul-ws-btn:focus-visible{box-shadow:0 0 0 2px var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary));outline:none}',
+      '.soul-ws-btn-danger{border:none;color:var(--dsw-alias-state-error-primary)}',
+      '.soul-ws-btn-danger:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover-danger)}',
+      // 待确认：文字已经变成「确认解绑…」，再叠一层浅红底让它更醒目
+      '.soul-ws-btn-armed{background:var(--dsw-alias-interactive-bg-hover-danger)}',
+      '.soul-ws-action{box-sizing:border-box;display:inline-flex;align-items:center;height:26px;padding:0 10px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;line-height:18px;cursor:pointer}',
+      // ⚠️ hover **只改边框，不改文字色**（0.9.0-am）。
+      // 原先这里还有 color:brand-primary —— 主色按钮（深底白字）hover 时文字被压成
+      // 近黑色，黑底黑字＝整块全黑；同时它也压掉了 .soul-ws-action-armed 的红字。
+      '.soul-ws-action:hover{border-color:var(--dsw-alias-brand-primary)}',
+      '.soul-ws-action:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
+      '.soul-ws-action:disabled{opacity:.5;cursor:default}',
+      // 「绑定人设」是这一页的主操作：实心主色
+
+      // 解绑 armed：危险色（与删除预设同一套）
+      '.soul-ws-action-armed{border-color:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-state-error-primary)}',
+      // 内联展开的人设胶囊：占满整行，与卡片内容左对齐
+      '.soul-ws-picker{flex-basis:100%;display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding-top:8px;border-top:.5px solid var(--dsw-alias-settings-card-stroke)}',
+      '.soul-ws-picker-label{flex:none;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // 会话清理的按钮行：与设置页的 .soul-buttons **分开命名**（那个 class 语义是
+      // 「保存按钮区」，复用它会让"保存设置在哪里"这类断言抓到错误的块 —— 实测抓到过）。
+      '.soul-sessions-actions{display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-top:4px}',
+      // 保留条数（0.8.1 从设置页迁来）：一行「标签 + 下拉 + 提示」。
+      // 下拉不撑满整行 —— 它是容量参数，不是表单主字段，铺满会显得比记录本身还重。
+      '.soul-history-retention{display:flex;align-items:center;gap:8px;flex-wrap:wrap}',
+      '.soul-history-retention label{margin:0;flex:none;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      '.soul-history-retention select{flex:none;width:auto;min-width:112px;padding:4px 8px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;line-height:18px}',
+      '.soul-history-retention select:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
+      '.soul-history-retention select:disabled{opacity:.6}',
+      // 下拉右侧的问号提示沿用设置页的 SoulHint；这里只压掉它的上边距以对齐这一行
+      '.soul-history-retention .soul-hint{margin-top:0}',
+      // —— 设置页指引（0.8.1 双入口）——
+      // 列表整体迁去插件详情页后，设置页不再有指引行；去向说明并入「人设预设」
+      // 展开区的 .soul-note（见下方 .soul-note 注释），不再单独占一行。
+      // 危险色描边文字钮（规格抄 .soul-persona-danger）：清空记录不可逆，
+      // 是这一组唯一的破坏性动作。撤销按钮不用危险色 —— 它可以再撤销一次改回来。
+      '.soul-history-clear{box-sizing:border-box;flex:none;display:inline-flex;align-items:center;height:24px;padding:0 10px;border:.5px solid var(--dsw-alias-state-error-primary);border-radius:var(--dsw-radius-sm);background:transparent;color:var(--dsw-alias-state-error-primary);font:inherit;font-size:12px;line-height:18px;cursor:pointer;white-space:nowrap}',
+      '.soul-history-clear:hover{background:var(--dsw-alias-interactive-bg-hover-danger,rgba(236,19,19,.05))}',
+      '.soul-history-clear:focus-visible{outline:2px solid var(--dsw-alias-state-error-primary);outline-offset:1px}',
+      // armed：实心危险色 + 文案变成「确认清空？」（样式抄 .soul-persona-danger-armed）
+      '.soul-history-clear-armed{background:var(--dsw-alias-state-error-primary);border-color:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-label-primary-foreground)}',
+      '.soul-history-warning{margin-top:6px}',
+      '.soul-history-list{display:flex;flex-direction:column;gap:6px;margin:10px 0 0 0;padding:0;list-style:none}',
+      '.soul-history-item{border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-module-platform);overflow:hidden}',
+      // 头部是「主体按钮 + 操作按钮」两段：主体撑满左侧，操作固定在右，
+      // 因此主体按钮必须 min-width:0 才能让里面的 ellipsis 生效。
+      '.soul-history-item-head{display:flex;align-items:center;gap:8px;padding-right:8px}',
+      '.soul-history-item-main{display:flex;align-items:center;gap:8px;flex:1;min-width:0;padding:8px 10px;border:0;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;line-height:18px;text-align:left;cursor:pointer}',
+      '.soul-history-item-main:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.soul-history-item-main:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:-2px}',
+      // 时间与来源不参与收缩（它们短且固定），字段名列表吃掉剩余宽度并省略。
+      '.soul-history-time{flex:none;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px;white-space:nowrap}',
+      '.soul-history-source{flex:none;padding:0 6px;border:.5px solid var(--dsw-alias-border-l3);border-radius:var(--dsw-radius-xs);color:var(--dsw-alias-label-secondary);font-size:11px;line-height:16px;white-space:nowrap}',
+      '.soul-history-fields{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-secondary)}',
+      '.soul-history-item-actions{display:flex;align-items:center;gap:6px;flex:none}',
+      '.soul-history-action{box-sizing:border-box;flex:none;display:inline-flex;align-items:center;height:24px;padding:0 8px;border:.5px solid var(--dsw-alias-brand-primary);border-radius:var(--dsw-radius-sm);background:transparent;color:var(--dsw-alias-brand-primary);font:inherit;font-size:12px;line-height:18px;cursor:pointer;white-space:nowrap}',
+      '.soul-history-action:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.soul-history-action:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
+      '.soul-history-action-armed{border-color:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-state-error-primary)}',
+      '.soul-history-detail{padding:0 10px 10px 10px;border-top:.5px solid var(--dsw-alias-settings-card-stroke)}',
+      '.soul-history-diff{display:flex;flex-direction:column;gap:10px;padding-top:8px}',
+      // 「展开即全文」：每行竖排 —— 字段名、原值块、新值块依次铺开。
+      // 曾经是 88px/1fr/14px/1fr 的四列网格 + 单行省略，但自定义指令几百字时
+      // 一行省略号等于没给；竖排让长文本换行铺开，短字段也不吃亏。
+      '.soul-history-diff-row{display:flex;flex-direction:column;gap:4px;font-size:12px;line-height:18px}',
+      '.soul-history-diff-field{color:var(--dsw-alias-label-tertiary);word-break:break-word}',
+      // pre-wrap：介绍 / 自定义指令里的换行是内容的一部分，压成一行会看不出改了什么。
+      '.soul-history-diff-cell{display:flex;flex-direction:column;gap:2px}',
+      '.soul-history-diff-tag{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px}',
+      '.soul-history-diff-value{min-width:0;white-space:pre-wrap;word-break:break-word}',
+      // 原值块垫底色区分「这是被替换掉的」，新值保持正文色；省略号阶段二值同权重，全文阶段必须能一眼分清。
+      '.soul-history-diff-cell:first-of-type .soul-history-diff-value{color:var(--dsw-alias-label-tertiary)}',
+      '.soul-history-diff-value{color:var(--dsw-alias-label-primary)}',
+      '.soul-history-diff-persona{margin-top:8px;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // 分页器（0.9.0-ai）：左按钮 / 页码 / 右按钮，纵向居中对齐
+      '.soul-history-pager{align-self:flex-start;display:flex;align-items:center;gap:8px;margin-top:8px}',
+      '.soul-history-pageinfo{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // —— 设置页「工作区绑定」分组（0.8.1-d）——
+      // 外层容器只负责块间距：三段是 .soul-field，彼此之间要留出与其它分组一致的空。
+      '.soul-bindings{display:flex;flex-direction:column;gap:14px}',
+      // 尺寸全部抄本文件既有的宿主对齐规格：输入框复用 .soul-field 的控件规则，
+      // 小按钮复用 .soul-history-action（24px 高 / 描边 / brand 文字），
+      // 危险态复用 .soul-history-action-armed 的语义（实心危险色 + 换文案）。
+      // 这里只补「绑定」独有的排版：路径与元信息的折叠、列表的树形前缀、当前目录的高亮。
+      // 当前会话目录卡：一行等宽路径 + 两行元信息（生效人设 / 来源），
+      // 路径靠 title 给全文、靠 shortenPath 截中段 —— 不换行，避免长路径把卡片撑高
+      '.soul-bindings-current{display:flex;flex-direction:column;gap:4px;padding:8px 10px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-layer-1)}',
+      // 路径用等宽字体：宿主主题**没有** --dsw-font-mono 这个 token（实测校对过），
+      // 引一个不存在的 var() 只会静默回退，所以这里直接给系统等宽字体栈。
+      '.soul-bindings-path{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary)}',
+      '.soul-bindings-meta{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // 输入框 + 「选择目录…」同一行：按钮不缩放（flex:none），输入框吃满剩余宽度
+      '.soul-bindings-new{display:flex;align-items:center;gap:8px;margin-bottom:8px}',
+      '.soul-bindings-new:last-child{margin-bottom:0}',
+      '.soul-bindings-new label{margin:0;flex:none}',
+      // 0.9.0-ah：按钮改用宿主 ui.Button 后，这里**不能再覆盖 background / color**
+      // —— 原先的 color:brand-primary 压住了宿主给的白字，hover 时深底深字变全黑。
+      // 只保留布局：这一行的输入框吃掉剩余宽度，其余控件不缩放。
+      '.soul-bindings-new > *{flex:none}',
+      '.soul-bindings-new input{flex:1 1 auto;min-width:0}',
+      // 人设下拉不许被压到看不见：flex:none + 固定最小宽度
+      '.soul-bindings-new select{flex:none;width:auto;min-width:120px}',
+      // 降级提示：与 .soul-status 同色同字号，贴在选择器原位（说明为什么按钮不见了）
+      '.soul-bindings-hint{margin:-2px 0 8px 0;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // 列表：与 .soul-history-list 同规格（紧凑、无项目符号）
+      '.soul-bindings-rows{display:flex;flex-direction:column;gap:6px;margin:10px 0 0 0;padding:0;list-style:none}',
+      '.soul-bindings-row{display:flex;align-items:center;gap:6px;min-height:32px;padding:4px 8px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-layer-1)}',
+      // 高亮命中当前会话的那一条：左侧一道 brand 竖条，比整块上色更安静
+      '.soul-bindings-row[data-current="true"]{border-color:var(--dsw-alias-brand-primary);box-shadow:inset 2px 0 0 var(--dsw-alias-brand-primary)}',
+      '.soul-bindings-tree{flex:none;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}',
+      // 目录名是这一行的主体：吃掉剩余宽度，过长则省略（全文在 title）
+      '.soul-bindings-dir{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary)}',
+      '.soul-bindings-here{flex:none;padding:0 6px;border-radius:var(--dsw-radius-sm);background:color-mix(in srgb,var(--dsw-alias-brand-primary) 12%,transparent);color:var(--dsw-alias-brand-primary);font-size:11px;line-height:18px}',
+      '.soul-bindings-bad{flex:none;color:var(--dsw-alias-state-error-primary);font-size:12px;line-height:18px}',
+      '.soul-bindings-select{flex:none;width:auto;min-width:96px;max-width:160px}',
+      // 解绑的「待确认」态：只染文字颜色（宿主按钮的底色/悬停不动，避免旧的全黑问题）
+      '.soul-bindings-act-armed{color:var(--dsw-alias-state-error-primary)}',
+      // 未绑定回落行：虚线框＝「这是规则、不是一条记录」
+      '.soul-bindings-fallback{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:8px 10px;border:.5px dashed var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm)}',
+      '.soul-bindings-fallback-text{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      // 「看到的不是全部」不是失败：用次要色，与红字错误（.soul-error）区分。
+      // 宿主主题**没有**黄色 warning token（实测：--dsw-alias-label-warning /
+      // --dsw-alias-state-warning-primary 都不存在），自己硬编一个黄色又会跟主题脱节，
+      // 所以按「不重要但要知道」处理，与同组其它提示同色。
+      '.soul-bindings-warning{color:var(--dsw-alias-label-secondary)}',
       // 开了「减少动态效果」时：光轨层与卡片停动画。
       // 结果提示（绿字/红字）不需要在这里照顾 —— 它们是静态文字、没有动画。
       '@media (prefers-reduced-motion:reduce){.soul-trail-layer{animation:none}.soul-persona-card{animation:none!important;transition:none}}'
@@ -930,6 +1574,7 @@ window.__ModuleLoader__.load({
       'field.tables': '表格',
       'hint.tables': '在回复风格和语调的基础上选择额外的自定义特质项。控制回答中表格的使用程度。',
       'field.replyLength': '回复长度',
+      'field.activePersonaName': '最近使用的预设',
       'hint.replyLength': '控制回答的篇幅。选「适中」时不额外约束，由 Agent 自行判断。',
       'field.language': '输出语言',
       'hint.language': '设置 Agent 回复你使用的语言，同时影响 /soul 命令的输出语言。',
@@ -940,6 +1585,12 @@ window.__ModuleLoader__.load({
       'personas.save': '保存当前为预设',
       // 方案 A：入口移出预设列表，与「保存设置」并列（文案用「存为预设…」表示会再问一步）
       'personas.saveAs': '存为预设…',
+      // 更新到预设（0.9.0-s）：与「存为预设」并列 —— 前者覆盖已有，后者新建。
+      'personas.updateTo': '更新到预设',
+      'personas.updateNone': '还没有可更新的自建预设。内置预设不可修改。',
+      'personas.updateCovers': '会把「关于你」之外的人格字段（风格、特质、长度、指令）写入所选预设。',
+      'personas.updateExcludes': '不会包含昵称、职业、介绍 —— 它们不属于预设。',
+      'notice.personaUpdated': '已更新预设「{name}」。',
       'personas.saveNameLabel': '新预设名称',
       'personas.saveConfirm': '保存',
       'personas.saveCovers': '将保存：回复风格和语调、特质、回复长度、输出语言、自定义指令',
@@ -965,7 +1616,13 @@ window.__ModuleLoader__.load({
       'personas.builtin': '内置',
       'personas.drift': '当前配置与任何预设都不一致。',
       'personas.driftAction': '存为新预设',
-      'personas.hint': '预设只保存 Agent 的人设（风格 / 特质 / 回复长度 / 输出语言 / 自定义指令），不含「关于你」；内置预设随插件提供，不可删除',
+      // 一句话就够了：用户的真实疑问只有「存了这个会不会连我的昵称也一起换掉」。
+      // 「不可删除」不再写进正文 —— 每张内置卡上都挂着「内置」徽标、且根本没有删除按钮，
+      // 说第二遍只是噪音。
+      'personas.hint': '预设只含 Agent 的人格；你的昵称与自我介绍不随预设切换。',
+      // hover 里的全文：原来那段正文原样保留在这里，需要细节的人仍能读到，
+      // 不需要的人不必被它占两行。
+      'personas.hintDetail': '预设有风格、特质（标题和列表 / 表情符号 / 表格）、回复长度、输出语言、自定义指令；不含「关于你」里的昵称、职业与自我介绍。内置预设随插件提供，不可删除。',
       'style.professional': '专业严谨',
       'style.casual': '轻松自然',
       'style.humorous': '幽默风趣',
@@ -994,9 +1651,183 @@ window.__ModuleLoader__.load({
       'meta.tables.less': '少用表格',
       'meta.language.zh': '中文',
       'meta.language.en': '英文',
+      // —— 工作区绑定（0.8.1）——
+      'group.bindings': '工作区绑定',
+      'bindings.hint': '绑定记住的是目录而不是会话：在绑定的目录（含子目录）里开的会话自动用这个人设。保存后立刻对活动会话生效，其他目录不受影响。',
+      // 当前会话目录卡
+      'bindings.currentTitle': '当前会话目录',
+      'bindings.noSession': '当前没有活动会话，所以没有「现在用什么」可显示。',
+      'bindings.noCwd': '这个会话没有工作目录，任何绑定都不会命中 —— 它会用全局配置。',
+      'bindings.effective': '生效人设',
+      'bindings.source': '来源',
+      'bindings.sourceGlobal': '全局配置（没有绑定的目录都归它管）',
+      'bindings.sourceInherited': '{dir}（上级目录继承）',
+      'bindings.choose': '选择目录…',
+      'bindings.manualLabel': '目录路径',
+      'bindings.manualPlaceholder': '粘贴一个绝对路径，例如 D:\\项目A',
+      'bindings.bindDir': '绑定',
+      // 结果提示：就地在分组内显示绿字/红字（与变更记录同款，不用 toast）
+      'bindings.needDir': '先填一个目录，或者点「选择目录…」。',
+      'bindings.bound': '已绑定：{dir} → {name}',
+      'bindings.unbound': '已解绑：{dir}',
+      'bindings.unbindMissing': '这条绑定已经不在列表里了（可能是在别处删掉的），刷新一下即可。',
+      'bindings.pickerUnavailable': '当前连接方式无法调起系统目录选择器，请手动粘贴路径。',
+      'bindings.moreSessions': '另有 {count} 个活动会话',
+      // 绑定列表
+      'bindings.listTitle': '已绑定的目录',
+      'bindings.loading': '加载中...',
+      'bindings.loadFailed': '无法读取工作区绑定：{reason}',
+      'bindings.empty': '还没有绑定任何目录。',
+      'bindings.count': '共 {count} 条 · 最多 {max} 条',
+      'bindings.here': '当前目录',
+      'bindings.persona': '使用的人设',
+      'bindings.unbind': '解绑',
+      'bindings.unbindArmed': '确认解绑？',
+      'bindings.invalid': '人设「{name}」已不存在',
+      'bindings.invalidHint': '这条绑定不会生效，改绑或解绑它。',
+      'bindings.dropped': '有 {count} 行无效记录已被忽略。',
+      'bindings.warning': '绑定表可能不完整：{reason}',
+      'bindings.maxPath': '路径上限 {max} 字符。',
+      'bindings.fallback': '未绑定的目录使用全局配置',
+      'bindings.change': '改',
+      // —— 会话级人设（0.9.0-d）——
+      // tab 标题：与设置页「个性化」、详情页「人设预设」同一套用词。
+      'session.tabLabel': '人设',
+      'session.title': '本会话的人设',
+      'session.current': '当前生效',
+      'session.workspace': '所属工作区',
+      'session.workspaceUnknown': '未归入任何工作区',
+      'session.source.global': '全局配置',
+      'session.source.workspace': '工作区「{name}」',
+      'session.source.directory': '目录绑定',
+      'session.source.session': '本会话临时覆盖',
+      'session.noPersona': '自定义（与任何预设都不匹配）',
+      'session.overrideTitle': '临时改用',
+      'session.overrideHint': '只影响这个会话；新会话仍按工作区或全局设置。',
+      'session.pickPersona': '换成预设…',
+      'session.customOverrides': '自定义字段',
+      'session.clear': '取消本会话的临时人设',
+      'session.cleared': '已取消本会话的临时人设，现在跟随上层配置。',
+      'session.applied': '本会话已改用「{name}」。',
+      'session.loading': '加载中...',
+      'session.loadFailed': '无法读取本会话的人设：{reason}',
+      'session.applyFailed': '设置失败：{reason}',
+      'session.noOverrides': '没有临时覆盖。',
+      'session.badge': '有覆盖',
+      // 输入框标签的来源层级：告诉用户「现在这个人设是哪一层定的」
+      'quick.scopeSession': '本会话覆盖',
+      'quick.scopeWorkspace': '工作区「{name}」',
+      'quick.scopeDirectory': '目录绑定',
+      'quick.scopeGlobal': '全局配置',
+      'quick.scopeUnknown': '会话状态未知',
+      // 设置页预设行的作用域标注：设置页没有会话上下文，写的是**全局**
+      'personas.scopeGlobal': '全局',
+      // 卡面按钮：与设置页「使用 / 使用中」同一套语义，只是措辞更贴会话语境
+      'session.useCard': '用这个',
+      'session.pickHint': '点左侧任意一张卡，在这里查看它的完整人设。',
+      'session.chipInUse': '使用中',
+      // —— 工作区人设（详情页，0.9.0-e）——
+      'workspaces.title': '工作区人设',
+      'workspaces.count': '{bound} / {total} 已绑定',
+      'workspaces.hint': '工作区里的人设只作用于该工作区下的会话；未绑定的回落全局配置。',
+      'workspaces.unbound': '未绑定',
+      'workspaces.bind': '绑定人设',
+      'workspaces.rebind': '改绑',
+      'workspaces.unbind': '解除绑定',
+      'workspaces.unbindArmed': '确认解除？',
+      'workspaces.empty': '还没有工作区。在侧边栏「添加工作区」后回来这里配置人设。',
+      'workspaces.loading': '加载中...',
+      'workspaces.loadFailed': '无法读取工作区：{reason}',
+      'workspaces.serverProblem': '宿主服务不可用：{reason}',
+      'workspaces.invalid': '人设「{name}」已不存在',
+      'workspaces.invalidHint': '这条绑定不会生效；改绑或解除它。',
+      'workspaces.applied': '「{name}」已绑定到「{title}」。',
+      'workspaces.unbindDone': '已解除「{title}」的人设绑定。',
+      'workspaces.applyFailed': '设置失败：{reason}',
+      'workspaces.pickPersona': '选择人设',
+      // —— 会话覆盖清理（0.9.0-f）——
+      'sessions.title': '会话覆盖',
+      'sessions.hint': '会话里临时改过的人设。会话不存在后会先观察 30 天，确认不回再清理。',
+      'sessions.scanning': '正在检查…',
+      'sessions.scanFailed': '无法完成检查：{reason}',
+      'sessions.scanIncomplete': '宿主未提供会话清单，本次不做任何判定 —— 「没看到」不等于「已删除」。',
+      'sessions.summary': '共 {total} 个 · 待观察 {markable} · 可回收 {collectable} · 损坏 {quarantine}',
+      'sessions.collect': '清理可回收项',
+      'sessions.collectArmed': '确认清理 {count} 项？',
+      'sessions.collected': '已清理 {count} 项。',
+      'sessions.nothing': '没有可回收的条目。',
+      'sessions.previewHint': '预览不会删除任何文件；确认后才会真的清理。',
       'group.tool': 'Agent 工具',
       'field.toolConfirm': '人设变更需确认',
       'hint.toolConfirm': '开启后，Agent 改人设会先在输入框处弹出审批面板（Enter 允许 / Esc 拒绝）。若会话审批通道不可用（策略为 never），则退化为待确认提议，需用 /soul confirm 处理 —— 此时建议关闭本开关，否则每次改动都要手输命令。',
+      // —— 变更记录（0.8.0）——
+      'group.history': '变更记录',
+      'history.empty': '还没有任何变更记录。',
+      'history.loading': '加载中...',
+      'history.loadFailed': '无法读取变更记录：{reason}',
+      'history.summary': '最近 {count} 条 · 最多保留 {max} 条',
+      'history.prev': '上一页',
+      'history.next': '下一页',
+      'history.pageInfo': '第 {page} / {total} 页 · 共 {count} 条',
+      'history.clear': '清空记录',
+      'history.clearArmed': '确认清空？',
+      'history.clearDone': '已清空 {count} 条变更记录。',
+      // 按钮用「撤销」而不是「恢复」：点一条记录的结果是**把这一次改动撤掉**
+      // （连同它之后的），不是「切回那天的状态」。
+      'history.restore': '撤销这一次',
+      'history.restoreArmed': '撤销？',
+      'history.restoreDone': '已撤销 {count} 次改动。',
+      'history.restoreUnchanged': '在撤销之前，这些改动就已经被后续改动改回去了。',
+      'history.restorePreset': '恢复此预设',
+      'history.restorePresetDone': '已恢复预设「{name}」。',
+      'history.restorePresetSkipped': '未恢复「{name}」：{reason}',
+      'history.skip.exists': '当前已有同名的预设',
+      'history.skip.builtin': '这是内置预设',
+      'history.skip.invalid-name': '名字不合法',
+      'history.restoreSkippedNote': '已恢复 {count} 个，另有 {skipped} 个未恢复。',
+      'history.diverged': '记录与当前配置对不上，无法撤销。可能有人手工改过配置文件。',
+      'history.warning': '记录可能不完整：{reason}',
+      'history.footer': '撤销人设配置，不影响人设预设库。',
+      'history.fields': '涉及 {fields}',
+      'history.field.from': '原值',
+      'history.field.to': '新值',
+      'history.personasAdded': '新增预设 {names}',
+      'history.personasRemoved': '删除预设 {names}',
+      'history.personasUpdated': '覆盖预设 {names}',
+      // —— label：条目的人类可读上下文（0.8.0 打磨）——
+      // 折叠行里「应用预设 · 自定义指令」答不了「应用的是什么」；有 label 时拼在来源后面。
+      'history.labelSuffix': '：{label}',
+      'history.source.web': '网页保存',
+      'history.source.command': '斜杠命令',
+      'history.source.tool': 'Agent 工具',
+      'history.source.service': '插件调用',
+      'history.source.persona': '应用预设',
+      'history.source.rollback': '撤销',
+      'history.source.restorePersona': '恢复预设',
+      // —— 变更记录：列表渲染补充（0.8.0-d）——
+      // 服务端没带回容量上限时的退路：宁可不提「最多保留 N 条」，也不编一个数字出来。
+      'history.summaryCount': '最近 {count} 条',
+      // 双入口（0.8.1）：主入口在插件详情页，设置页不再留独立指引行（突兀且占地）；
+      // 变更记录的主入口在插件详情页。这里不再罗列「撤销、恢复预设、清空都在那里」
+      // —— 那是三个按钮的名字，点进去自然看得到；罗列只会把一行提示撑成一段话。
+      'history.entryHint': '改动都能撤销',
+      // hover 全文：具体的「在哪儿、能做什么」。正文只留一句判断，细节按需展开。
+      'history.entryHintMore': '变更记录在插件详情页（插件管理 → 已安装插件 → dsh-soul）：撤销某次改动及其之后的全部改动、恢复被删的预设、清空记录，都在那里。',
+      // —— 变更记录保留条数（0.8.0 打磨）——
+      'history.maxEntries': '保留条数',
+      'history.maxEntriesHint': '变更记录最多保留多少条。超出后自动丢弃最旧的记录；条数越多，可撤销的范围越大。',
+      'history.maxEntriesDefault': '{count} 条（默认）',
+      'history.maxEntriesOption': '{count} 条',
+      'history.maxEntriesSaved': '保留条数已改为 {count} 条。',
+      'history.timeJustNow': '刚刚',
+      'history.timeMinutes': '{count} 分钟前',
+      'history.timeHours': '{count} 小时前',
+      'history.timeDays': '{count} 天前',
+      // 空值必须显式画出来：留空会被读成「渲染坏了」，而「这次把它清空了」是一条事实
+      'history.valueEmpty': '（空）',
+      // 服务端不记空条目，所以这一句正常情况下到不了屏幕；但记录文件是可以被手工
+      // 改坏的，真遇到时宁可写「无字段变化」，也不要显示成裸键名 history.emptyFields。
+      'history.emptyFields': '无字段变化',
       'button.save': '保存设置',
       'button.saving': '保存中...',
       'button.cancel': '取消',
@@ -1011,6 +1842,11 @@ window.__ModuleLoader__.load({
       'notice.reset': '已重置为默认值。',
       'notice.resetRecovered': '已重置为默认值（损坏的配置已备份）。',
       'notice.personaSaved': '已保存预设「{name}」。',
+      'notice.personaSavedAndApplied': '已保存并应用预设「{name}」。',
+      'personas.applyAfterSave': '保存后立即应用',
+      'sidebar.personaTip': '人设：{name}',
+      'sidebar.personaRow': '人设',
+      'personas.applyAfterSaveHint': '不勾选则保留当前配置不变（表单恢复到已保存的设置）',
       'notice.personaUsed': '已应用预设「{name}」。',
       'notice.personaUnchanged': '预设与当前配置一致。',
       'notice.personaDeleted': '已删除预设「{name}」。',
@@ -1091,6 +1927,7 @@ window.__ModuleLoader__.load({
       'field.tables': 'Tables',
       'hint.tables': 'An extra trait layered on top of style & tone. Controls how much answers rely on tables.',
       'field.replyLength': 'Reply length',
+      'field.activePersonaName': 'Last used persona',
       'hint.replyLength': 'Controls how long answers are. "Balanced" adds no constraint and lets the agent decide.',
       'field.language': 'Output language',
       'hint.language': 'Sets the language the agent replies in; also affects the /soul command output.',
@@ -1100,6 +1937,11 @@ window.__ModuleLoader__.load({
       'group.personas': 'Personas',
       'personas.save': 'Save current as persona',
       'personas.saveAs': 'Save as persona…',
+      'personas.updateTo': 'Update preset',
+      'personas.updateNone': 'No editable custom presets yet. Built-in presets cannot be modified.',
+      'personas.updateCovers': 'Writes the persona fields (style, traits, length, instructions) into the selected preset.',
+      'personas.updateExcludes': 'Nickname, occupation and bio are not included — they are not part of a persona.',
+      'notice.personaUpdated': 'Updated preset "{name}".',
       'personas.saveNameLabel': 'New persona name',
       'personas.saveConfirm': 'Save',
       'personas.saveCovers': 'Saves: reply style & tone, traits, reply length, reply language, custom instructions',
@@ -1124,7 +1966,8 @@ window.__ModuleLoader__.load({
       'personas.builtin': 'Built-in',
       'personas.drift': 'The current config matches no preset.',
       'personas.driftAction': 'Save as new preset',
-      'personas.hint': 'A persona saves the agent personality only (style / traits / reply length / reply language / custom instructions), never your own identity fields; built-ins ship with the plugin and cannot be deleted',
+      'personas.hint': 'Personas hold only the agent personality; your nickname and bio never switch with a persona.',
+      'personas.hintDetail': 'A persona covers style, traits (headings & lists / emoji / tables), reply length, reply language and custom instructions — never the nickname, occupation or bio under "About you". Built-in personas ship with the plugin and cannot be deleted.',
       'style.professional': 'Professional',
       'style.casual': 'Casual',
       'style.humorous': 'Humorous',
@@ -1153,9 +1996,170 @@ window.__ModuleLoader__.load({
       'meta.tables.less': 'Fewer tables',
       'meta.language.zh': 'Chinese',
       'meta.language.en': 'English',
+      // —— Workspace bindings (0.8.1) ——
+      'group.bindings': 'Workspace bindings',
+      'bindings.hint': 'A binding remembers a directory, not a session: sessions opened in that directory (or below it) use the bound persona. Saving takes effect for active sessions right away; other directories are untouched.',
+      'bindings.currentTitle': 'Current session directory',
+      'bindings.noSession': 'No active session, so there is no "in effect right now" to show.',
+      'bindings.noCwd': 'This session has no working directory, so no binding can match it — it uses the global config.',
+      'bindings.effective': 'Persona in effect',
+      'bindings.source': 'Source',
+      'bindings.sourceGlobal': 'Global config (everything unbound falls back to it)',
+      'bindings.sourceInherited': '{dir} (inherited from a parent directory)',
+      'bindings.choose': 'Choose directory…',
+      'bindings.manualLabel': 'Directory path',
+      'bindings.manualPlaceholder': 'Paste an absolute path, e.g. D:\\project-a',
+      'bindings.bindDir': 'Bind',
+      'bindings.needDir': 'Enter a directory first, or use "Choose directory…".',
+      'bindings.bound': 'Bound: {dir} → {name}',
+      'bindings.unbound': 'Unbound: {dir}',
+      'bindings.unbindMissing': 'This binding is no longer in the list (it was probably removed elsewhere); reload to refresh.',
+      'bindings.pickerUnavailable': 'This connection cannot open the system directory picker; paste the path instead.',
+      'bindings.moreSessions': '{count} more active session(s)',
+      'bindings.listTitle': 'Bound directories',
+      'bindings.loading': 'Loading...',
+      'bindings.loadFailed': 'Could not read the workspace bindings: {reason}',
+      'bindings.empty': 'No directory is bound yet.',
+      'bindings.count': '{count} total · up to {max}',
+      'bindings.here': 'This directory',
+      'bindings.persona': 'Persona',
+      'bindings.unbind': 'Unbind',
+      'bindings.unbindArmed': 'Unbind it?',
+      'bindings.invalid': 'Persona "{name}" no longer exists',
+      'bindings.invalidHint': 'This binding will not take effect; rebind or remove it.',
+      'bindings.dropped': '{count} invalid line(s) were ignored.',
+      'bindings.warning': 'The binding table may be incomplete: {reason}',
+      'bindings.maxPath': 'Path limit {max} characters.',
+      'bindings.fallback': 'Unbound directories use the global config',
+      'bindings.change': 'Change',
+      'session.tabLabel': 'Persona',
+      'session.title': 'Persona for this session',
+      'session.current': 'In effect',
+      'session.workspace': 'Workspace',
+      'session.workspaceUnknown': 'Not in any workspace',
+      'session.source.global': 'Global config',
+      'session.source.workspace': 'Workspace "{name}"',
+      'session.source.directory': 'Directory binding',
+      'session.source.session': 'Temporary override for this session',
+      'session.noPersona': 'Custom (matches no preset)',
+      'session.overrideTitle': 'Temporarily use',
+      'session.overrideHint': 'Affects this session only; new sessions follow the workspace or global setting.',
+      'session.pickPersona': 'Switch to a preset…',
+      'session.customOverrides': 'Custom fields',
+      'session.clear': 'Remove this session\'s temporary persona',
+      'session.cleared': "Removed this session's temporary persona; it now follows the upper scopes.",
+      'session.applied': 'This session now uses "{name}".',
+      'session.loading': 'Loading...',
+      'session.loadFailed': 'Could not read this session\'s persona: {reason}',
+      'session.applyFailed': 'Could not apply: {reason}',
+      'session.noOverrides': 'No temporary override.',
+      'session.badge': 'overridden',
+      'quick.scopeSession': 'this session',
+      'quick.scopeWorkspace': 'workspace "{name}"',
+      'quick.scopeDirectory': 'directory binding',
+      'quick.scopeGlobal': 'global config',
+      'quick.scopeUnknown': 'session state unknown',
+      'personas.scopeGlobal': 'Global',
+      'session.useCard': 'Use this',
+      'session.pickHint': 'Pick a card on the left to see its full persona here.',
+      'session.chipInUse': 'In use',
+      'workspaces.title': 'Workspace personas',
+      'workspaces.count': '{bound} / {total} bound',
+      'workspaces.hint': 'A workspace persona applies only to sessions opened in that workspace; unbound workspaces fall back to the global config.',
+      'workspaces.unbound': 'Not bound',
+      'workspaces.bind': 'Bind persona',
+      'workspaces.rebind': 'Change',
+      'workspaces.unbind': 'Unbind',
+      'workspaces.unbindArmed': 'Unbind?',
+      'workspaces.empty': 'No workspaces yet. Add one from the sidebar, then come back here to set its persona.',
+      'workspaces.loading': 'Loading...',
+      'workspaces.loadFailed': 'Could not read workspaces: {reason}',
+      'workspaces.serverProblem': 'Host service unavailable: {reason}',
+      'workspaces.invalid': 'Persona "{name}" no longer exists',
+      'workspaces.invalidHint': 'This binding will not take effect; rebind or remove it.',
+      'workspaces.applied': '"{name}" is now bound to "{title}".',
+      'workspaces.unbindDone': 'Unbound the persona from "{title}".',
+      'workspaces.applyFailed': 'Could not apply: {reason}',
+      'workspaces.pickPersona': 'Pick a persona',
+      'sessions.title': 'Session overrides',
+      'sessions.hint': 'Personas changed for a single session. After the session disappears they are watched for 30 days before cleanup.',
+      'sessions.scanning': 'Checking…',
+      'sessions.scanFailed': 'Could not finish the check: {reason}',
+      'sessions.scanIncomplete': 'The host did not provide a session list, so nothing was decided — "not seen" is not "deleted".',
+      'sessions.summary': '{total} total · {markable} watching · {collectable} collectable · {quarantine} corrupt',
+      'sessions.collect': 'Clean up collectable',
+      'sessions.collectArmed': 'Delete {count} item(s)?',
+      'sessions.collected': 'Cleaned up {count} item(s).',
+      'sessions.nothing': 'Nothing to collect.',
+      'sessions.previewHint': 'Previewing deletes nothing; files are removed only after you confirm.',
       'group.tool': 'Agent tools',
       'field.toolConfirm': 'Require confirmation for persona changes',
       'hint.toolConfirm': 'When on, persona changes by the agent first raise an approval panel above the input box (Enter = allow, Esc = reject). If the session approval channel is unavailable (policy = never), it falls back to a pending proposal applied only via /soul confirm. Under full permissions the panel never appears, so turning this switch off is recommended.',
+      // —— Change history (0.8.0) ——
+      'group.history': 'Change history',
+      'history.empty': 'No changes recorded yet.',
+      'history.loading': 'Loading...',
+      'history.loadFailed': 'Could not read the change history: {reason}',
+      'history.summary': 'Last {count} · keeps up to {max}',
+      'history.prev': 'Previous',
+      'history.next': 'Next',
+      'history.pageInfo': 'Page {page} of {total} · {count} entries',
+      'history.clear': 'Clear history',
+      'history.clearArmed': 'Clear it?',
+      'history.clearDone': 'Cleared {count} change records.',
+      // "Undo" rather than "restore": clicking a record reverts **that change**
+      // (and everything after it), it does not jump back to that day's state.
+      'history.restore': 'Undo this change',
+      'history.restoreArmed': 'Undo?',
+      'history.restoreDone': 'Undid {count} change(s).',
+      'history.restoreUnchanged': 'Those changes had already been reverted by later edits.',
+      'history.restorePreset': 'Restore this preset',
+      'history.restorePresetDone': 'Restored preset "{name}".',
+      'history.restorePresetSkipped': 'Did not restore "{name}": {reason}',
+      'history.skip.exists': 'a preset with that name already exists',
+      'history.skip.builtin': 'it is a built-in preset',
+      'history.skip.invalid-name': 'the name is not valid',
+      'history.restoreSkippedNote': 'Restored {count}; {skipped} were not restored.',
+      'history.diverged': 'The history does not match the current config, so it cannot be undone. The config file may have been edited by hand.',
+      'history.warning': 'The history may be incomplete: {reason}',
+      'history.footer': 'Undoes persona settings only; your preset library is untouched.',
+      'history.fields': 'Touches {fields}',
+      'history.field.from': 'was',
+      'history.field.to': 'now',
+      'history.personasAdded': 'Added preset {names}',
+      'history.personasRemoved': 'Deleted preset {names}',
+      'history.personasUpdated': 'Overwrote preset {names}',
+      'history.labelSuffix': ': {label}',
+      'history.source.web': 'Web save',
+      'history.source.command': 'Slash command',
+      'history.source.tool': 'Agent tool',
+      'history.source.service': 'Plugin call',
+      'history.source.persona': 'Preset applied',
+      'history.source.rollback': 'Undo',
+      'history.source.restorePersona': 'Preset restored',
+      // —— Change history: list rendering (0.8.0-d) ——
+      // Fallback for when the server did not report a capacity: better to omit
+      // "keeps up to N" than to invent a number that reads like a promise.
+      'history.summaryCount': 'Last {count}',
+      // Dual entry (0.8.1): the full view lives on the plugin detail page; the
+      // settings group becomes a pointer line so a low-frequency feature stops
+      // occupying the settings page permanently.
+      'history.entryHint': 'Every change can be undone',
+      'history.entryHintMore': 'Change history lives on the plugin details page (Plugin manager → Installed plugins → dsh-soul): undo a change together with everything after it, restore a deleted preset, and clear the log.',
+      // —— Change history retention (0.8.0 polish) ——
+      'history.maxEntries': 'Entries kept',
+      'history.maxEntriesHint': 'How many change-history entries to keep. Older entries are dropped once the limit is reached; a larger number means a longer undo window.',
+      'history.maxEntriesDefault': '{count} entries (default)',
+      'history.maxEntriesOption': '{count} entries',
+      'history.maxEntriesSaved': 'Entries kept is now {count}.',
+      'history.timeJustNow': 'just now',
+      'history.timeMinutes': '{count} min ago',
+      'history.timeHours': '{count} h ago',
+      'history.timeDays': '{count} d ago',
+      // An empty value must be drawn explicitly: leaving it blank reads as "broken",
+      // while "it was cleared" is itself a fact worth showing.
+      'history.valueEmpty': '(empty)',
+      'history.emptyFields': 'No field changes',
       'button.save': 'Save Settings',
       'button.saving': 'Saving...',
       'button.cancel': 'Cancel',
@@ -1168,6 +2172,11 @@ window.__ModuleLoader__.load({
       'notice.reset': 'Reset to defaults.',
       'notice.resetRecovered': 'Reset to defaults (the damaged config was backed up).',
       'notice.personaSaved': 'Saved persona "{name}".',
+      'notice.personaSavedAndApplied': 'Saved and applied persona "{name}".',
+      'personas.applyAfterSave': 'Apply immediately after saving',
+      'sidebar.personaTip': 'Persona: {name}',
+      'sidebar.personaRow': 'Persona',
+      'personas.applyAfterSaveHint': 'Leave unchecked to keep the current config unchanged (the form reverts to the saved settings)',
       'notice.personaUsed': 'Applied persona "{name}".',
       'notice.personaUnchanged': 'Persona matches current config.',
       'notice.personaDeleted': 'Deleted persona "{name}".',
@@ -1264,14 +2273,110 @@ window.__ModuleLoader__.load({
       { value: 'en', label: 'English' }
     ]
 
-    // 表单字段与 store 字段的一一对应（dirty 检测与保存载荷共用）
-    const FIELD_KEYS = ['enabled', 'nickname', 'occupation', 'bio', 'style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language', 'customInstructions', 'requireToolConfirmation', 'trailEnabled', 'trailColor', 'trailSpeed', 'trailWidth']
+    // 设置页表单驱动的字段（dirty 检测与保存载荷共用）。
+    const FORM_FIELD_KEYS = ['enabled', 'nickname', 'occupation', 'bio', 'style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language', 'customInstructions', 'requireToolConfirmation', 'trailEnabled', 'trailColor', 'trailSpeed', 'trailWidth']
+
+    // 由**别的界面**就地管理、因而不在这张表单里的配置字段：
+    //   · `historyMaxEntries` —— 插件详情页的变更记录区块（改完即时落盘，不经保存按钮）；
+    //   · `workspaces` —— 插件详情页的「工作区人设」区块（同上，0.9.0）。
+    // 两者都是复合/非表单语义：设置页的「保存设置」不该顺手提交它们，否则用户在详情页
+    // 改完的值会被设置页那份**不知道它改过**的旧表单覆盖回去。
+    // activePersonaName（0.9.0-p）同属外部管理：由「使用预设」动作写入，
+    // 设置页表单不直接编辑它 —— 但 FIELD_KEYS 必须覆盖（dirty 对账不漏字段）。
+    const EXTERNALLY_MANAGED_FIELDS = ['historyMaxEntries', 'workspaces', 'activePersonaName']
+
+    // 配置字段全集（宿主 DEFAULT_CONFIG 的对账基准）。
+    // 顺序与 DEFAULT_CONFIG 一致，便于人眼对账；重复字段会让 dirty 判定重复计算。
+    // **表单只认 FORM_FIELD_KEYS** —— 拿全集去判 dirty 会让表单对着一个它并不持有的
+    // 字段反复比较，语义混乱（当前恰好因为两边都是 undefined 而等价，但那是巧合）。
+    const FIELD_KEYS = [...FORM_FIELD_KEYS, ...EXTERNALLY_MANAGED_FIELDS]
+
+    // 变更记录保留条数的可选值。**只放整数档位，不做自由输入**：
+    // 这是个一次设定、此后不再碰的容量参数，自由输入只会带来
+    // 「输 30 被夹到 50」这种需要额外解释的状态。默认档（200）单独标注出来，
+    // 用户想回到出厂设置时一眼能找到。
+    // （0.8.1 起这个下拉在插件详情页的变更记录区块内，不在设置页 —— 见下方
+    //  `HISTORY_MAX_ENTRIES_OPTIONS` 所在位置的说明。）
 
     // 其中真正参与 compilePrompt 的字段子集。
     // 提示词预览只依赖它们：改光轨颜色 / 粗细、切换 set_persona 确认模式都不会改变
     // 编译结果，不该因此重新请求，也不该让预览被标成「未保存」。
     const PROMPT_FIELD_KEYS = ['enabled', 'nickname', 'occupation', 'bio', 'style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language', 'customInstructions']
 
+    // —— 变更记录（0.8.0）——
+    //
+    // 审计字段的文案键。**必须覆盖 lib/history.mjs 的 AUDIT_FIELDS**（= DEFAULT_CONFIG 全键）：
+    // 漏掉一个，时间线里就会露出一串裸键名（`trailWidth`）。有断言盯着这张表。
+    // 复用设置页既有文案而不是另写一份：同一样东西在两处叫不同名字，用户会以为不是一回事。
+    const HISTORY_FIELD_LABELS = {
+      enabled: 'toggle.enabled',
+      nickname: 'field.nickname',
+      occupation: 'field.occupation',
+      bio: 'field.bio',
+      style: 'field.style',
+      headingLists: 'field.headingLists',
+      emoji: 'field.emoji',
+      tables: 'field.tables',
+      replyLength: 'field.replyLength',
+      language: 'field.language',
+      customInstructions: 'field.instructions',
+      requireToolConfirmation: 'field.toolConfirm',
+      trailEnabled: 'trail.enable',
+      trailColor: 'trail.color',
+      trailSpeed: 'trail.speed',
+      trailWidth: 'trail.width',
+      // 保留条数本身也是被审计的字段：改它同样会留一条记录（否则用户改了容量，
+      // 记录里查不到是谁改的），所以它必须有自己的标签。
+      historyMaxEntries: 'history.maxEntries',
+      // 最近一次「使用预设」实际点的名字（0.9.0-p）：切预设同样要留痕，
+      // 否则变更记录里它显示成裸键名。
+      activePersonaName: 'field.activePersonaName'
+    }
+
+    // 与 lib/history.mjs 的 HISTORY_SOURCES 对齐；认不出的来源原样显示。
+    const HISTORY_SOURCES = ['web', 'command', 'tool', 'service', 'persona', 'rollback', 'restorePersona']
+
+    // 一次最多铺开多少条。记录上限是 200 条，全渲染会让这一组比整个设置页还长；
+    // 超出的折成一行「还有 N 条」，想看完的人再点一次。
+    // 变更记录每页条数（0.9.0-ai：原先「先铺 20 条 + 还有 N 条 → 全部摊开」，
+    // 摊开后区块会很长；改为分页，页面高度稳定，也便于回看早期记录。
+    const HISTORY_PAGE_SIZE = 20
+
+    // —— 变更记录保留条数（0.8.1 从设置页迁到插件详情页）——
+    //
+    // 它描述的是「这个区块自己保留多少条」，放在它**自己旁边**才是对话该发生的位置：
+    // 用户在详情页看到「最近 37 条 · 最多保留 200 条」，想改这个 200 时就地能改，
+    // 而不必先去设置页的「人设预设」组里找 —— 那个位置解释不清（它既不是预设，
+    // 也只是「变更记录」这个分组的容量，而设置页早已没有变更记录分组了）。
+    //
+    // 档位由服务端 HISTORY_MAX_ENTRIES 与 clampHistoryMaxEntries 兜底；客户端这组
+    // 常量只负责「给哪些选项」。上限 500 因为条目只存变化字段、远在 512 KB 之内；
+    // 下限 50 因为再小则「上一轮就没了」。
+    const HISTORY_MAX_ENTRIES_OPTIONS = [50, 100, 200, 500]
+    const HISTORY_MAX_ENTRIES_DEFAULT = 200
+
+    // 枚举字段 → 既有文案键的映射表（模块级：SoulSettings 与 SoulHistorySection 共用）。
+    // 枚举值复用设置页的既有文案键（`style.*` / `trait.*` / `trail.speed.*` …），
+    // 布尔用「已开启 / 未开启」，其余原样显示。
+    const HISTORY_ENUM_KEYS = {
+      style: (value) => `style.${value}`,
+      headingLists: (value) => `trait.headingLists.${value}`,
+      emoji: (value) => `trait.emoji.${value}`,
+      tables: (value) => `trait.tables.${value}`,
+      replyLength: (value) => `trait.replyLength.${value}`,
+      trailSpeed: (value) => `trail.speed.${value}`,
+      trailWidth: (value) => `trail.width.${value}`
+    }
+    const HISTORY_ENUM_VALUES = {
+      style: STYLE_VALUES,
+      headingLists: TRAIT_VALUES,
+      emoji: TRAIT_VALUES,
+      tables: TRAIT_VALUES,
+      replyLength: REPLY_LENGTH_VALUES,
+      trailSpeed: TRAIL_SPEED_VALUES,
+      trailWidth: TRAIL_WIDTH_VALUES
+    }
+
     // 提示词小图标：hover / 键盘聚焦都展示说明文字。
     // 此前只有 :hover 可达，且提示节点用 visibility:hidden —— 那会把它移出无障碍树，
     // 键盘与读屏用户拿不到字段说明。这里补 tabIndex 让它可以聚焦，并在 :focus-visible
@@ -1297,22 +2402,1566 @@ window.__ModuleLoader__.load({
       )
     }
 
-    // 可折叠设置面板：同一时间只展开一个区域，并持久化用户最后的选择。
-    function SoulAccordion(props) {
-      const { id, title, summary, open, onToggle, children } = props
-      return e('section', { className: `soul-accordion${open ? ' soul-accordion-open' : ''}` },
-        e('button', {
-          type: 'button',
-          className: 'soul-accordion-trigger',
-          'aria-expanded': open,
-          'aria-controls': `${id}-body`,
-          onClick: onToggle
-        },
-          e('span', { className: 'soul-accordion-title' }, title),
-          e('span', { className: 'soul-accordion-summary' }, summary),
-          e('span', { className: 'soul-accordion-icon', 'aria-hidden': true }, open ? '−' : '+')
-        ),
-        open && e('div', { id: `${id}-body`, className: 'soul-accordion-body' }, children)
+    // 可折叠设置面板：同一时间只展开一个区域，并持久化用户最后的选择。
+    //
+    // 曾经这里有个 `hint` prop，把问号提示渲染在折叠标题旁的 head 里。用户反馈：
+    // 折叠态挂问号等于把说明放在「还没展开就能看到」的位置，而它解释的恰恰是展开后
+    // 的东西。现在说明一律写进 body 里（能直接读的文字优先于 hover），
+    // head 层随之取消 —— 触发器恢复成 section 的直接子元素。
+    function SoulAccordion(props) {
+      const { id, title, summary, open, onToggle, children } = props
+      return e('section', { className: `soul-accordion${open ? ' soul-accordion-open' : ''}` },
+        e('button', {
+          type: 'button',
+          className: 'soul-accordion-trigger',
+          'aria-expanded': open,
+          'aria-controls': `${id}-body`,
+          onClick: onToggle
+        },
+          e('span', { className: 'soul-accordion-title' }, title),
+          e('span', { className: 'soul-accordion-summary' }, summary),
+          e('span', { className: 'soul-accordion-icon', 'aria-hidden': true }, open ? '−' : '+')
+        ),
+        open && e('div', { id: `${id}-body`, className: 'soul-accordion-body' }, children)
+      )
+    }
+
+    // —— 变更记录（0.8.0 → 0.8.1 双入口改造）——
+    //
+    // 0.8.1 起主入口是**插件详情页**（plugins.detail.section 槽位）：
+    // 变更记录是低频的回顾性信息，长期占着设置页主区不值得；详情页地方大，
+    // 可以按宿主 detailSection 的排版充分展示。设置页只留一行指引（见 SoulSettings）。
+    //
+    // 组件收 { useSoulController, controller, t, subject }：subject 由宿主传入
+    //（bundle / item / row 三种形态）—— 只有 dsh-soul 自己的详情页才渲染，
+    // 其他插件的详情页必须渲染 null（槽位契约原话："renders null for a subject
+    // it has nothing for"）。挂载时才拉取：比设置页的「展开才拉」更懒。
+    function SoulHistorySection(props) {
+      const { useSoulController, controller } = props
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      const subject = props.subject || null
+      // 只服务自己的详情页。bundle 形态才有 pkg.name（item/row 形态没有，
+      // 一律不渲染 —— 它们是另一个层级的页面）。
+      if (!subject || subject.kind !== 'bundle' || !subject.pkg || subject.pkg.name !== 'dsh-soul') return null
+
+      const state = useSoulController((state) => state)
+      const { history, historyWarning, historyMax, historyError, historyMaxEntries } = state
+
+      // 结果提示：与设置页同款双轨 —— 成功绿字（role=status）、失败红字（role=alert），
+      // 失败压过成功。独立于 pendingUndo/pendingClear（那两个有 5s 超时）。
+      const [notice, setNotice] = React.useState(null)
+      const [errorNotice, setErrorNotice] = React.useState(null)
+
+      // —— 保留条数（0.8.1 从设置页迁来）——
+      //
+      // 它是**配置字段**（落 soul-config.json、进审计），但在这里是「就地的容量参数」：
+      // 改完立刻 POST，不等设置页那个保存按钮——用户在详情页改完就走人了，
+      // 要求他再去设置页点一次保存，等于挖了个坑。
+      //
+      // 乐观更新 + 失败回滚：先把本地值改成新值（下拉立刻响应），服务端拒绝
+      // （校验 / 磁盘损坏）时退回原值并报红字。不做「保存中禁用」——这是个
+      // 一次性动作，且服务端有写队列，连点几次只会依次落盘。
+      const [retentionPending, setRetentionPending] = React.useState(false)
+      const savedRetention = Number.isFinite(historyMaxEntries) ? historyMaxEntries : HISTORY_MAX_ENTRIES_DEFAULT
+
+      // —— 二次确认与浏览状态（从 SoulSettings 平移，语义不变）——
+      const [pendingUndo, setPendingUndo] = React.useState(null)
+      const [pendingClear, setPendingClear] = React.useState(false)
+      // 展开的是哪一条（存 id 而不是下标：重拉后顺序可能变，存下标会展开错行）。
+      const [expandedEntry, setExpandedEntry] = React.useState(null)
+      // 「还有 N 条」被点开后就一直摊开：记录只在写配置时变。
+      const [historyPage, setHistoryPage] = React.useState(0)
+    // 分页派生值（0.9.0-ai）：记录被清空、或保留条数调小时，页码自动收敛到最后一页 ——
+    // 否则会停在一个不存在的页上（列表空白，分页器却还写着第 5 页）。
+    const historyEntries = Array.isArray(history) ? history : []
+    const historyPageCount = Math.max(1, Math.ceil(historyEntries.length / HISTORY_PAGE_SIZE))
+    const historyPageIndex = Math.min(Math.max(historyPage, 0), historyPageCount - 1)
+    const pageEntries = historyEntries.slice(
+      historyPageIndex * HISTORY_PAGE_SIZE,
+      (historyPageIndex + 1) * HISTORY_PAGE_SIZE
+    )
+
+      React.useEffect(() => {
+        if (pendingUndo === null && !pendingClear) return
+        const timer = setTimeout(() => {
+          setPendingUndo(null)
+          setPendingClear(false)
+        }, 5000)
+        return () => clearTimeout(timer)
+      }, [pendingUndo, pendingClear])
+
+      const showError = (text) => {
+        setNotice(null)
+        setErrorNotice(text)
+      }
+      const showNotice = (text) => {
+        setErrorNotice(null)
+        setNotice(text)
+      }
+
+      // 保留条数的就地保存（定义放在 showError / showNotice 之后：它们是被引用的
+      // 绑定，写在前面会在首次渲染时落进 TDZ —— 本文件踩过同一个坑）。
+      const changeRetention = async (next) => {
+        if (retentionPending || next === savedRetention) return
+        setRetentionPending(true)
+        setErrorNotice(null)
+        try {
+          // 只发这一个字段：服务端把 POST 体当 patch 用（`{ ...current, ...patch }`），
+          // 不必回传整份配置 —— 也就不会把别的标签页刚改的字段覆盖回旧值。
+          const payload = await controller.saveConfig({ historyMaxEntries: next })
+          if (!payload) {
+            showError(t('toast.saveFailed'))
+            return
+          }
+          // 服务端会夹取（clampHistoryMaxEntries）：回读它**实际接受**的值，
+          // 而不是相信我们发出去的那个。
+          const applied = Number.isFinite(payload.config && payload.config.historyMaxEntries)
+            ? payload.config.historyMaxEntries
+            : savedRetention
+          showNotice(t('history.maxEntriesSaved', { count: String(applied) }))
+          // 窗口可能变小（例如 200 → 50）：顺手把列表刷新回新窗口，免得界面上
+          // 还挂着按旧上限读来的条目。
+          await controller.loadHistory()
+        } catch (err) {
+          showError(messageOf(err))
+        } finally {
+          setRetentionPending(false)
+        }
+      }
+
+      const handleUndo = async (id) => {
+        if (pendingUndo !== id) {
+          setPendingUndo(id)
+          return
+        }
+        setPendingUndo(null)
+        try {
+          const payload = await controller.rollbackHistory(id)
+          await controller.loadHistory()
+          const count = Array.isArray(payload && payload.reversed) ? payload.reversed.length : 0
+          if (count === 0) {
+            showNotice(t('history.restoreUnchanged'))
+          } else {
+            showNotice(t('history.restoreDone', { count: String(count) }))
+          }
+        } catch (err) {
+          showError(messageOf(err))
+        }
+      }
+
+      const handleRestorePreset = async (id) => {
+        try {
+          const payload = await controller.restorePersona(id)
+          await controller.loadHistory()
+          const restored = Array.isArray(payload && payload.restored) ? payload.restored : []
+          const skipped = Array.isArray(payload && payload.skipped) ? payload.skipped : []
+          const names = restored.join(t('common.listSep'))
+          showNotice(
+            skipped.length > 0
+              ? `${t('history.restorePresetDone', { name: names })} ${t('history.restoreSkippedNote', { count: String(restored.length), skipped: String(skipped.length) })}`
+              : t('history.restorePresetDone', { name: names })
+          )
+        } catch (err) {
+          showError(messageOf(err))
+        }
+      }
+
+      const handleClearHistory = async () => {
+        if (!pendingClear) {
+          setPendingClear(true)
+          return
+        }
+        setPendingClear(false)
+        try {
+          const payload = await controller.clearHistory()
+          await controller.loadHistory()
+          const removed = payload && typeof payload.removed === 'number' ? payload.removed : 0
+          showNotice(t('history.clearDone', { count: String(removed) }))
+        } catch (err) {
+          showError(messageOf(err))
+        }
+      }
+
+      // 挂载即拉取：详情页本来就是「专门来看记录」才打开的页面。
+      React.useEffect(() => {
+        if (!controller.canRefresh()) return
+        void controller.loadHistory()
+      }, [controller])
+
+      // —— 渲染辅助（与 0.8.0-d 同源，搬成组件内局部函数）——
+      const historySummary = historyError
+        ? t('accordion.loadFailed')
+        : (history === null
+          ? t('status.loading')
+          : (history.length === 0
+            ? t('accordion.empty')
+            : (Number.isFinite(historyMax)
+              ? t('history.summary', { count: String(history.length), max: String(historyMax) })
+              : t('history.summaryCount', { count: String(history.length) }))))
+
+      const historyTimeText = (rawAt) => {
+        const at = Date.parse(rawAt)
+        if (!Number.isFinite(at)) return String(rawAt)
+        const diff = Date.now() - at
+        // 时钟回拨（或服务端时间略快）会让 diff 变成负数 —— 当成「刚刚」。
+        if (diff < 60 * 1000) return t('history.timeJustNow')
+        const minutes = Math.floor(diff / (60 * 1000))
+        if (minutes < 60) return t('history.timeMinutes', { count: String(minutes) })
+        const hours = Math.floor(minutes / 60)
+        if (hours < 24) return t('history.timeHours', { count: String(hours) })
+        return t('history.timeDays', { count: String(Math.floor(hours / 24)) })
+      }
+
+      const historySourceText = (source) => {
+        const key = `history.source.${String(source)}`
+        return HISTORY_SOURCES.includes(source) ? t(key) : String(source)
+      }
+
+      const historyValueText = (key, value) => {
+        if (value === undefined || value === null || value === '') return t('history.valueEmpty')
+        if (typeof value === 'boolean') return t(value ? 'accordion.on' : 'accordion.off')
+        if (key === 'language') {
+          const hit = LANGUAGE_OPTIONS.find((item) => item.value === value)
+          return hit ? hit.label : String(value)
+        }
+        // 只有落在合法取值里才查词典：否则 `style: 'custom-whatever'` 会渲染成键名本身
+        const toKey = HISTORY_ENUM_KEYS[key]
+        if (toKey && HISTORY_ENUM_VALUES[key].includes(value)) return t(toKey(value))
+        return String(value)
+      }
+
+      const historyFieldNames = (entry) => {
+        const keys = new Set()
+        for (const key of Object.keys(entry.before || {})) keys.add(key)
+        for (const key of Object.keys(entry.after || {})) keys.add(key)
+        return [...keys]
+      }
+
+      const historyPersonaEvents = (entry) => {
+        const events = (entry && entry.personas) || {}
+        const added = Array.isArray(events.added) ? events.added : []
+        const removed = Array.isArray(events.removed) ? events.removed.map((item) => item && item.name).filter(Boolean) : []
+        const updated = Array.isArray(events.updated) ? events.updated.map((item) => item && item.name).filter(Boolean) : []
+        return { added, removed, updated }
+      }
+
+      const historyRowText = (entry) => {
+        const parts = historyFieldNames(entry).map((key) => t(HISTORY_FIELD_LABELS[key] || key))
+        const events = historyPersonaEvents(entry)
+        const sep = t('common.listSep')
+        if (events.added.length > 0) parts.push(t('history.personasAdded', { names: events.added.join(sep) }))
+        if (events.removed.length > 0) parts.push(t('history.personasRemoved', { names: events.removed.join(sep) }))
+        if (events.updated.length > 0) parts.push(t('history.personasUpdated', { names: events.updated.join(sep) }))
+        // label（如预设名）紧跟在第一个字段前说出来：「应用预设：苏格拉底式提问者 · 自定义指令」
+        // —— 没有它，这一行答不了「应用的是什么」。旧记录没有 label，原样省略。
+        if (typeof entry.label === 'string' && entry.label !== '') parts.unshift(t('history.labelSuffix', { label: entry.label }))
+        return parts.length > 0 ? t('history.fields', { fields: parts.join(sep) }) : t('history.emptyFields')
+      }
+
+      const historyFieldRows = (entry) => {
+        const before = (entry && entry.before) || {}
+        const after = (entry && entry.after) || {}
+        const keys = [...new Set([...Object.keys(after), ...Object.keys(before)])]
+        return keys.map((key) => ({
+          key,
+          label: t(HISTORY_FIELD_LABELS[key] || key),
+          from: historyValueText(key, before[key]),
+          to: historyValueText(key, after[key])
+        }))
+      }
+
+      // —— 外壳对齐宿主插件详情页（fO69Vq_ 前缀的样式）——
+      // .detailSection：flex column、gap:12px；.sectionHead：baseline 对齐的标题行；
+      // .sectionTitle：14px/500/20px；.sectionCount：12px 次要色。
+      return e('section', { className: 'soul-detail-history', 'data-soul-history': 'true' },
+        e('div', { className: 'soul-detail-history-head' },
+          e('h4', { className: 'soul-detail-history-title' }, t('group.history')),
+          e('span', { className: 'soul-detail-history-count' }, historySummary)
+        ),
+        // —— 保留条数：与它约束的内容放在一起 ——
+        //
+        // 标题行说「最近 37 条 · 最多保留 200 条」，这个 200 就地可改，不必去设置页找。
+        // 放在列表**之前**而不是之后：它是这个区块的容量设置，读了标题就会想知道它在哪；
+        // 放到几十条记录下面，等于让用户先翻完才看见。
+        // 记录为空 / 读取失败时也照常渲染 —— 容量参数与「当前有几条」无关。
+        e('div', { className: 'soul-history-retention' },
+          e('label', { htmlFor: 'soul-historyMaxEntries' }, t('history.maxEntries')),
+          e('select', {
+            id: 'soul-historyMaxEntries',
+            value: String(savedRetention),
+            disabled: retentionPending,
+            onChange: (ev) => { void changeRetention(Number(ev.target.value)) }
+          },
+            ...HISTORY_MAX_ENTRIES_OPTIONS.map((count) => e('option', {
+              key: count,
+              value: String(count)
+            }, count === HISTORY_MAX_ENTRIES_DEFAULT
+              ? t('history.maxEntriesDefault', { count: String(count) })
+              : t('history.maxEntriesOption', { count: String(count) })))
+          ),
+          e(SoulHint, { text: t('history.maxEntriesHint') })
+        ),
+        // 结果提示：成功绿字 / 失败红字，与设置页同一套形态（宿主 savedNotice 语义）
+        (notice || errorNotice) && (errorNotice
+          ? e('p', { className: 'soul-error-notice', role: 'alert' }, errorNotice)
+          : e('p', { className: 'soul-saved-notice', role: 'status', 'aria-live': 'polite' }, notice)),
+        historyError
+          ? e('div', { className: 'soul-error' }, t('history.loadFailed', { reason: historyError }))
+          : (history === null
+            ? e('div', { className: 'soul-status' }, t('history.loading'))
+            : (history.length === 0
+              ? e('div', { className: 'soul-status' }, t('history.empty'))
+              : e(Fragment, null,
+                // 清空是**不可逆**的（记录里有昵称、职业、自述、自定义指令的原文），
+                // 所以它是这一组唯一的危险色按钮，且同样要过二次确认。
+                e('div', { className: 'soul-history-head' },
+                  e('button', {
+                    type: 'button',
+                    className: `soul-history-clear${pendingClear ? ' soul-history-clear-armed' : ''}`,
+                    onClick: handleClearHistory
+                  }, t(pendingClear ? 'history.clearArmed' : 'history.clear'))
+                ),
+
+                // 记录可能不完整（末尾被截断 / 文件过大只读了一段 / 有坏行）——
+                // 这是「看到的不是全部」，不是失败。
+                historyWarning && e('div', { className: 'soul-status soul-history-warning' },
+                  t('history.warning', { reason: historyWarning })),
+
+                e('ul', { className: 'soul-history-list' },
+                  ...pageEntries.map((entry) => {
+                    const isOpen = expandedEntry === entry.id
+                    const events = historyPersonaEvents(entry)
+                    const rows = historyFieldRows(entry)
+                    const arming = pendingUndo === entry.id
+                    return e('li', {
+                      key: entry.id,
+                      className: 'soul-history-item',
+                      'data-source': String(entry.source)
+                    },
+                      e('div', { className: 'soul-history-item-head' },
+                        // 整行主体是一个按钮（展开/收起），操作按钮放在它**外面** ——
+                        // 按钮里套按钮既非法又会让点「撤销」连带展开。
+                        e('button', {
+                          type: 'button',
+                          className: 'soul-history-item-main',
+                          'aria-expanded': isOpen,
+                          onClick: () => setExpandedEntry(isOpen ? null : entry.id)
+                        },
+                          e('span', { className: 'soul-history-time' }, historyTimeText(entry.at)),
+                          e('span', { className: 'soul-history-source' }, historySourceText(entry.source)),
+                          e('span', { className: 'soul-history-fields' }, historyRowText(entry))
+                        ),
+                        e('div', { className: 'soul-history-item-actions' },
+                          // 撤销用次要色：它可逆；真正不可逆的是清空，危险色留给它。
+                          e('button', {
+                            type: 'button',
+                            className: `soul-history-action${arming ? ' soul-history-action-armed' : ''}`,
+                            onClick: () => handleUndo(entry.id)
+                          }, t(arming ? 'history.restoreArmed' : 'history.restore')),
+                          // 只有「删过预设」的记录才给恢复入口 —— 其余记录点它无事可做。
+                          events.removed.length > 0 && e('button', {
+                            type: 'button',
+                            className: 'soul-history-action',
+                            onClick: () => handleRestorePreset(entry.id)
+                          }, t('history.restorePreset'))
+                        )
+                      ),
+
+                      isOpen && e('div', { className: 'soul-history-detail' },
+                        rows.length > 0 && e('div', { className: 'soul-history-diff' },
+                          // 「展开即全文」：原值/新值不再压成单行省略 —— 自定义指令几百字时，
+                          // 一行省略号等于没给。每行竖排：字段名 + 原值块 + 新值块，长文本换行铺开。
+                          ...rows.map((row) => e('div', { key: row.key, className: 'soul-history-diff-row' },
+                            e('span', { className: 'soul-history-diff-field' }, row.label),
+                            row.from !== '' && e('div', { className: 'soul-history-diff-cell' },
+                              e('span', { className: 'soul-history-diff-tag' }, t('history.field.from')),
+                              e('div', { className: 'soul-history-diff-value' }, row.from)
+                            ),
+                            e('div', { className: 'soul-history-diff-cell' },
+                              e('span', { className: 'soul-history-diff-tag' }, t('history.field.to')),
+                              e('div', { className: 'soul-history-diff-value' }, row.to)
+                            )
+                          ))
+                        ),
+                        events.added.length > 0 && e('div', { className: 'soul-history-diff-persona' },
+                          t('history.personasAdded', { names: events.added.join(t('common.listSep')) })),
+                        events.updated.length > 0 && e('div', { className: 'soul-history-diff-persona' },
+                          t('history.personasUpdated', { names: events.updated.join(t('common.listSep')) })),
+                        events.removed.length > 0 && e('div', { className: 'soul-history-diff-persona' },
+                          t('history.personasRemoved', { names: events.removed.join(t('common.listSep')) }))
+                      )
+                    )
+                  })
+                ),
+
+                // 分页器（0.9.0-ai）：只在多于一页时出现。
+                // 按钮直接用宿主 ui.Button，与工作区绑定按钮同一套外观（不覆盖底色/文字）。
+                historyPageCount > 1 && e('div', { className: 'soul-history-pager' },
+                  e(ui.Button, {
+                    disabled: historyPageIndex <= 0,
+                    onClick: () => setHistoryPage(historyPageIndex - 1)
+                  }, t('history.prev')),
+                  e('span', { className: 'soul-history-pageinfo' },
+                    t('history.pageInfo', {
+                      page: String(historyPageIndex + 1),
+                      total: String(historyPageCount),
+                      count: String(historyEntries.length)
+                    })),
+                  e(ui.Button, {
+                    disabled: historyPageIndex >= historyPageCount - 1,
+                    onClick: () => setHistoryPage(historyPageIndex + 1)
+                  }, t('history.next'))
+                ),
+
+                e('div', { className: 'soul-status' }, t('history.footer'))
+              )))
+      )
+    }
+
+    // -------------------------------------------------------------------------
+    // 会话级人设（0.9.0-d）—— 注册到宿主的 `conversation.view` 列表槽位
+    // -------------------------------------------------------------------------
+    //
+    // 为什么在这里而不在设置页：会话覆盖**只对这个会话**有意义，而设置页的槽位
+    // scope 是 `root`，拿不到 sessionId（宿主契约：settings.section 不注入会话）。
+    // `conversation.view` 的 inject 回调是 `(sessionId) => props`，这是插件能拿到
+    // 当前会话 id 的唯一正规入口。
+    //
+    // 与设置页的第二个区别：这里的改动**即时生效**，没有"保存"按钮 ——
+    // 用户在对话中途想换个风格，不该先跑去设置页。
+    function SoulSessionPersona(props) {
+      const { controller, useSoulController } = props
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      // 宿主把当前会话 id 通过槽位 inject 传进来（conversation.view 的约定）。
+      const sessionId = typeof props.sessionId === 'string' && props.sessionId !== '' ? props.sessionId : null
+      // 全局 store：预设列表、配置都在这里（与设置页同一份）。
+      const state = useSoulController((state) => state)
+
+      // 本会话的解析结果**独立于全局 store**：一份覆盖只对它所属的会话有意义，
+      // 塞进全局 store 会让两个会话的 tab 互相串味。
+      const [localView, setView] = React.useState(null)
+      // 会话作用域解析结果 —— **优先读全局 store**，回落本地 state。
+      //
+      // 为什么：header 的人设标签与这个 tab 是两个组件，都要显示「当前生效的人设 + 来源」。
+      // 两边各存一份必然漂移（实测：tab 里切换了人设，header 标签仍显示旧的 ——
+      // 因为标签只在 sessionId 变化时取数，而切换人设不改变 sessionId）。
+      // store 是单一数据源：saveSessionScope 成功后写入，两边一起刷新。
+      const storedScope = state.sessionScopes && state.sessionScopes[String(sessionId)]
+      const view = storedScope || localView
+      const [error, setError] = React.useState(null)
+      const [notice, setNotice] = React.useState(null)
+      const [busy, setBusy] = React.useState(false)
+      // 右栏详情正在展示哪一张卡（null = 还没选中）。
+      //
+      // 与「生效」是两件事：这个纯属浏览状态，点卡片只换详情、不改配置；
+      // 真正写配置的是详情面板里的「用这个」。初值在下面的 effect 里跟随生效项。
+      const [selectedPersona, setSelectedPersona] = React.useState(null)
+
+      // 刻意**不用** React.useCallback：本项目的客户端垫片（scripts/verify-client.mjs）
+      // 只实现了 useState / useEffect / useRef —— 用 useCallback 会让整条客户端回归
+      // 在这个组件上一头撞死（历史上已经踩过一次）。这里的依赖只有 sessionId，
+      // 用普通函数 + 显式依赖数组完全等价，而且垫片也能跑。
+      const reload = async () => {
+        if (sessionId === null) {
+          setView(null)
+          setError(null)
+          return
+        }
+        try {
+          const payload = await controller.fetchSessionScope(sessionId)
+          setView(payload)
+          setError(null)
+        } catch (err) {
+          setError(messageOf(err))
+        }
+      }
+
+      // 切到别的会话时重新取：这个组件的 props.sessionId 会随宿主切换而变。
+      React.useEffect(() => {
+        setNotice(null)
+        // 切会话时清掉选中态：上一屏看的那张卡与这个会话无关，留着会让人以为它在生效
+        setSelectedPersona(null)
+        void reload()
+        // reload 的闭包只捕获 sessionId（其余是稳定的 setter / controller）
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+      }, [sessionId])
+
+      // 预设名列表与设置页同一套排序（内置优先），避免两处顺序不一致。
+      const personaNames = state.personas
+        ? Object.keys(state.personas).sort((a, b) => {
+          const aBuiltin = state.personas[a] && state.personas[a].builtin ? 0 : 1
+          const bBuiltin = state.personas[b] && state.personas[b].builtin ? 0 : 1
+          return aBuiltin - bBuiltin
+        })
+        : []
+
+      const apply = async (personaName) => {
+        if (sessionId === null || busy) return
+        const entry = state.personas ? state.personas[personaName] : null
+        if (!entry) return
+        setBusy(true)
+        setError(null)
+        try {
+          // 只提交该预设**声明过**的字段（部分覆盖），与「应用预设」「工作区绑定」
+          // 走同一条语义 —— 否则三处效果不一致，用户没法用任一处验证另一处。
+          const overrides = {}
+          for (const key of SESSION_OVERRIDE_KEYS) {
+            if (key in entry) overrides[key] = entry[key]
+          }
+          // 带上**用户实际点的预设名**：服务端要靠它显示"当前生效的是哪个预设"。
+          //
+          // 只传字段是不够的 —— 覆盖项里没有名字，服务端只能拿当前配置去反查哪个预设
+          // 匹配得上。两个预设声明了相同字段时，反查结果取决于**名称排序**：
+          // 实测用户自建「游戏策划与开发专家」与内置「自驱型协作者」字段一致时，
+          // 点了后者却显示前者。把名字一起传过去，反查就退化成兜底而不是唯一依据。
+          const payload = await controller.saveSessionScope(sessionId, overrides, personaName)
+          setView(payload)
+          setNotice(t('session.applied', { name: personaName }))
+        } catch (err) {
+          setError(messageOf(err))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      const clear = async () => {
+        if (sessionId === null || busy) return
+        setBusy(true)
+        setError(null)
+        try {
+          const payload = await controller.clearSessionScope(sessionId)
+          setView(payload)
+          setNotice(t('session.cleared'))
+        } catch (err) {
+          setError(messageOf(err))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      // ⚠️ 所有 hook 必须声明在**任何提前 return 之前**。
+      //
+      // 这个 effect 原先写在 `if (view === null) return ...` 后面，于是：
+      //   首屏 view === null  → 提前 return，effect 没执行（hook 数 = 5）
+      //   view 到达后          → effect 执行（hook 数 = 6）
+      // React 检测到「本次渲染的 hook 比上次多」⇒ error #310
+      // （Rendered more hooks than during the previous render）整块 tab 崩溃。
+      //
+      // 测试台没抓到，是因为它每次 settle 都走完整的渲染循环、且组件从不经过
+      // 「先 null 后有值」的两段式挂载。**这是垫片与真实 React 的差异，不是产品逻辑
+      // 正确性的证据** —— 教训：hook 顺序在垫片里测不出来，只能靠代码纪律。
+      React.useEffect(() => {
+        if (selectedPersona !== null) return
+        // 优先跟随「当前生效」的预设。
+        if (view && typeof view.activePersona === 'string' && view.activePersona !== '') {
+          setSelectedPersona(view.activePersona)
+          return
+        }
+        // ⚠️ view 还没加载完时**必须等**：此刻 view 为 null、activePersona 也读不到，
+        // 若在这里兜底就会抢先选中第一个预设；等 view 到达后，
+        // 「selectedPersona !== null」的守卫又会把正确的选择挡回去 ——
+        // 结果是「生效的那张被甩到侧边、中心卡是别的预设」。
+        if (!view) return
+        // 兜底：全局配置**不匹配任何预设**时（手改过特质、纯自定义配置），
+        // 服务端回的 activePersona 是 null。此时若不兜底，选中态永远为 null ⇒
+        // 右栏渲染成「点左侧任意一张卡」的空提示 ⇒ **一个按钮都没有**，
+        // 用户看到的是「点了没反应」（其实连按钮都没画出来）。
+        // 兜底到第一个可用预设，右栏立刻有内容与「用这个」按钮。
+        if (personaNames.length > 0) setSelectedPersona(personaNames[0])
+        // selectedPersona 是「要不要跟随」的判据，必须进依赖；view / personaNames
+        // 变化时重新评估。
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+      }, [view, selectedPersona, personaNames])
+
+      // 会话 id 缺席（宿主在诊断 / 空白会话时可能不传）：如实说明，不假装能改。
+      if (sessionId === null) {
+        return e('div', { className: 'soul-session-persona' },
+          e('div', { className: 'soul-status' }, t('session.workspaceUnknown'))
+        )
+      }
+
+      if (view === null) {
+        return e('div', { className: 'soul-session-persona' },
+          error
+            ? e('div', { className: 'soul-error' }, t('session.loadFailed', { reason: error }))
+            : e('div', { className: 'soul-status' }, t('session.loading'))
+        )
+      }
+
+      // 「来源」必须说清是**哪一层**决定的：否则用户看到一个人设名，却不知道该去哪儿改它。
+      const sourceText = (() => {
+        if (view.source === 'session') return t('session.source.session')
+        if (view.source === 'workspace') {
+          return t('session.source.workspace', { name: view.workspaceTitle || view.workspaceId || '' })
+        }
+        if (view.source === 'directory') return t('session.source.directory')
+        return t('session.source.global')
+      })()
+
+      const hasOverride = view.override !== null && view.override !== undefined
+      const activePersona = typeof view.activePersona === 'string' && view.activePersona !== ''
+        ? view.activePersona
+        : t('session.noPersona')
+
+      // —— 卡牌网格 ——
+      //
+      // 与设置页的「人设预设」用**同一套卡牌语言**（同样的圆角/描边/插画/压图标题），
+      // 理由不是"顺手复用"：用户在设置页学会「一张卡 = 一个人设，点卡面上的按钮就用它」，
+      // 到了会话里面对同一个概念（人设），切换成本最低的方式就是长成一样。
+      // —— 左：卡牌轮转（叠层）／右：选中卡的详情 ——
+      //
+      // 轮转而非平铺：会话面板横向空间本来就窄，平铺会把每张卡挤到「名字 + 一句效果」
+      // 看不出差异；叠层轮转与设置页的人设卡牌**同构**，用户在设置页学会的
+      // 「左右露边 = 可翻，中心大卡 = 正在看」在这里直接复用。
+      //
+      // 与设置页轮转的两点差异（会话面板高度有限，简化几何）：
+      //   · 偏移步长收窄到 68px / 0.94 / 0.88（设置页 92px / 0.9 / 0.8）—— 三张同屏
+      //     时总宽约 260px，正好卡进左栏；
+      //   · 不做 3D 翻面（右栏详情已承担「看清」，翻面会与它重复）。
+      //
+      // 选中态与生效态是**两个不同的东西**，必须分开表达：
+      //   · selectedPersona = 中心大卡（右栏详情跟着变，纯浏览，不影响配置）；
+      //   · isEffective     = 这一张是否正在生效（配置事实，名字前加 ★）。
+      const cardFor = (name, offset) => {
+        const entry = state.personas ? state.personas[name] : null
+        const builtin = !!(entry && entry.builtin)
+        const isEffective = hasOverride && activePersona === name
+        return e('div', {
+          key: name,
+          className: 'soul-session-card',
+          'data-effective': isEffective ? 'true' : 'false',
+          'data-current': offset === 0 ? 'true' : 'false',
+          'aria-hidden': offset === 0 ? undefined : 'true',
+          // 偏移归**叠层**所有（内联 transform）；与 CSS 里 hover/焦点态的
+          // translateY 微抬无关 —— 两者若合成一个 transform 会互相打架。
+          style: {
+            transform: `translateX(${offset * 78}px) scale(${1 - Math.abs(offset) * 0.06})`,
+            zIndex: String(10 - Math.abs(offset)),
+            opacity: offset === 0 ? '1' : '0.55'
+          },
+          // 0.9.0-m：卡牌**不再可点** —— 切换改由下方轮播导航（左右按钮 + 圆点）负责，
+          // 与设置页的「人设预设」轮播同一套交互。卡上只保留信息与状态角标。
+          //
+          // 无障碍名仍然要：卡面已无可见文字（0.9.0-l 移除了遮罩与压图标题），
+          // 纯图形元素必须有可访问名，读屏用户才知道这是哪张卡。
+          'aria-label': name,
+          title: isEffective ? `${name}（${t('session.chipInUse')}）` : name
+        },
+          e('div', { className: 'soul-persona-art' },
+            e('img', {
+              className: 'soul-persona-art-img',
+              src: new URL(`/api/soul/persona-art/${encodeURIComponent(name)}`, hostBase()).href,
+              alt: '',
+              loading: 'lazy',
+              decoding: 'async',
+              draggable: 'false',
+              onError: (ev) => { ev.target.style.display = 'none' }
+            }),
+            // 遮罩与压图文字**已移除**（0.9.0-l）：右侧详情已完整展示人设名、
+            // 六个维度与自定义指令全文，卡上再叠一层渐变遮罩 + 文字只是重复，
+            // 而且遮罩会让插画本身失掉大半饱和度 —— 既然是「完全展示卡牌」，
+            // 就让插画原样呈现。
+            //
+            // 保留的是**功能性角标**（不是文字信息，右栏没有的）：
+            //   · 内置徽标 —— 这张卡是内置的还是自建的
+            //   · 位置指示 i / n —— 排第几张（只标中心卡，否则三张都显示同一个数）
+            //   · ★ —— 这张正在生效（原本在名字前，名字没了就挪到右上角）
+            builtin && e('span', { className: 'soul-persona-badge' }, t('personas.builtin')),
+            offset === 0 && e('span', { className: 'soul-persona-card-pos' }, `${personaIndexOf(name) + 1} / ${personaNames.length}`),
+            isEffective && e('span', { className: 'soul-session-card-star' }, '★')
+          )
+          // 下方不再有文字区（0.9.0-j）：右栏详情已完整展示人设名、六个维度、
+          // 自定义指令全文与效果说明，卡上重复一遍是冗余，还会把插画挤成半张。
+          // 「完全展示卡牌」= 插画铺满整张卡。
+          //
+          // 压图标题（名字 + 摘要）**保留** —— 插画是抽象主题图，没有名字
+          // 认不出是哪张卡。
+        )
+      }
+
+      // ── 叠层顺序：完整循环 ──
+      //
+      // 中心永远是 selectedPersona；左露边 = 它的**前一个**（列表头则接尾），
+      // 右露边 = 它的**后一个**（列表尾则接头）。首尾相接 ⇒ 点右侧卡它滑到中心、
+      // 原中心滑到左侧；点左侧卡反之 —— 整个列表是一个环。
+      //
+      // ⚠️ 这里**不能**用「selectedPersona 排头 + 其余顺排」那种线性序：
+      // 那样点侧边卡时，露出的仍是同一批邻居，视觉上像「只有两张在动」；
+      // 而真正该变的是「谁在中心、谁在旁边」。
+      // ── 叠层：中心 + 两侧露边，首尾相接 ──
+      //
+      // 结构直接用「槽位」表达，不再用「stackOrder 下标 + 偏移」两层映射 ——
+      // 那两层映射正是本轮三个 bug 的来源：下标与偏移各错一次就渲染出别的卡。
+      //
+      // slots 的每一项是 { name, offset }：
+      //   offset 0  = 中心（= selectedPersona）
+      //   offset -1 = 左侧露边（= 它的前一个，列表头则接尾）
+      //   offset +1 = 右侧露边（= 它的后一个，列表尾则接头）
+      //
+      // 预设数不足 3 时**不重复渲染同一张**：[A, B, A] 会产生重复 React key，
+      // 且让"恰一张中心卡"的判据失真。
+      const personaIndexOf = (name) => personaNames.indexOf(name)
+      const stackSlots = (() => {
+        const n = personaNames.length
+        if (n === 0) return []
+        const at = personaIndexOf(selectedPersona)
+        if (at === -1) {
+          // 选中项不在列表里（预设刚被删）：退回线性序，中心取第一个
+          return personaNames.map((name, i) => ({ name, offset: i === 0 ? 0 : 1 }))
+        }
+        if (n === 1) return [{ name: personaNames[0], offset: 0 }]
+        if (n === 2) {
+          const other = personaNames[1 - at]
+          return [
+            { name: other, offset: -1 },
+            { name: personaNames[at], offset: 0 }
+          ]
+        }
+        return [
+          { name: personaNames[(at - 1 + n) % n], offset: -1 },
+          { name: personaNames[at], offset: 0 },
+          { name: personaNames[(at + 1) % n], offset: 1 }
+        ]
+      })()
+
+      // 右栏详情：与设置页卡背**逐字相同**的六个维度 + 自定义指令全文，
+      // 外加这一栏独有的操作按钮（用这个 / 取消本会话的临时人设）。
+      const detailOf = (name) => {
+        if (name === null) {
+          return e('div', { className: 'soul-session-detail-empty' }, t('session.pickHint'))
+        }
+        const entry = state.personas ? state.personas[name] : null
+        const builtin = !!(entry && entry.builtin)
+        const isEffective = hasOverride && activePersona === name
+        return e(Fragment, null,
+          e('div', { className: 'soul-session-detail-head' },
+            e('span', { className: 'soul-session-detail-name' }, name),
+            builtin && e('span', { className: 'soul-persona-badge' }, t('personas.builtin')),
+            isEffective && e('span', { className: 'soul-session-badge' }, t('session.chipInUse'))
+          ),
+          e('div', { className: 'soul-persona-dims' },
+            ...PERSONA_DIM_KEYS.map((dim) => e('div', { className: 'soul-persona-dim', key: dim },
+              e('span', null, t(`field.${dim}`)),
+              e('b', null, personaDimLabelOf(entry, dim, t))
+            ))
+          ),
+          e('div', { className: 'soul-persona-back-label' }, t('personas.customInstructions')),
+          e('div', { className: 'soul-persona-fulltext' }, personaFullTextOf(entry, t)),
+          e('div', { className: 'soul-session-detail-actions' },
+            e('button', {
+              type: 'button',
+              className: isEffective
+                ? 'soul-persona-action soul-persona-active'
+                : 'soul-persona-action',
+              disabled: busy,
+              onClick: () => { void apply(name) }
+            }, isEffective ? t('session.chipInUse') : t('session.useCard')),
+            hasOverride && isEffective && e('button', {
+              type: 'button',
+              className: 'soul-session-chip soul-session-chip-clear',
+              disabled: busy,
+              onClick: () => { void clear() }
+            }, t('session.clear'))
+          ),
+          // 作用范围说明：紧跟操作按钮 —— 它解释的正是上面那个按钮改的东西
+          // （「用这个」/「取消本会话的临时人设」都只作用于本会话）。
+          // 放在分栏最底部离使用场景太远，用户看不到。
+          hasOverride && e('div', { className: 'soul-session-scope-hint' },
+            t('session.overrideHint'))
+        )
+      }
+
+      return e('div', { className: 'soul-session-persona' },
+        e('div', { className: 'soul-session-head' },
+          e('h4', { className: 'soul-session-title' }, t('session.title')),
+          hasOverride && e('span', { className: 'soul-session-badge' }, t('session.badge'))
+        ),
+
+        // 当前生效：先回答「现在是谁」，再给操作
+        e('div', { className: 'soul-session-current' },
+          e('div', { className: 'soul-session-current-name' },
+            activePersona,
+            // 特质突出点（0.9.0-ab）：非默认的维度摘要，跟在名称后的小字。
+            // personaRowMetaOf 的输出正是"风格 + 偏离默认值的维度" —— 与卡面
+            // 摘要同源。无匹配预设（自定义配置）时不显示。
+            activePersona && state.personas && state.personas[activePersona] && e('span', { className: 'soul-session-current-traits' },
+              ` · ${personaRowMetaOf(state.personas[activePersona], t)}`)
+          ),
+          e('div', { className: 'soul-session-current-source' }, sourceText)
+        ),
+
+        (notice || error) && (error
+          ? e('p', { className: 'soul-error-notice', role: 'alert' }, t('session.applyFailed', { reason: error }))
+          : e('p', { className: 'soul-saved-notice', role: 'status', 'aria-live': 'polite' }, notice)),
+
+        // 临时覆盖：左侧叠层轮转（中心大卡 + 两侧露边）+ 右侧详情面板
+        e('div', { className: 'soul-field soul-persona-field' },
+          // 标题与上方 tab 标题（.soul-session-title，14px/500）统一 ——
+          // 两者是同层级区块标题，原先用 .soul-field-label（12px）视觉不齐（用户反馈）。
+          e('h4', { className: 'soul-session-title' }, t('session.overrideTitle')),
+          personaNames.length === 0
+            ? e('div', { className: 'soul-status' }, t('session.loading'))
+            : e('div', { className: 'soul-session-split' },
+              // 左侧：轮播区 = 叠层卡 + 下方导航
+              e('div', { className: 'soul-session-carousel' },
+                // 叠层：中心卡 = selectedPersona（offset 0），左/右各露出前一个/后一个。
+                e('div', { className: 'soul-session-grid' },
+                  ...stackSlots.map((slot) => cardFor(slot.name, slot.offset))
+                ),
+                // 轮播导航：左右按钮 + 圆点（与设置页「人设预设」同一套）
+                //
+                // 为什么**循环**而不是到边界就 disabled：设置页是线性浏览（到头就停），
+                // 这里刻意做成环形 —— 预设只有几张，用户想看「下一张」时不该先翻回第一张。
+                e('div', { className: 'soul-persona-nav' },
+                  e('button', {
+                    type: 'button',
+                    className: 'soul-persona-navbtn',
+                    'data-dir': 'prev',
+                    'aria-label': t('personas.prev'),
+                    onClick: () => setSelectedPersona(
+                      personaNames[(personaIndexOf(selectedPersona) - 1 + personaNames.length) % personaNames.length]
+                    )
+                  }, '‹'),
+                  e('div', { className: 'soul-persona-dots', role: 'tablist' },
+                    ...personaNames.map((n, i) => e('button', {
+                      key: n,
+                      type: 'button',
+                      role: 'tab',
+                      className: 'soul-persona-dot',
+                      'data-active': i === personaIndexOf(selectedPersona) ? 'true' : 'false',
+                      'aria-selected': i === personaIndexOf(selectedPersona) ? 'true' : 'false',
+                      'aria-label': `${n}（${i + 1}/${personaNames.length}）`,
+                      onClick: () => setSelectedPersona(n)
+                    }))
+                  ),
+                  e('button', {
+                    type: 'button',
+                    className: 'soul-persona-navbtn',
+                    'data-dir': 'next',
+                    'aria-label': t('personas.next'),
+                    onClick: () => setSelectedPersona(
+                      personaNames[(personaIndexOf(selectedPersona) + 1) % personaNames.length]
+                    )
+                  }, '›')
+                )
+              ),
+              e('div', { className: 'soul-session-detail' }, detailOf(selectedPersona))
+            ),
+        ),
+
+        // 覆盖里的自定义字段（不是预设带来的）：让用户知道"现在生效的不是某个预设"
+        hasOverride && (() => {
+          const keys = Object.keys(view.override || {})
+          if (keys.length === 0) return null
+          return e('div', { className: 'soul-field' },
+            e('div', { className: 'soul-field-label' }, t('session.customOverrides')),
+            // 用字段**标签**（中英双语）而不是裸键名：HISTORY_FIELD_LABELS 是变更记录
+            // 同款表，保证「改字段叫什么」在 tab、变更记录、设置页三处一致。
+            // 缺失的键回退到原样（万一有人改了字段名又漏了标签）。
+            e('div', { className: 'soul-session-fields' }, ...keys.map((key) => e('code', {
+              key,
+              className: 'soul-session-field'
+            }, t(HISTORY_FIELD_LABELS[key] || key))))
+          )
+        })()
+      )
+    }
+
+    // 会话覆盖可提交的字段白名单（与服务端 lib/session-scope.mjs 的
+    // SESSION_OVERRIDE_FIELDS 逐项一致）。客户端这份只用于「从预设里挑字段」，
+    // 真正的校验在服务端 —— 客户端过滤只是少发几个必然被丢弃的键。
+    const SESSION_OVERRIDE_KEYS = ['style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language', 'customInstructions']
+
+    // -------------------------------------------------------------------------
+    // 卡牌文案（模块级）—— 设置页、会话 tab、工作区卡片共用同一套措辞
+    // -------------------------------------------------------------------------
+    //
+    // 为什么必须共用而不是各写一份：同一个预设在设置页显示「专业严谨 · 多列表」、
+    // 在会话里显示「专业严谨」，用户会以为它们是两个东西。语义一致只能靠同一份实现，
+    // 靠"记得同步"是不行的（这个项目已经因为手工同步的清单踩过两次）。
+    //
+    // 依赖注入的 `t`：渲染器按槽位 locale 注入翻译函数，模块级函数拿不到闭包里的 t。
+
+    // 预设摘要：风格 + 所有「偏离默认值」的维度。
+    const personaRowMetaOf = (entry, t) => {
+      const row = entry || {}
+      const parts = []
+      if (STYLE_VALUES.includes(row.style)) parts.push(t(`style.${row.style}`))
+      else if (row.style) parts.push(row.style)
+      for (const [field, allowed] of Object.entries(META_FIELD_VALUES)) {
+        const value = row[field]
+        if (!value || value === META_FIELD_DEFAULTS[field]) continue
+        if (!allowed.includes(value)) continue
+        parts.push(t(`meta.${field}.${value}`))
+      }
+      return parts.join(' · ')
+    }
+
+    // 卡面效果栏：优先 customInstructions（人格差异的主要载体），没有则退回摘要。
+    // 截断到第一句或 60 字：卡面空间有限，CSS 侧还有 3 行 line-clamp 兜底。
+    const personaEffectTextOf = (entry, t) => {
+      const raw = typeof (entry || {}).customInstructions === 'string' ? entry.customInstructions.trim() : ''
+      if (raw === '') return personaRowMetaOf(entry, t)
+      const firstSentence = raw.split(/[。；;\n]/)[0] || raw
+      return firstSentence.length > 60 ? `${firstSentence.slice(0, 60)}…` : firstSentence
+    }
+
+    // —— 卡背（详情面）的三样辅助，模块级 ——
+    //
+    // 列出「一个人设完整的六个维度」。顺序与设置页表单一致（风格 → 标题列表 →
+    // 表情 → 表格 → 回复长度 → 语言），这样卡背读起来与设置页对得上。
+    const PERSONA_DIM_KEYS = ['style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language']
+
+    // 单个维度的「值」文案。刻意**不把与默认相同的项留空**：设置页里 trait 的默认值
+    // 就是 'default'，而卡背要回答的是「这个人设改了什么」—— 统一标成「默认」比留空
+    // 更清楚（留空会让人以为渲染坏了）。
+    // 语言维度复用 LANGUAGE_OPTIONS 的标签（'中文' / 'English' 两种语言下同名，
+    // 本来就是语言自称，无需翻译）。
+    const personaDimLabelOf = (entry, dim, t) => {
+      const row = entry || {}
+      const value = row[dim]
+      if (dim === 'language') {
+        const opt = LANGUAGE_OPTIONS.find((o) => o.value === value)
+        return opt ? opt.label : t('personas.dimDefault')
+      }
+      if (dim === 'style') {
+        return STYLE_VALUES.includes(value) ? t(`style.${value}`) : t('personas.dimDefault')
+      }
+      // ⚠️ 判据是 TRAIT_VALUES.includes(value)（合法**取值** 'default'|'more'|'less'），
+      // 不是检查 dim —— 这里曾经被误改成检查维度名，结果所有 trait 维度都落到「默认」。
+      return TRAIT_VALUES.includes(value) ? t(`trait.${dim}.${value}`) : t('personas.dimDefault')
+    }
+
+    // 卡背的全文：这一次**不截断**（正面效果栏才截断）。
+    // 预设没写自定义指令时给一句说明，而不是留空 —— 留空会让人以为渲染坏了。
+    const personaFullTextOf = (entry, t) => {
+      const raw = typeof (entry || {}).customInstructions === 'string'
+        ? entry.customInstructions.trim()
+        : ''
+      return raw === '' ? t('personas.noCustomInstructions') : raw
+    }
+
+    // -------------------------------------------------------------------------
+    // 工作区人设（0.9.0-e）—— 注册到宿主的 `plugins.detail.section` 槽位
+    // -------------------------------------------------------------------------
+    //
+    // 为什么在插件详情页而不是设置页：设置页是**快捷调整**（风格/语言/开关），
+    // 而这里是「这个项目用什么人设」的结构性配置 —— 低频、需要空间（平铺卡片）、
+    // 而且与变更记录放在同一页更符合"这是我的插件怎么配"的心智模型。
+    //
+    // 为什么平铺而不是下拉：工作区通常 3–10 个，每个有 title 与"是否已绑定"两个
+    // 信息维度；下拉关闭时只能显示一项，用户必须展开才知道有哪些、哪些还没绑。
+    // **未绑定的排前面** —— 那正是用户来这里要处理的事。
+    function SoulWorkspaces(props) {
+      const { controller, useSoulController } = props
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      const subject = props.subject || null
+      // 只服务自己的详情页（与变更记录同一判据）。
+      if (!subject || subject.kind !== 'bundle' || !subject.pkg || subject.pkg.name !== 'dsh-soul') return null
+
+      const state = useSoulController((state) => state)
+      const [view, setView] = React.useState(null)
+      const [error, setError] = React.useState(null)
+      const [notice, setNotice] = React.useState(null)
+      const [busy, setBusy] = React.useState(false)
+      // 正在展开人设选择的工作区（null = 没有）
+      const [picking, setPicking] = React.useState(null)
+      // 待确认解绑的工作区（内联二次确认，与删除预设同一套）
+      const [pendingUnbind, setPendingUnbind] = React.useState(null)
+
+      const reload = async () => {
+        try {
+          const payload = await controller.fetchWorkspaces()
+          setView(payload)
+          setError(null)
+        } catch (err) {
+          // ⚠️ 失败时必须清空 view：否则界面继续渲染**上一次成功**的列表，
+          // 用户看到的是过期数据却以为是当前的（错误提示与旧卡片同屏，更混乱）。
+          setView(null)
+          setError(messageOf(err))
+        }
+      }
+
+      React.useEffect(() => {
+        void reload()
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+      }, [])
+
+      // 解绑的二次确认 5 秒后复位（同设置页的 armed 态）
+      React.useEffect(() => {
+        if (pendingUnbind === null) return undefined
+        const timer = setTimeout(() => setPendingUnbind(null), 5000)
+        return () => clearTimeout(timer)
+      }, [pendingUnbind])
+
+      const personaNames = state.personas
+        ? Object.keys(state.personas).sort((a, b) => {
+          const aBuiltin = state.personas[a] && state.personas[a].builtin ? 0 : 1
+          const bBuiltin = state.personas[b] && state.personas[b].builtin ? 0 : 1
+          return aBuiltin - bBuiltin
+        })
+        : []
+
+      const bind = async (workspace, persona) => {
+        if (busy) return
+        setBusy(true)
+        setError(null)
+        try {
+          const payload = await controller.saveWorkspacePersona(workspace.workspaceId, persona)
+          setView(payload)
+          setPicking(null)
+          setNotice(t('workspaces.applied', { name: persona, title: workspace.title || workspace.path }))
+        } catch (err) {
+          setError(messageOf(err))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      const unbind = async (workspace) => {
+        if (pendingUnbind !== workspace.workspaceId) {
+          setPendingUnbind(workspace.workspaceId)
+          return
+        }
+        setPendingUnbind(null)
+        if (busy) return
+        setBusy(true)
+        setError(null)
+        try {
+          const payload = await controller.removeWorkspacePersona(workspace.workspaceId)
+          setView(payload)
+          setNotice(t('workspaces.unbindDone', { title: workspace.title || workspace.path }))
+        } catch (err) {
+          setError(messageOf(err))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      // 加载中 / 失败 / 空 三态必须分开（0.8.0 的 C14 就是被"加载中显示成空"抓到的）
+      const body = (() => {
+        if (error !== null && view === null) {
+          return e('div', { className: 'soul-error' }, t('workspaces.loadFailed', { reason: error }))
+        }
+        if (view === null) {
+          return e('div', { className: 'soul-status' }, t('workspaces.loading'))
+        }
+        if (view.indexProblem) {
+          // 宿主服务不可用：如实说明，不给一个"看起来是空的"列表
+          return e('div', { className: 'soul-error' }, t('workspaces.serverProblem', { reason: view.indexProblem }))
+        }
+        const items = Array.isArray(view.workspaces) ? view.workspaces : []
+        if (items.length === 0) {
+          return e('div', { className: 'soul-status' }, t('workspaces.empty'))
+        }
+
+        // 未绑定的排前面：那正是用户来这一页要处理的事
+        const sorted = items.slice().sort((a, b) => {
+          if (a.bound !== b.bound) return a.bound ? 1 : -1
+          return String(a.title || a.path).localeCompare(String(b.title || b.path))
+        })
+
+        return e('div', { className: 'soul-ws-list' }, ...sorted.map((ws) => {
+          const title = ws.title || ws.path
+          const armed = pendingUnbind === ws.workspaceId
+          const isPicking = picking === ws.workspaceId
+          return e('div', {
+            key: ws.workspaceId,
+            className: ws.bound ? 'soul-ws-card soul-ws-card-bound' : 'soul-ws-card',
+            'data-bound': ws.bound ? 'true' : 'false'
+          },
+            e('div', { className: 'soul-ws-main' },
+              e('div', { className: 'soul-ws-title' }, title),
+              e('code', { className: 'soul-ws-path', title: ws.path }, ws.path),
+              ws.invalidPersona && e('div', { className: 'soul-ws-invalid' },
+                e('span', null, t('workspaces.invalid', { name: ws.persona || '' })),
+                e('span', { className: 'soul-status' }, t('workspaces.invalidHint')))
+            ),
+            e('div', { className: 'soul-ws-actions' },
+              // 已绑定：显示当前人设名 + 改绑 / 解绑
+              ws.bound
+                ? e(Fragment, null,
+                  e('span', { className: 'soul-ws-persona' }, ws.persona || t('workspaces.bound')),
+                  // 0.9.0-ao：**文字按钮**，规格照抄宿主设置-模型页的「编辑 / 删除」。
+                  //
+                  // 上一版我误抄成了 .iconButton（图标按钮）—— 那是宿主页面里另一处
+                  // 的形态，不是这两个按钮。宿主真正的实现是：
+                  //   编辑 → className = secondaryButton（描边、文字、label-primary）
+                  //   删除 → className = dangerButton（无描边、红字、hover 浅红底）
+                  // 两者共用紧凑尺寸：radius-sm / height 28 / padding 0 10 / 12px / lh 18。
+                  e('button', {
+                    type: 'button',
+                    className: 'soul-ws-btn',
+                    disabled: busy,
+                    onClick: () => setPicking(isPicking ? null : ws.workspaceId)
+                  }, t('workspaces.rebind')),
+                  e('button', {
+                    type: 'button',
+                    className: armed ? 'soul-ws-btn soul-ws-btn-danger soul-ws-btn-armed' : 'soul-ws-btn soul-ws-btn-danger',
+                    'data-armed': armed ? 'true' : 'false',
+                    disabled: busy,
+                    onClick: () => { void unbind(ws) }
+                  }, t(armed ? 'workspaces.unbindArmed' : 'workspaces.unbind'))
+                )
+                : e(Fragment, null,
+                  e('span', { className: 'soul-ws-unbound' }, t('workspaces.unbound')),
+                  // 0.9.0-am：改用宿主 ui.Button —— 原先自绘的
+                  // .soul-ws-action-primary 是实心主色底（浅色主题≈黑），
+                  // 而共用的 .soul-ws-action:hover 又把文字染成 brand 近黑色，
+                  // 黑底黑字 ⇒ 整块全黑（用户两次反馈的真实成因）。
+                  e(ui.Button, {
+                    variant: 'outline',
+                    size: 'sm',
+                    disabled: busy || personaNames.length === 0,
+                    onClick: () => setPicking(isPicking ? null : ws.workspaceId)
+                  }, t('workspaces.bind'))
+                )
+            ),
+            // 内联展开人设胶囊（不另开弹层）：一次点击完成绑定
+            isPicking && e('div', { className: 'soul-ws-picker' },
+              e('span', { className: 'soul-ws-picker-label' }, t('workspaces.pickPersona')),
+              e('div', { className: 'soul-session-chips' },
+                ...personaNames.map((name) => e('button', {
+                  key: name,
+                  type: 'button',
+                  className: 'soul-session-chip',
+                  disabled: busy,
+                  onClick: () => { void bind(ws, name) }
+                }, name))
+              )
+            )
+          )
+        }))
+      })()
+
+      const boundCount = Array.isArray(view && view.workspaces)
+        ? view.workspaces.filter((w) => w.bound).length
+        : 0
+      const total = Array.isArray(view && view.workspaces) ? view.workspaces.length : 0
+
+      return e('section', { className: 'soul-detail-history', 'data-soul-workspaces': 'true' },
+        e('div', { className: 'soul-detail-history-head' },
+          e('h4', { className: 'soul-detail-history-title' }, t('workspaces.title')),
+          e('span', { className: 'soul-detail-history-count' },
+            t('workspaces.count', { bound: String(boundCount), total: String(total) }))
+        ),
+        (notice || error) && (error
+          ? e('p', { className: 'soul-error-notice', role: 'alert' }, t('workspaces.applyFailed', { reason: error }))
+          : e('p', { className: 'soul-saved-notice', role: 'status', 'aria-live': 'polite' }, notice)),
+        e('div', { className: 'soul-note' }, t('workspaces.hint')),
+        body
+      )
+    }
+
+    // -------------------------------------------------------------------------
+    // 会话覆盖清理（0.9.0-f）—— 插件详情页的第三个区块
+    // -------------------------------------------------------------------------
+    //
+    // 为什么也要一个按钮（而不是只留命令）：命令是给愿意敲的人的，而"我这儿攒了一堆
+    // 不知道哪来的会话配置"是所有人都会遇到的事 —— 那时他们不会想到去查文档。
+    //
+    // 交互刻意做成两步：先**预览**（不删任何东西），确认后才清理。
+    // 删除不可逆，且回收依据（会话清单）可能不可用，所以默认永远站在"不删"一侧。
+    function SoulSessions(props) {
+      const { controller } = props
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      const subject = props.subject || null
+      if (!subject || subject.kind !== 'bundle' || !subject.pkg || subject.pkg.name !== 'dsh-soul') return null
+
+      const [plan, setPlan] = React.useState(null)
+      const [error, setError] = React.useState(null)
+      const [notice, setNotice] = React.useState(null)
+      const [busy, setBusy] = React.useState(false)
+      // 已预览、待确认（null = 还没预览过）
+      const [armedCount, setArmedCount] = React.useState(null)
+
+      const scan = async () => {
+        if (busy) return
+        setBusy(true)
+        setError(null)
+        setNotice(null)
+        try {
+          const payload = await controller.scanSessionScopeGc()
+          setPlan(payload)
+          // 预览一次即 arm：按钮文案随之变成「确认清理 N 项？」
+          setArmedCount(Array.isArray(payload.collectable) ? payload.collectable.length : 0)
+        } catch (err) {
+          setPlan(null)
+          setError(messageOf(err))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      const apply = async () => {
+        if (busy || plan === null) return
+        // 第二次点击才真删；第一次只 arm（按钮文案已经说明了后果）
+        if (armedCount === null) { void scan(); return }
+        if (armedCount === 0) { void scan(); return }
+        setBusy(true)
+        setError(null)
+        try {
+          const payload = await controller.applySessionScopeGc()
+          setPlan(payload)
+          setArmedCount(null)
+          const removed = Array.isArray(payload.removed) ? payload.removed.length : 0
+          setNotice(t('sessions.collected', { count: String(removed) }))
+        } catch (err) {
+          setError(messageOf(err))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      const collectable = plan && Array.isArray(plan.collectable) ? plan.collectable.length : 0
+      const body = (() => {
+        if (error !== null && plan === null) {
+          return e('div', { className: 'soul-error' }, t('sessions.scanFailed', { reason: error }))
+        }
+        if (plan === null) {
+          // 还没点「预览」：不自动扫描。清理是运维动作，不该在打开详情页时悄悄跑一遍。
+          return e('div', { className: 'soul-status' }, t('sessions.previewHint'))
+        }
+        return e(Fragment, null,
+          // 扫描不完整 → 明确说"没做判定"，并**隐藏清理按钮**（没有判定就没有可清理项）
+          plan.scanComplete === false
+            ? e('div', { className: 'soul-status' }, t('sessions.scanIncomplete'))
+            : e('div', { className: 'soul-status' },
+              t('sessions.summary', {
+                total: String(plan.total || 0),
+                markable: String((plan.markable || []).length),
+                collectable: String(collectable),
+                quarantine: String((plan.quarantine || []).length)
+              })),
+          // 可回收清单：让用户在删之前看见具体是哪些
+          collectable > 0 && e('div', { className: 'soul-field' },
+            e('div', { className: 'soul-field-label' }, t('sessions.collect')),
+            ...plan.collectable.slice(0, 20).map((item) => e('code', {
+              key: item.sessionId || item.file,
+              className: 'soul-session-field'
+            }, String(item.sessionId || item.file)))
+          ),
+          plan.scanComplete !== false && collectable === 0 && e('div', { className: 'soul-status' }, t('sessions.nothing'))
+        )
+      })()
+
+      return e('section', { className: 'soul-detail-history', 'data-soul-sessions': 'true' },
+        e('div', { className: 'soul-detail-history-head' },
+          e('h4', { className: 'soul-detail-history-title' }, t('sessions.title'))
+        ),
+        (notice || error) && (error
+          ? e('p', { className: 'soul-error-notice', role: 'alert' }, t('sessions.scanFailed', { reason: error }))
+          : e('p', { className: 'soul-saved-notice', role: 'status', 'aria-live': 'polite' }, notice)),
+        e('div', { className: 'soul-note' }, t('sessions.hint')),
+        body,
+        // 用独立 class 而不是 .soul-buttons：那个 class 属于**设置页的保存按钮区**，
+        // 复用会让「保存设置在哪里」这类断言抓到错误的块（verify-config 立刻抓到过）。
+        e('div', { className: 'soul-sessions-actions' },
+          e('button', {
+            type: 'button',
+            className: 'soul-ws-action',
+            disabled: busy,
+            onClick: () => { void scan() }
+          }, busy ? t('sessions.scanning') : t('sessions.collect')),
+          // 真删按钮的三个条件缺一不可：
+          //   ① 预览过（armedCount !== null）；
+          //   ② 有可回收项；
+          //   ③ **本轮扫描完整** —— 扫描不完整时状态机对一切返回 keep，那时即便
+          //      列表里出现 collectable（服务端逻辑变更 / 数据异常），也不该给删除入口。
+          //      这是"缺证据时保留"在 UI 上的最后一道闸。
+          armedCount !== null && collectable > 0 && plan !== null && plan.scanComplete !== false && e('button', {
+            type: 'button',
+            className: 'soul-ws-action soul-ws-action-armed',
+            disabled: busy,
+            onClick: () => { void apply() }
+          }, t('sessions.collectArmed', { count: String(collectable) }))
+        )
+      )
+    }
+
+    // -------------------------------------------------------------------------
+    // 会话人设标签（只读）—— 挂在会话 header
+    // -------------------------------------------------------------------------
+    //
+    // 为什么从输入框左侧挪到 header：
+    // · 输入框左侧横向空间极窄，「个性化已启用 · 人设名 · 层级」根本放不下
+    //   （实测被 overflow:hidden 裁掉）；
+    // · 会话 header 那一行（标题旁）本来就有横向空间，宿主的「创造模式」标签就挂在那；
+    // · 宿主自己在窄容器时会把 header 标签**隐藏**（AgentPresetLabel 的
+    //   @container (width<=540px){ display:none }）—— 说明这个位置的设计就是
+    //   「有空间才显示」，与我们的诉求一致。
+    //
+    // 只读：会话的 composition 一旦开始就固定了，header 里放可切换控件会承诺
+    //   宿主拒绝兑现的事（这是宿主 AgentPresetLabel 的原话，理由同样成立）。
+    //   要改人设去「人设」tab 或设置页。
+    // -------------------------------------------------------------------------
+    // 面具图标几何（唯一来源）
+    // -------------------------------------------------------------------------
+    //
+    // 这个面具在三个地方出现：会话 header 标签、侧栏会话行徽标、侧栏面板图标。
+    // 之前各处各抄一份 path，结果「下巴改圆」只改了 header，另两处仍用尖下巴 ——
+    // 同一副面具在界面上长出两种轮廓（用户实测发现）。现在只留这一份。
+    //
+    // 造型：戏剧双面 —— 左眼笑（上弯）、右眼哭（下弯）、嘴左高右低；盾形圆下巴。
+    const SOUL_MASK_PATHS = [
+      'M2.2 3.0 C4.2 1.8 11.8 1.8 13.8 3.0 C14.4 6.4 13.0 11.4 11.4 12.4 C10.2 13.1 9.2 13.4 8.0 13.4 C6.8 13.4 5.8 13.1 4.6 12.4 C3.0 11.4 1.6 6.4 2.2 3.0 Z',
+      'M4.0 6.0 C4.7 5.2 6.1 5.2 6.8 6.0',
+      'M9.2 5.6 C9.9 6.4 11.3 6.4 12.0 5.6',
+      'M4.6 9.6 C6.0 10.2 9.0 9.6 11.2 8.6'
+    ]
+
+    /** 渲染面具 SVG。props 里的宽高/类名/内联样式原样透传，描边规格在此统一。 */
+    const soulMask = (props) => e('svg', {
+      viewBox: '0 0 16 16',
+      fill: 'none',
+      stroke: 'currentColor',
+      strokeWidth: 1.4,
+      strokeLinecap: 'round',
+      strokeLinejoin: 'round',
+      'aria-hidden': true,
+      ...(props || {})
+    }, ...SOUL_MASK_PATHS.map((d, i) => e('path', { key: i, d })))
+
+    function SoulSessionPersonaLabel(props) {
+      const { useSoulController, controller } = props
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      const state = useSoulController((state) => state)
+      const enabled = state.enabled === true
+      // scope:'session' 槽位的 inject 收到的是**位置参数** [sessionId]（见宿主契约
+      // FactoryInjectParams：scope 'session' → [sessionId: SessionId]）。
+      const sessionId = typeof props.sessionId === 'string' && props.sessionId !== '' ? props.sessionId : null
+      // 数据来自**全局 store**（sessionScopes[sessionId]），不是组件自己取。
+      //
+      // 为什么改：原实现自己在 useEffect 里 fetch，依赖只有 [sessionId] ——
+      // 会话里切换人设时 sessionId 没变 ⇒ effect 不重跑 ⇒ header 标签仍显示旧人设
+      // （用户报的 bug：人设 tab 里切换了，标题栏不变）。
+      //
+      // 现在 store 是单一数据源：saveSessionScope / clearSessionScope 成功后把服务端
+      // 返回的解析结果写进 store ⇒ 所有看它的地方一起刷新，不必各自轮询。
+      const scopeView = (state.sessionScopes && state.sessionScopes[String(sessionId)]) || null
+      // 请求是否失败过：失败时不得静默退回全局值（那会重现"界面说 A、模型用 B"的割裂）
+      const [scopeFailed, setScopeFailed] = React.useState(false)
+
+      // 兜底：store 里还没有这个会话的记录时（首次打开、别的组件写入的），
+      // 去取一次。取到后写回 store，后续都走 store。
+      React.useEffect(() => {
+        if (sessionId === null) return undefined
+        if (scopeView !== null) return undefined
+        let cancelled = false
+        void controller.fetchCurrentSessionScope(sessionId).then((payload) => {
+          if (cancelled) return
+          controller.setSessionScope(sessionId, {
+            activePersona: typeof payload.activePersona === 'string' ? payload.activePersona : null,
+            recordedPersona: typeof payload.recordedPersona === 'string' ? payload.recordedPersona : null,
+            globalPersona: typeof payload.globalPersona === 'string' ? payload.globalPersona : null,
+            source: typeof payload.source === 'string' ? payload.source : null,
+            workspaceId: payload.workspaceId || null,
+            workspaceTitle: typeof payload.workspaceTitle === 'string' ? payload.workspaceTitle : null,
+            override: payload.override || null
+          })
+          setScopeFailed(false)
+        }).catch(() => {
+          if (cancelled) return
+          setScopeFailed(true)
+        })
+        return () => { cancelled = true }
+      }, [sessionId, scopeView])
+
+      // 关闭个性化时不显示（人设此刻不生效，挂名字会误导）
+      if (!enabled) return null
+
+      const activePersona = state.activePersona
+      const scopeActive = scopeView && typeof scopeView.activePersona === 'string' && scopeView.activePersona !== ''
+        ? scopeView.activePersona
+        : null
+      const displayPersona = scopeActive
+        || (scopeFailed ? t('quick.scopeUnknown') : (activePersona || t('quick.custom')))
+      const scopeTag = (() => {
+        if (!scopeView) return null
+        if (scopeView.source === 'session') return t('quick.scopeSession')
+        if (scopeView.source === 'workspace') {
+          return t('quick.scopeWorkspace', { name: scopeView.workspaceTitle || scopeView.workspaceId || '' })
+        }
+        if (scopeView.source === 'directory') return t('quick.scopeDirectory')
+        if (scopeView.source === 'global') return t('quick.scopeGlobal')
+        return t('quick.scopeUnknown')
+      })()
+
+      return e('span', { className: 'soul-session-persona-label' },
+        // 图标：宿主的 IconAgentPresetOutlineRegular（智能体预设）。
+        //
+        // 为什么用宿主现成图标而不是自绘：
+        // · 语义正好 —— 「Agent 预设」就是「人设」；
+        // · 与**同一位置**的邻居（header 上的「创造模式」标签）用同一套图标语言，
+        //   视觉统一，用户的识别成本最低；
+        // · 随主题变色（currentColor），不用管深浅色；
+        // · 免去自绘 SVG 的描边/尺寸对齐问题。
+        //
+        // 宿主客户端包（ui-agent-preset / ui-chat / ui-tool）都是
+        // require('@deepseek-ai/dsh-client-ui-primitives') 拿它的，
+        // 与本插件的 require 机制完全相同。
+        //
+        // 尺寸 14：与邻居 AgentPresetLabel 的图标一致（size: 14）。
+        // 面具图标（0.9.0-w 自绘，0.9.0-x 定稿为「喜剧+悲剧」双面）：戏剧面具 =
+        // 「戴上面具扮演另一个角色」+ 一张脸半笑半哭，比 agent-preset 图标更准确
+        // 地表达「人设」，也避免与「创造模式」标签撞图标。stroke 用 currentColor。
+        // 渲染验证：Chrome headless 截 96/28/14px 三档，14px 下三笔都清晰。
+        soulMask({
+          className: 'soul-session-persona-label-icon',
+          width: 14,
+          height: 14,
+          strokeWidth: 1.5
+        }),
+        e('span', { className: 'soul-session-persona-label-name' }, displayPersona),
+        scopeTag && e('span', { className: 'soul-session-persona-label-scope' }, scopeTag)
+      )
+    }
+
+    // -------------------------------------------------------------------------
+    // 侧栏面板图标「Soul 人设」（0.9.0-ac）
+    // -------------------------------------------------------------------------
+    //
+    // 槽位：sidebar.panellist —— kind:'list' / scope:'root'，"Global panel icons"。
+    // 宿主 occupants：插件管理器（plugins）、自动化任务（schedules）等。
+    //
+    // owner props（SidebarPanelIconOwnerProps）：{ size, active } ——
+    // 宿主把"要多大的方块 / 当前是否选中"传给图标，照做即可与邻居对齐。
+    //
+    // ⚠️ inject 与 session 槽位不同：panellist 是 scope:'root'，runInject 只传
+    // [binding.key, actions]（root 无 binding ⇒ 无参）—— inject 只需注入无状态
+    // 内容，宿主的 PanelRow 自己拥有点击（拿我们的 id 去 selectPanel）。
+    function SoulPanelIcon(props) {
+      // 宿主要求方块尺寸与选中态；未传时给默认（14px）
+      const size = typeof props.size === 'number' ? props.size : 14
+      return e('span', {
+        className: 'soul-panel-icon',
+        style: { width: size, height: size },
+        'aria-hidden': true
+      },
+        // 面具（与 header 标签同一副「喜剧+悲剧」），stroke: currentColor
+        soulMask({ width: '100%', height: '100%' })
+      )
+    }
+
+    // -------------------------------------------------------------------------
+    // 侧栏会话行 hover 面具按钮（0.9.0-ab）
+    // -------------------------------------------------------------------------
+    //
+    // 槽位：sidebar.workspaces.session.row.action —— kind:'list' / scope:'root'，
+    // 宿主文档："The hover buttons at the end of one Session row, in ascending
+    // order, after the '...' menu trigger." ui-workspace 自己注册了
+    // archive(100) / pin(200)，我们 order:300 排在后面。
+    //
+    // owner props（宿主 SessionRowOwnerProps）：{ sessionId, displayTitle } ——
+    // 能知道这一行是哪个会话，配合 store.bindingsSessions（含每会话的
+    // persona / binding）即可显示该会话当前生效的人设。
+    //
+    // 展示形态：面具图标按钮，hover 出 tooltip「人设：X（来源）」。
+    // 只读 —— 点击不做任何事（按钮本身禁用），它只是把"这个会话现在是谁"
+    // 显式摆到侧栏，不用先点开会话再看。
+    // 侧栏徽标的数据去重句柄（模块级）：侧栏一次会挂很多行，每行各自触发一次
+    // 拉取会打出一串重复请求。同一时刻只允许一个在飞。
+    let sidebarBindingsRequest = null
+
+    /**
+     * 会话行相关的共享取数（行尾徽标 + 宿主 hover 信息卡两个槽位共用）。
+     *
+     * 返回该行的会话 id 与生效人设；数据没拉过时顺手补拉一次。
+     * 抽成一处是因为两个槽位读的是同一份数据、同一套降级规则 ——
+     * 各写一份迟早出现「徽标有、hover 卡没有」这类分叉。
+     */
+    function useSessionRowPersona(props) {
+      const { useSoulController, controller } = props
+      const state = useSoulController((s) => s)
+      const enabled = state.enabled === true
+
+      // sessionId 的两种注入形态都接住：
+      // ① 宿主把 owner props（SessionRowOwnerProps）并入组件 props —— 文档行为；
+      // ② 若某个宿主版本改把它交给 inject，则由 inject 透传（见注册处）。
+      const sessionId = typeof props.sessionId === 'string' && props.sessionId !== ''
+        ? props.sessionId
+        : null
+
+      // 侧栏可能先于插件详情页挂载：那时 store.bindings 还是 null（从没拉过），
+      // bindingsSessions 恒为空 ⇒ 两个槽位都渲染 null（用户实测「看不到」的成因）。
+      // 这里补一次拉取：null 才拉，拉过（含「确实没有绑定」）就交给详情页那只。
+      React.useEffect(() => {
+        if (!enabled) return
+        if (state.bindings !== null) return
+        if (sidebarBindingsRequest) return
+        if (!controller || typeof controller.loadBindings !== 'function') return
+        sidebarBindingsRequest = Promise.resolve(controller.loadBindings())
+          .catch(() => {})
+          .finally(() => { sidebarBindingsRequest = null })
+      }, [enabled, state.bindings])
+
+      const row = sessionId === null
+        ? null
+        : (state.bindingsSessions || []).find((x) => x && x.id === sessionId)
+      const persona = row && typeof row.persona === 'string' && row.persona !== ''
+        ? row.persona
+        : null
+      return { enabled, sessionId, persona }
+    }
+
+    function SoulSessionPersonaBadge(props) {
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      const { enabled, persona } = useSessionRowPersona(props)
+      // 无会话 / 人设未知 / 个性化关闭 ⇒ 不渲染（不占 hover 位）
+      if (!enabled || !persona) return null
+
+      const label = t('sidebar.personaTip', { name: persona })
+
+      // 气泡用**宿主自己的 Tooltip**（0.9.0-ak），参数照抄宿主的行尾按钮
+      // （PinSessionRowButton）：side bottom / align end / delayMs 500 / portal。
+      // 之前用原生 title，浏览器画的是浅色系统气泡，和旁边「置顶/归档」的黑色
+      // 气泡并排时两种样式 —— 用户实测指出不一致。
+      //
+      // 不用 title 还有第二个理由：人设也显示在宿主的 hover 信息卡里
+      // （sidebar.session.row.hover），title 会让两个弹窗先后冒出来。
+      const body = e('span', {
+        className: 'soul-sidebar-persona-badge',
+        // 只读标识：不做动作（点击仍会落在行上，避免误触打开会话）
+        'aria-label': label
+      },
+        // 尺寸与邻居一致：宿主行尾图标是 14
+        soulMask({ className: 'soul-sidebar-persona-badge-icon', width: 14, height: 14 })
+      )
+      // 降级：宿主若没有导出 Tooltip，就只渲染徽标（没有气泡，但绝不能整个塌掉）
+      if (!ui || ui.Tooltip === undefined || ui.Tooltip === null) return body
+      return e(ui.Tooltip, {
+        label,
+        side: 'bottom',
+        align: 'end',
+        delayMs: 500,
+        portal: true
+      }, body)
+    }
+
+    // -------------------------------------------------------------------------
+    // 宿主 hover 信息卡里的「人设」一行（0.9.0-aj）
+    // -------------------------------------------------------------------------
+    //
+    // 槽位：sidebar.session.row.hover —— kind:'list' / scope:'root'，宿主文档：
+    // "Section of the Session row's hover card between its relative time and its
+    // trailing status line. Mounted only while that card is open."
+    // ui-workspace 自己的自动任务摘要（schedule-tasks）也在这里。
+    //
+    // 为什么放这里：宿主 hover 会话行会弹出信息卡（标题 / 运行状态 / 几分钟前）。
+    // 人设属于同一类「这一行现在是什么状态」的信息，塞进宿主的卡里比另起一个
+    // 自绘 tooltip 更一致 —— 用户只看到一张卡，而不是两张轮流冒出来。
+    // 卡片只在打开时挂载 ⇒ 这里的取数是真正的按需，不占常驻开销。
+    function SoulSessionPersonaHover(props) {
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      const { enabled, persona } = useSessionRowPersona(props)
+      if (!enabled || !persona) return null
+      // 结构照抄宿主同槽位住户（ui-schedule 的 SessionScheduleHover）：
+      // 一行 = 图标容器 + 说明 + 主体值，行高/字号/间距都与宿主卡片一致。
+      return e('div', { className: 'soul-hover-persona' },
+        e('span', { className: 'soul-hover-persona-icon', 'aria-hidden': true },
+          soulMask({ width: 12, height: 12 })),
+        e('span', { className: 'soul-hover-persona-label' }, t('sidebar.personaRow')),
+        e('span', { className: 'soul-hover-persona-name', title: persona }, persona)
       )
     }
 
@@ -1323,9 +3972,6 @@ window.__ModuleLoader__.load({
       const state = useSoulController((state) => state)
       const enabled = state.enabled === true
       const busy = state.saving === true
-      // B：底栏开关上缀当前人设名，与输入框上方的标签互相印证
-      const activePersona = state.activePersona
-
       // 保存失败的本地标记：失败时 store.error 会带上原因，但按钮本身此前毫无反馈
       // （enabled 没变 ⇒ 外观与文案都不变），用户视角是「点了没反应」。
       const [failed, setFailed] = React.useState(false)
@@ -1360,17 +4006,331 @@ window.__ModuleLoader__.load({
         // 「未匹配预设」这种说法听着像报错。底栏这里是输入框旁唯一的常驻状态，
         // 必须给确定的落点 —— 有名字就是那个预设，没名字就是自定义。
         // 关闭个性化时不显示（人设此时不生效，挂名字会误导）。
-        enabled && e('span', { className: 'soul-quick-toggle-name' },
-          `· ${activePersona || t('quick.custom')}`)
+        // 人设名与层级标注**不在这里**（0.9.0-h 挪到会话 header）：
+        // 输入框左侧横向空间有限，那串文字会被裁掉；header 那一行才有空间。
+        // 这里只留「开/关」这个动作。
+      )
+    }
+
+    // -------------------------------------------------------------------------
+    // 设置页「工作区绑定」分组（0.8.1）
+    // -------------------------------------------------------------------------
+
+    // 目录点选服务。由 apply() 里的 ctx.inject(['uiWorkspace'], ...) 动态写入 ——
+    // **不能**把它加进静态 inject 数组（`const inject = ['slots','locale']`）：
+    // uiWorkspace 缺失时整个插件都不会激活，设置页连同人设卡一起消失。
+    // null = 这个连接拿不到该服务，界面直接走手输路径。
+    let directoryPicker = null
+
+    // 路径截中段显示：保留结尾（`…\dsh-plugin`）。用户靠结尾区分项目、靠开头区分盘符，
+    // 两者都要时优先结尾 —— 同一盘下的项目前缀往往一样长。完整路径交给 title。
+    function shortenPath(raw, max) {
+      const text = typeof raw === 'string' ? raw : String(raw == null ? '' : raw)
+      const limit = Number.isFinite(max) ? max : 44
+      if (text.length <= limit) return text
+      const tail = text.slice(text.length - (limit - 1))
+      // 从第一个分隔符处切，避免留下半截目录名（`…-plugin` 比 `…\dsh-plugin` 难认）
+      const cut = Math.max(tail.indexOf('\\'), tail.indexOf('/'))
+      return '…' + (cut >= 0 ? tail.slice(cut) : tail)
+    }
+
+    // 「工作区绑定」主体。三块结构见 docs/DESIGN-persona-scope.md §7.3：
+    //   ① 当前会话目录卡（我这个项目现在是谁）② 绑定列表（增删改查）③ 未绑定回落行。
+    //
+    // 与变更记录同款**懒加载**：本组件只在分组展开时才被渲染（手风琴 body 的
+    // `open && ...`），所以挂载即等于「用户主动打开了它」，effect 里拉一次即可。
+    // 刻意不进 2 秒轮询 —— 绑定是配置不是状态，轮询只会让「手机上改了、桌面上跳」。
+    function SoulBindings(props) {
+      const { useSoulController, controller, personaNames, onOpenPersonas } = props
+      const t = typeof props.t === 'function' ? props.t : FALLBACK_T
+      const state = useSoulController((state) => state)
+      const {
+        bindings, bindingsInvalid, bindingsDropped, bindingsWarning, bindingsError,
+        bindingsMax, bindingsMaxPath, bindingsSessions, activePersona
+      } = state
+
+      // 下拉选项：内置优先的稳定顺序由 SoulSettings 算好传进来（同一份排序）。
+      const names = Array.isArray(personaNames) ? personaNames : []
+      const [draftDir, setDraftDir] = React.useState('')
+      const [draftPersona, setDraftPersona] = React.useState('')
+      const [pickerFailed, setPickerFailed] = React.useState(false)
+      const [pendingUnbind, setPendingUnbind] = React.useState(null)
+      const [notice, setNotice] = React.useState(null)
+      const [errorNotice, setErrorNotice] = React.useState(null)
+
+      React.useEffect(() => {
+        if (!controller.canRefresh()) return
+        void controller.loadBindings()
+      }, [])
+
+      // 解绑的二次确认 5 秒后自动复位（与删除预设同一套 armed 态，不用原生 confirm）
+      React.useEffect(() => {
+        if (pendingUnbind === null) return undefined
+        const timer = setTimeout(() => setPendingUnbind(null), 5000)
+        return () => clearTimeout(timer)
+      }, [pendingUnbind])
+
+      const showError = (text) => { setErrorNotice(text); setNotice(null) }
+      const showNotice = (text) => { setNotice(text); setErrorNotice(null) }
+
+      // 草稿人设默认取列表第一项 —— 下拉不能空着等用户点，那看着像坏了
+      const effectiveDraftPersona = names.includes(draftPersona)
+        ? draftPersona
+        : (names.length > 0 ? names[0] : '')
+
+      // 调起系统目录选择器。取消返回空串（什么都不做），失败抛错。
+      //
+      // 降级判据必须是「调用失败」而不是「预读后端种类」：宿主 UiWorkspaceService
+      // 的 pickDirectory() 把底层错误（含 capability 字段）包装成了普通 Error，
+      // 客户端读不到种类。见 docs/DESIGN-persona-scope.md §7.5。
+      async function handlePick() {
+        try {
+          // 防御：服务可能在按钮渲染后被撤走（插件卸载 / scope 物化），此时按「不可用」处理
+          if (!directoryPicker) throw new Error(t('bindings.pickerUnavailable'))
+          const picked = await directoryPicker.pickDirectory()
+          // null = 用户取消：不是错误，不该弹红字
+          if (typeof picked === 'string' && picked !== '') setDraftDir(picked)
+        } catch (err) {
+          setPickerFailed(true)
+          showError(messageOf(err))
+        }
+      }
+
+      async function handleBind() {
+        const dir = draftDir.trim()
+        if (dir === '') {
+          showError(t('bindings.needDir'))
+          return
+        }
+        try {
+          await controller.saveBinding(dir, effectiveDraftPersona)
+          setDraftDir('')
+          showNotice(t('bindings.bound', { dir: shortenPath(dir), name: effectiveDraftPersona }))
+        } catch (err) {
+          // 服务端的拒绝文案可以直接展示（它已经写清了是哪一类问题），不再包一层前缀
+          showError(messageOf(err))
+        }
+      }
+
+      async function handleRebind(dir, persona) {
+        try {
+          await controller.saveBinding(dir, persona)
+          showNotice(t('bindings.bound', { dir: shortenPath(dir), name: persona }))
+        } catch (err) {
+          showError(messageOf(err))
+        }
+      }
+
+      async function handleUnbind(dir) {
+        if (pendingUnbind !== dir) {
+          setPendingUnbind(dir)
+          setErrorNotice(null)
+          return
+        }
+        setPendingUnbind(null)
+        try {
+          const payload = await controller.removeBinding(dir)
+          // removed 为假 = 这条绑定已经不在表里了（另一个窗口删的），不必谎报成功
+          if (payload && payload.removed === false) showError(t('bindings.unbindMissing'))
+          else showNotice(t('bindings.unbound', { dir: shortenPath(dir) }))
+        } catch (err) {
+          showError(messageOf(err))
+        }
+      }
+
+      const table = bindings && typeof bindings === 'object' && !Array.isArray(bindings) ? bindings : {}
+      const dirs = Object.keys(table)
+      // 失效引用：服务端按当前预设库算好后标注，客户端只负责画出来（不自动删除 ——
+      // 用户可能只是临时删了那个预设、打算改名回来）
+      const invalidNames = new Map()
+      for (const item of Array.isArray(bindingsInvalid) ? bindingsInvalid : []) {
+        if (item && typeof item.dir === 'string') invalidNames.set(item.dir, String(item.persona))
+      }
+      // 层级排序：父目录排在子目录前，用 `└` 标出「这是上一条的子树」。
+      // 同一个 `D:\项目A` 既绑了自身又绑了子目录时，先看父再看子才读得懂继承关系。
+      const sortedDirs = dirs.slice().sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+
+      // 当前会话：优先挑有 cwd 的那个 —— 没有目录的会话任何绑定都不会命中，
+      // 拿它当「当前」会让整张卡说的都不是用户眼前这个项目。
+      const sessions = Array.isArray(bindingsSessions) ? bindingsSessions : []
+      const withCwd = sessions.filter((s) => s && typeof s.cwd === 'string' && s.cwd !== '')
+      const current = withCwd.length > 0 ? withCwd[0] : (sessions.length > 0 ? sessions[0] : null)
+      const currentCwd = current && typeof current.cwd === 'string' && current.cwd !== '' ? current.cwd : null
+      const moreCount = sessions.length - (current ? 1 : 0)
+      const binding = current && current.binding ? current.binding : null
+      const effectivePersona = current && current.persona ? String(current.persona) : ''
+      // 「直接绑在本目录」与「继承自上级」的区别只体现在这里：没有它，用户在子目录里
+      // 看到别的人设会以为是 bug。判别已在宿主做过（客户端拿原始串比较会被盘符大小写骗过）。
+      const sourceText = !binding
+        ? t('bindings.sourceGlobal')
+        : (binding.inherited
+            ? t('bindings.sourceInherited', { dir: shortenPath(binding.dir) })
+            : shortenPath(binding.dir))
+
+      return e('div', { className: 'soul-bindings' },
+        // ① 当前会话目录卡 —— 先回答「我这个项目现在是谁」，再让用户改
+        e('div', { className: 'soul-field' },
+          e('div', { className: 'soul-field-label' }, t('bindings.currentTitle')),
+          current === null
+            ? e('div', { className: 'soul-status' }, t('bindings.noSession'))
+            : (currentCwd === null
+                ? e('div', { className: 'soul-status' }, t('bindings.noCwd'))
+                : e('div', null,
+                    e('div', { className: 'soul-bindings-current' },
+                      e('code', {
+                        className: 'soul-bindings-path',
+                        title: currentCwd
+                      }, shortenPath(currentCwd)),
+                      e('div', { className: 'soul-bindings-meta' },
+                        e('div', null, `${t('bindings.effective')}：${effectivePersona || t('quick.custom')}`),
+                        e('div', null, `${t('bindings.source')}：${sourceText}`)
+                      )
+                    ),
+                    moreCount > 0 && e('div', { className: 'soul-status' },
+                      t('bindings.moreSessions', { count: String(moreCount) }))
+                  ))
+        ),
+
+        // ② 新建 / 改绑入口。点选与手输填的是**同一个字段** —— 选择器只是把路径
+        // 填进来，不是另一条独立的路径，所以两者不会给出不同的结果。
+        e('div', { className: 'soul-field' },
+          e('label', { htmlFor: 'soul-bindings-dir' }, t('bindings.manualLabel')),
+          e('div', { className: 'soul-bindings-new' },
+            e('input', {
+              type: 'text',
+              id: 'soul-bindings-dir',
+              value: draftDir,
+              placeholder: t('bindings.manualPlaceholder'),
+              onChange: (ev) => setDraftDir(ev.target.value)
+            }),
+            // 失败过一次就不再给按钮：宿主的能力在启动时判定一次、之后不会变，
+            // 留着它只会让用户反复点一个确定会失败的东西。
+            // 服务**压根没注入**时同理（那些连接方式拿不到 uiWorkspace）：按钮不能出现，
+            // 否则点下去只会在 handlePick 里对 null 取属性、抛一个用户看不懂的 TypeError。
+            // 0.9.0-ah：改用宿主 ui.Button —— 原先自绘的 <button> 继承了宿主
+            // 基础按钮样式（实心底 + 白字），我们又用 color:brand-primary 覆盖文字，
+            // hover 时深底 + 深字 ⇒ 整个按钮全黑（用户反馈）。
+            // 换成宿主组件后，底色 / 文字 / 悬停是一套，构造上必然与宿主一致。
+            !pickerFailed && directoryPicker !== null && e(ui.Button, {
+              variant: 'outline',
+              onClick: () => { void handlePick() }
+            }, t('bindings.choose'))
+          ),
+          pickerFailed && e('div', { className: 'soul-bindings-hint' }, t('bindings.pickerUnavailable')),
+          e('div', { className: 'soul-bindings-new' },
+            e('label', { htmlFor: 'soul-bindings-persona' }, t('bindings.persona')),
+            e('select', {
+              id: 'soul-bindings-persona',
+              value: effectiveDraftPersona,
+              onChange: (ev) => setDraftPersona(ev.target.value)
+            }, names.map((name) => e('option', { key: name, value: name }, name))),
+            // variant 用 outline，**不用 primary**：primary 是实心主色
+            // （浅色主题下 ≈ 黑底），hover 再压一层就更黑 —— 用户实测「全黑」。
+            // outline 是描边按钮，hover 底色由宿主的 button token 决定，
+            // 与设置页那些次要按钮（重置 / 存为预设）同族。
+            e(ui.Button, {
+              variant: 'outline',
+              disabled: names.length === 0,
+              onClick: () => { void handleBind() }
+            }, t('bindings.bindDir'))
+          ),
+          bindingsMaxPath && e('div', { className: 'soul-status' },
+            t('bindings.maxPath', { max: String(bindingsMaxPath) }))
+        ),
+
+        // ③ 绑定列表
+        e('div', { className: 'soul-field' },
+          e('div', { className: 'soul-field-label' }, t('bindings.listTitle')),
+          bindingsError
+            ? e('div', { className: 'soul-error' }, t('bindings.loadFailed', { reason: bindingsError }))
+            : (bindings === null
+                ? e('div', { className: 'soul-status' }, t('bindings.loading'))
+                : (sortedDirs.length === 0
+                    ? e('div', { className: 'soul-status' }, t('bindings.empty'))
+                    : e('div', null,
+                        e('div', { className: 'soul-status' },
+                          t('bindings.count', {
+                            count: String(sortedDirs.length),
+                            max: Number.isFinite(bindingsMax) ? String(bindingsMax) : '—'
+                          })),
+                        e('ul', { className: 'soul-bindings-rows' },
+                          sortedDirs.map((dir, at) => {
+                            // 与前面渲染过的某条构成父子关系时画 `└`，把「一条绑定 =
+                            // 一棵子树」画出来 —— 否则用户看不出为什么两个目录会用同一个人设
+                            const parent = sortedDirs.slice(0, at).find((prev) => (
+                              dir.startsWith(prev + '\\') || dir.startsWith(prev + '/')
+                            ))
+                            const isCurrent = currentCwd !== null && (
+                              currentCwd === dir ||
+                              currentCwd.startsWith(dir + '\\') ||
+                              currentCwd.startsWith(dir + '/')
+                            )
+                            const invalidName = invalidNames.get(dir)
+                            const value = invalidName || String(table[dir])
+                            const isInvalid = invalidName !== undefined
+                            return e('li', {
+                              key: dir,
+                              className: 'soul-bindings-row',
+                              'data-current': isCurrent ? 'true' : 'false'
+                            },
+                              parent && e('span', { className: 'soul-bindings-tree', 'aria-hidden': true }, '└'),
+                              e('code', { className: 'soul-bindings-dir', title: dir }, shortenPath(dir)),
+                              isCurrent && e('span', { className: 'soul-bindings-here' }, t('bindings.here')),
+                              isInvalid && e('span', { className: 'soul-bindings-bad' },
+                                t('bindings.invalid', { name: invalidName })),
+                              // 失效引用也画在下拉里（作为唯一选项）：让用户看到「现在写的是谁」，
+                              // 而不是看见一个空下拉、以为这条记录没有值
+                              e('select', {
+                                className: 'soul-bindings-select',
+                                value,
+                                'aria-label': t('bindings.persona'),
+                                onChange: (ev) => { void handleRebind(dir, ev.target.value) }
+                              },
+                                isInvalid && e('option', { value }, invalidName),
+                                names.map((name) => e('option', { key: name, value: name }, name))
+                              ),
+                              e(ui.Button, {
+                                // 待确认态靠文案已能区分（「确认解绑…」），
+                                // 红色描边是增强：className 若不透传也不影响可用性。
+                                className: pendingUnbind === dir ? 'soul-bindings-act-armed' : undefined,
+                                onClick: () => { void handleUnbind(dir) }
+                              }, pendingUnbind === dir ? t('bindings.unbindArmed') : t('bindings.unbind'))
+                            )
+                          })
+                        )
+                      ))
+        ),
+
+        // ④ 未绑定回落行：把隐式行为显式写成一条可改的规则
+        e('div', { className: 'soul-bindings-fallback' },
+          e('span', { className: 'soul-bindings-fallback-text' },
+            `${t('bindings.fallback')} · ${activePersona || t('quick.custom')}`),
+          e(ui.Button, {
+            onClick: onOpenPersonas
+          }, t('bindings.change'))
+        ),
+
+        // 「看到的不是全部」与「失败了」是两件事：前者是黄字警告，后者是红字
+        Number.isFinite(bindingsDropped) && bindingsDropped > 0 && e('div', { className: 'soul-status' },
+          t('bindings.dropped', { count: String(bindingsDropped) })),
+        bindingsWarning && e('div', { className: 'soul-status soul-bindings-warning' },
+          t('bindings.warning', { reason: bindingsWarning })),
+        errorNotice && e('p', { className: 'soul-error-notice', role: 'alert' }, errorNotice),
+        !errorNotice && notice && e('p', {
+          className: 'soul-saved-notice',
+          role: 'status',
+          'aria-live': 'polite'
+        }, notice)
+      )
       )
     }
 
-        function SoulSettings(props) {
+    function SoulSettings(props) {
       const { useSoulController, controller } = props
       // 渲染器按槽位 locale 命名空间注入 t（随语言切换更新）；缺失时回退中文
       const t = typeof props.t === 'function' ? props.t : FALLBACK_T
       const state = useSoulController((state) => state)
-      const { enabled, nickname, occupation, bio, style, headingLists, emoji, tables, replyLength, language, customInstructions, requireToolConfirmation, trailEnabled, trailColor, trailSpeed, trailWidth, personas, activePersona, personasError, saving, error } = state
+      const { enabled, nickname, occupation, bio, style, headingLists, emoji, tables, replyLength, language, customInstructions, requireToolConfirmation, trailEnabled, trailColor, trailSpeed, trailWidth, historyMaxEntries, personas, activePersona, personasError, history, historyWarning, historyMax, historyError, saving, error, bindings, bindingsMax, bindingsWarning, bindingsError, bindingsInvalid, bindingsDropped, bindingsSessions } = state
 
       const [localEnabled, setLocalEnabled] = React.useState(enabled)
       const [localNickname, setLocalNickname] = React.useState(nickname || '')
@@ -1388,6 +4348,10 @@ window.__ModuleLoader__.load({
       const [localTrailColor, setLocalTrailColor] = React.useState(trailColor || TRAIL_COLOR_FALLBACK)
       const [localTrailSpeed, setLocalTrailSpeed] = React.useState(trailSpeed || 'slow')
       const [localTrailWidth, setLocalTrailWidth] = React.useState(trailWidth || 'thin')
+      // 变更记录保留条数**不再是设置页的表单字段**（0.8.1 迁到插件详情页的变更记录
+      // 区块，就地改、立刻落盘）。因此它不进 localMap / savedMap / dirty ——
+      // 否则「在详情页改了容量」会让设置页的保存按钮莫名亮起，且点保存会把那份
+      // 详情页刚改的值当成「用户在这里的编辑」再提交一次。
       const [personaName, setPersonaName] = React.useState('')
       // 「存为预设」的命名弹层是否打开。
       //
@@ -1400,6 +4364,25 @@ window.__ModuleLoader__.load({
       //   ③ 「保存设置」与「保存当前为预设」两个保存并列，语义没区分；
       //      且名字要先想好才能点（disabled 依赖非空），交互顺序也别扭。
       const [showSavePersona, setShowSavePersona] = React.useState(false)
+      // 「更新到预设」弹层（0.9.0-s）：null = 关闭；字符串 = 正在选择目标预设名。
+      //
+      // 为什么单独一个入口而不复用「存为预设」：后者是**新建**（要名字），
+      // 前者是**覆盖已有**（选名字）。两个动作的用户意图不同，
+      // 混在一个入口里会让人分不清「我到底建了新的还是改了旧的」。
+      //
+      // 底层能力已经就位：savePersona(name, draft) 会存草稿，
+      // 且重复门禁会**排除同名条目**（即"覆盖同名"= 更新，天然允许）。
+      const [showUpdatePersona, setShowUpdatePersona] = React.useState(false)
+      // 「存为预设」弹层里的「保存后立即应用」复选框（0.9.0-t）。
+      //
+      // 解决的问题：保存预设后表单里仍是那套未保存的编辑 ⇒ 底部同时显示
+      // 「已保存预设「X」」和「有未保存的更改」两条，读起来矛盾（用户实测反馈）。
+      //
+      // 勾选 = 保存后把这套**应用为当前配置**（dirty 消失，★ 跟着这个预设走）；
+      // 不勾选 = 保存后把表单**回退到已保存配置**（例子里是自驱型协作者），
+      //          即「我把这套存起来了，但现在不切过去」。
+      // 默认不勾选：存预设与改当前配置是两件事，默认不该替用户静默改配置。
+      const [applyAfterSave, setApplyAfterSave] = React.useState(false)
       // 待删除的预设名（null = 没有待确认的删除）。
       //
       // 替代原生 window.confirm：原生模态框在 webview 里可能把文档焦点留在异常状态
@@ -1539,7 +4522,7 @@ window.__ModuleLoader__.load({
         : a === b)
       const savedMap = { enabled, nickname, occupation, bio, style, headingLists, emoji, tables, replyLength, language, customInstructions, requireToolConfirmation, trailEnabled, trailColor, trailSpeed, trailWidth }
       const localMap = { enabled: localEnabled, nickname: localNickname, occupation: localOccupation, bio: localBio, style: localStyle, headingLists: localHeadingLists, emoji: localEmoji, tables: localTables, replyLength: localReplyLength, language: localLanguage, customInstructions: localInstructions, requireToolConfirmation: localToolConfirm, trailEnabled: localTrailEnabled, trailColor: localTrailColor, trailSpeed: localTrailSpeed, trailWidth: localTrailWidth }
-      const dirty = FIELD_KEYS.some((key) => !sameValue(savedMap[key], localMap[key]))
+      const dirty = FORM_FIELD_KEYS.some((key) => !sameValue(savedMap[key], localMap[key]))
 
       // 宿主 savedNotice 语义：一旦用户开始新的编辑（dirty 变 true），
       // 上一条「已保存」就过时了 ⇒ 清除。（effect 必须放在 dirty 定义之后：
@@ -1664,15 +4647,111 @@ window.__ModuleLoader__.load({
 
       // 存为预设：把「关于你/特质」里的**当前设置**存成一个新预设。
       // 名字来自命名弹层；成功后关闭弹层并清空输入。
+      //
+      // ⚠️ 必须把**本地草稿**一起提交（0.9.0-r）：表单是「改完点保存才写回」的结构，
+      // 用户改完风格与自定义指令、没点「保存设置」直接点「存为预设」时，若只传名字，
+      // 服务端只能快照**已保存的旧配置** —— 存出来的预设还是上一个预设的内容
+      // （用户实测确认的 bug）。
+      //
+      // 只传人设字段：预设不含「关于你」（昵称 / 职业 / 介绍），它们不属于预设。
       const handleSavePersona = async () => {
         const name = personaName.trim()
         if (!name) return
         try {
-          await controller.savePersona(name)
+          const draft = {}
+          for (const key of SESSION_OVERRIDE_KEYS) {
+            // SESSION_OVERRIDE_KEYS 与 PERSONA_FIELDS 同集合（都含 language 与
+            // customInstructions，都不含「关于你」）—— 直接复用，不另造一份清单。
+            if (key in localMap) draft[key] = localMap[key]
+          }
+          await controller.savePersona(name, draft)
+
+          // 保存之后必须消解「已保存预设 X」与「有未保存更改」并存的矛盾（0.9.0-t）：
+          // 两条提示同时出现，读起来像"我到底存没存"。
+          //
+          // 勾选 ⇒ 把这套**应用为当前配置**（dirty 消失，★ 指向新预设）；
+          // 不勾选 ⇒ 把表单**回退到已保存配置**（丢弃这次编辑的表单值）。
+          if (applyAfterSave) {
+            await controller.usePersona(name)
+            // usePersona 里 applyConfig 会把 store 更新成该预设的值；
+            // 表单由下面的 effect 逐字段跟随（userEdited 判据会让"用户编辑过"的字段保留，
+            // 但这里我们刚把 store 改成与 draft 一致，故不会残留 dirty）。
+            await loadPersonas()
+            showSavedNotice(t('notice.personaSavedAndApplied', { name }))
+          } else {
+            // 回退表单：把 lastSyncRef 清空 ⇒ userEdited 一律视为"未编辑" ⇒
+            // 下一次 effect 用 store（已保存配置）覆盖全部表单字段。
+            lastSyncRef.current = null
+            // 直接把本地状态写回已保存配置，保证本帧就清掉 dirty（不等 effect）。
+            setLocalEnabled(enabled)
+            setLocalNickname(nickname || '')
+            setLocalOccupation(occupation || '')
+            setLocalBio(bio || '')
+            setLocalStyle(style)
+            setLocalHeadingLists(headingLists || 'default')
+            setLocalEmoji(emoji || 'default')
+            setLocalTables(tables || 'default')
+            setLocalReplyLength(replyLength || 'normal')
+            setLocalLanguage(language || 'zh')
+            setLocalInstructions(customInstructions || '')
+            setLocalToolConfirm(requireToolConfirmation === true)
+            setLocalTrailEnabled(trailEnabled)
+            setLocalTrailColor(trailColor)
+            setLocalTrailSpeed(trailSpeed)
+            setLocalTrailWidth(trailWidth)
+            await loadPersonas()
+            showSavedNotice(t('notice.personaSaved', { name }))
+          }
+
           setPersonaName('')
+          setApplyAfterSave(false)
           setShowSavePersona(false)
+        } catch (err) {
+          showError(messageOf(err))
+        }
+      }
+
+      // 更新到已有预设：把**当前草稿**覆盖写进某个已有预设（0.9.0-s）。
+      //
+      // 与 handleSavePersona 的唯一差别是「名字已存在」—— 底层是同一个
+      // controller.savePersona(name, draft)：重复门禁会排除同名条目，
+      // 所以「覆盖自己」天然被允许，不需要额外的 force 参数。
+      //
+      // 成功后**不动活动配置**：这是「把当前这套存回某个预设」，
+      // 不是「应用某个预设」。用户改的配置仍然是当前配置。
+      const handleUpdatePersona = async (name) => {
+        if (!name) return
+        try {
+          const draft = {}
+          for (const key of SESSION_OVERRIDE_KEYS) {
+            if (key in localMap) draft[key] = localMap[key]
+          }
+          await controller.savePersona(name, draft)
+
+          // 表单回退到**当前配置**：更新的是某个预设，不是当前配置，
+          // 所以那套编辑不该继续挂在表单上（否则「已更新预设」+「有未保存的更改」
+          // 并存，仍然是矛盾提示）。
+          lastSyncRef.current = null
+          setLocalEnabled(enabled)
+          setLocalNickname(nickname || '')
+          setLocalOccupation(occupation || '')
+          setLocalBio(bio || '')
+          setLocalStyle(style)
+          setLocalHeadingLists(headingLists || 'default')
+          setLocalEmoji(emoji || 'default')
+          setLocalTables(tables || 'default')
+          setLocalReplyLength(replyLength || 'normal')
+          setLocalLanguage(language || 'zh')
+          setLocalInstructions(customInstructions || '')
+          setLocalToolConfirm(requireToolConfirmation === true)
+          setLocalTrailEnabled(trailEnabled)
+          setLocalTrailColor(trailColor)
+          setLocalTrailSpeed(trailSpeed)
+          setLocalTrailWidth(trailWidth)
+
+          setShowUpdatePersona(false)
           await loadPersonas()
-          showSavedNotice(t('notice.personaSaved', { name }))
+          showSavedNotice(t('notice.personaUpdated', { name }))
         } catch (err) {
           showError(messageOf(err))
         }
@@ -1730,38 +4809,13 @@ window.__ModuleLoader__.load({
         return () => clearTimeout(timer)
       }, [pendingDelete])
 
-      // —— 卡背（详情面）用到的三个辅助 ——
+      // —— 卡背（详情面）用到的辅助 ——
       //
-      // 列出「一个人设完整的六个维度」。顺序与设置页表单一致（风格 → 标题列表 →
-      // 表情 → 表格 → 回复长度 → 语言），这样卡背读起来与设置页对得上。
-      const PERSONA_DIM_KEYS = ['style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language']
-
-      // 单个维度的「值」文案。刻意**不把与默认相同的项留空**：设置页里 trait 的默认值
-      // 就是 'default'，而卡背要回答的是「这个人设改了什么」—— 统一标成「默认」比留空
-      // 更清楚（留空会让人以为渲染坏了）。
-      // 语言维度复用 LANGUAGE_OPTIONS 的标签（'中文' / 'English' 两种语言下同名，
-      // 本来就是语言自称，无需翻译）。
-      const personaDimLabel = (entry, dim) => {
-        const row = entry || {}
-        const value = row[dim]
-        if (dim === 'language') {
-          const opt = LANGUAGE_OPTIONS.find((o) => o.value === value)
-          return opt ? opt.label : t('personas.dimDefault')
-        }
-        if (dim === 'style') {
-          return STYLE_VALUES.includes(value) ? t(`style.${value}`) : t('personas.dimDefault')
-        }
-        return TRAIT_VALUES.includes(value) ? t(`trait.${dim}.${value}`) : t('personas.dimDefault')
-      }
-
-      // 卡背的全文：这一次**不截断**（正面效果栏才截断）。
-      // 预设没写自定义指令时给一句说明，而不是留空 —— 留空会让人以为渲染坏了。
-      const personaFullText = (entry) => {
-        const raw = typeof (entry || {}).customInstructions === 'string'
-          ? entry.customInstructions.trim()
-          : ''
-        return raw === '' ? t('personas.noCustomInstructions') : raw
-      }
+      // 0.9.0-d 起这三样提到**模块级**（personaDimLabelOf / personaFullTextOf /
+      // PERSONA_DIM_KEYS 已在模块级）：会话「人设」tab 的右侧详情面板要显示与设置页
+      // 卡背**逐字相同**的维度与全文，各写一份必然漂移。
+      const personaDimLabel = (entry, dim) => personaDimLabelOf(entry, dim, t)
+      const personaFullText = (entry) => personaFullTextOf(entry, t)
 
       const styleOptions = STYLE_VALUES.map((value) => ({ value, label: t(`style.${value}`) }))
       const headingListsOptions = TRAIT_VALUES.map((value) => ({ value, label: t(`trait.headingLists.${value}`) }))
@@ -1778,6 +4832,12 @@ window.__ModuleLoader__.load({
         })
         : null
 
+      // 可被「更新到预设」覆盖的预设 = **自建**的那些（0.9.0-s）。
+      // 内置预设不可改：五条写路径都拒绝内置名，列出来只会让用户点了吃一个 400。
+      const editablePersonaNames = (personaNames || []).filter(
+        (name) => !(personas && personas[name] && personas[name].builtin)
+      )
+
       // 展开「人设预设」分组时，轮播自动定位到**当前生效**的那张，而不是永远停在第 1 张。
       //
       // 为什么需要：卡片一次只展示一张，若固定从第 1 张开始，用户点开分组后要翻好几下
@@ -1818,6 +4878,20 @@ window.__ModuleLoader__.load({
       const personasSummary = personasError
         ? t('accordion.loadFailed')
         : (personas === null ? t('status.loading') : `${Object.keys(personas).length} ${t('accordion.personas')}`)
+      // 工作区绑定摘要：折叠态只看得到这一行，所以要先说「读没读出来」，
+      // 再说条数。null = 还没拉过（本分组懒加载，展开前一直是 null）⇒ 显示空态文案，
+      // 不显示「0 条」—— 那会把「没加载」误报成「一条都没有」。
+      //
+      // 0.8.1 分组已从设置页撤下，这里暂时无人引用；保留是因为 0.9.0 的工作区
+      // 平铺卡片要用同一套「摘要怎么说」的判断（加载中 / 失败 / 0 条 / N 条）。
+      // 删掉它只会让那段逻辑在 0.9.0 被重写一遍，而那正是容易漏掉「加载中≠空」的地方。
+      const bindingsSummary = bindingsError
+        ? t('accordion.loadFailed')
+        : (bindings === null || !bindings || typeof bindings !== 'object' || Array.isArray(bindings)
+            ? t('bindings.empty')
+            : (Object.keys(bindings).length === 0
+                ? t('bindings.empty')
+                : t('bindings.count', { count: String(Object.keys(bindings).length), max: Number.isFinite(bindingsMax) ? String(bindingsMax) : '—' })))
       const toolSummary = localToolConfirm ? t('accordion.on') : t('accordion.off')
       const promptSummary = promptText.length > 0
         ? t(promptIsDraft ? 'prompt.summaryDraft' : 'prompt.summaryChars', { n: String(promptText.length) })
@@ -1830,33 +4904,12 @@ window.__ModuleLoader__.load({
       // 预设只描述 Agent 的人格，不含「关于你」（昵称 / 职业 / 介绍）—— 那是使用者
       // 的身份信息，不随预设切换。所以摘要里不再出现昵称，剩下的恰好也是比较两个
       // 预设时最需要看到的信息。
-      const personaRowMeta = (entry) => {
-        const row = entry || {}
-        const parts = []
-        if (STYLE_VALUES.includes(row.style)) parts.push(t(`style.${row.style}`))
-        else if (row.style) parts.push(row.style)
-        for (const [field, allowed] of Object.entries(META_FIELD_VALUES)) {
-          const value = row[field]
-          if (!value || value === META_FIELD_DEFAULTS[field]) continue
-          if (!allowed.includes(value)) continue
-          parts.push(t(`meta.${field}.${value}`))
-        }
-        return parts.join(' · ')
-      }
-
-      // 卡牌效果栏文本：优先用预设的 customInstructions（它是人格差异的主要载体），
-      // 没有则退回维度摘要。为什么取 customInstructions 而不是摘要：摘要只说
-      // 「专业严谨 · 默认」这类档位，而卡牌需要一句话说清「这个预设会怎么回答」。
-      //
-      // 截断到第一句或 60 字：卡面空间有限，CSS 侧还有 3 行 line-clamp 兜底。
-      const personaEffectText = (entry) => {
-        const raw = typeof (entry || {}).customInstructions === 'string' ? entry.customInstructions.trim() : ''
-        if (raw === '') return personaRowMeta(entry)
-        // 按中文句号/分号/换行切第一句；无标点时整段交给 CSS 截断
-        const firstSentence = raw.split(/[。；;\n]/)[0] || raw
-        const text = firstSentence.length > 60 ? `${firstSentence.slice(0, 60)}…` : firstSentence
-        return text
-      }
+      //
+      // 0.9.0 起这两个函数提到**模块级**（personaRowMetaOf / personaEffectTextOf）：
+      // 会话「人设」tab 与工作区卡片也要用同一种措辞 —— 同一个预设在两处显示不同的
+      // 摘要，用户会以为它们不是同一个东西。这里保留同名薄包装，避免改动大量调用点。
+      const personaRowMeta = (entry) => personaRowMetaOf(entry, t)
+      const personaEffectText = (entry) => personaEffectTextOf(entry, t)
 
       return e('div', { className: 'soul-section' },
         e('div', { className: 'soul-title-row' },
@@ -2019,6 +5072,9 @@ window.__ModuleLoader__.load({
             open: openSection === 'personas',
             onToggle: toggleSection('personas')
           },
+            // 保留条数下拉不在这里 —— 0.8.1 起它跟着变更记录走，落在**插件详情页**
+            // 的变更记录区块里（容量参数与被它约束的内容放在一起才说得通）。
+            // 设置页这一组只负责预设本身与那句去向指引。
             e('div', { className: 'soul-field' },
               // 加载失败优先于「加载中」：否则失败时界面永远停在加载态，与「还没有预设」无从区分
               personasError
@@ -2127,7 +5183,12 @@ window.__ModuleLoader__.load({
                             // 名称与摘要压在图上
                             e('div', { className: 'soul-persona-art-title' },
                               e('span', { className: 'soul-persona-name' },
-                                e('span', { className: 'soul-persona-label' }, name === activePersona ? `★ ${name}` : name)
+                                e('span', { className: 'soul-persona-label' }, name === activePersona ? `★ ${name}` : name),
+                                // 作用域标注：设置页的「使用」写的是**全局**（settings.section
+                                // 拿不到 sessionId，这是宿主槽位契约决定的）。标出来是为了
+                                // 避免用户以为「在这里点了使用 = 只影响这个项目」——
+                                // 三级隔离下那是会话/工作区层的事。
+                                e('span', { className: 'soul-persona-scope-tag' }, t('personas.scopeGlobal'))
                               ),
                               e('div', { className: 'soul-persona-meta' }, personaRowMeta(entry))
                             )
@@ -2289,12 +5350,50 @@ window.__ModuleLoader__.load({
               e('button', {
                 type: 'button',
                 className: 'soul-drift-action',
-                onClick: () => { setPersonaName(''); setShowSavePersona(true) }
+                onClick: () => { setPersonaName(''); setApplyAfterSave(false); setShowSavePersona(true) }
               }, t('personas.driftAction'))
             ),
-            e('div', { className: 'soul-status' }, t('personas.hint'))
+            // —— 说明：一条轻提示 + 一个可点的去向，不再铺两行正文 ——
+            //
+            // 原来这里是两行灰字，每行都在复述用户已经能从界面里看到的东西：
+            //   ·「风格 / 特质 / 回复长度 / 输出语言 / 自定义指令」—— 就是卡片上那几行；
+            //   ·「内置预设不可删除」—— 每张内置卡都有「内置」徽标、且没有删除按钮；
+            //   ·「撤销、恢复预设、清空都在那里」—— 是详情页上三个按钮的名字。
+            // 名词语气+穷举，读起来像条款。现在只留**用户真正会问的那一个判断**
+            //（「存这个会不会把我的昵称也换掉」），其余降级为问号里的 hover 全文。
+            e('div', { className: 'soul-note soul-note-inline' },
+              e('span', { className: 'soul-note-text' }, t('personas.hint')),
+              e(SoulHint, { text: t('personas.hintDetail') })
+            ),
+            // 变更记录：一行「改动都能撤销」+ 问号里的全文。
+            //
+            // 这里**刻意不放「打开插件详情」按钮**：宿主 settings.section 槽位的
+            // slotInject 是空串（见 dsh-cordis-client-runner 的槽位清单），设置页
+            // 拿不到任何导航能力，点了也没法跳转 —— 一个点不动的按钮比没有更糟。
+            e('div', { className: 'soul-note soul-note-inline' },
+              e('span', { className: 'soul-note-text' }, t('history.entryHint')),
+              e(SoulHint, { text: t('history.entryHintMore') })
+            )
           ),
 
+          // ——「工作区绑定」分组已从设置页撤下（0.8.0 发布前）——
+          //
+          // 原计划 0.8.1 交付「按目录绑人设」。但它要做的事（让目录决定人设）已经被
+          // 0.9.0 的三级隔离（Global → Workspace → Session）整体接管，而这个分组是
+          // 按「目录字符串」思考的 —— 工作区平铺卡片的交互形态与它完全不同，留下它
+          // 只会让用户先学一套即将被替换的操作方式。
+          //
+          // **只摘渲染，逻辑层一行不动**：
+          //   · lib/bindings.mjs 的路径规范化 / realpath / 前缀匹配是硬资产，0.9.0 直接复用；
+          //   · 宿主侧的 cwd 解析、三条绑定路由、controller 方法全部保留 ——
+          //     没有任何用户持有 soul-bindings.json（特性从未发布），解析恒为 null、
+          //     行为与「没有绑定功能」完全一致，失败方向安全；
+          //   · SoulBindings 组件与 .soul-bindings-* 样式同样保留，0.9.0 重写 UI 时替换。
+          //
+          // 对应的行为用例 C29–C33 已随 UI 一并删除（它们测的是点击这个分组之后的
+          // 交互，分组不在渲染树里就没有可断言的对象）。逻辑层仍由 verify-bindings
+          // （47 项）与 verify-e2e-prompt 的 R1–R13 守着。
+
           e(SoulAccordion, {
             id: 'soul-tools',
             title: t('group.tool'),
@@ -2392,6 +5491,11 @@ window.__ModuleLoader__.load({
           )
         ),
 
+        // —— 变更记录：设置页不再留独立指引行 ——
+        // 指引并入「人设预设」展开区的说明块（与 personas.hint 合并展示）：
+        // 独立一行在个性化区块里突兀，而折叠标题旁挂 hover 又说不到点上
+        //（它解释的是展开后的东西）。这里不再渲染任何 history 状态，渲染成本为零。
+
         e(SoulAccordion, {
           id: 'soul-prompt',
           title: t(promptIsDraft ? 'prompt.titleDraft' : 'prompt.title'),
@@ -2426,6 +5530,14 @@ window.__ModuleLoader__.load({
             onClick: () => { setPersonaName(''); setShowSavePersona(true) },
             disabled: saving
           }, t('personas.saveAs')),
+          // 「更新到预设」（0.9.0-s）：把当前草稿覆盖写回某个已有自建预设。
+          //
+          // 只列**自建**预设：内置预设不可改（写入路径一律拒绝内置名），
+          // 列出来只会让用户点了吃一个 400。
+          e(ui.Button, {
+            onClick: () => setShowUpdatePersona(true),
+            disabled: saving || editablePersonaNames.length === 0
+          }, t('personas.updateTo')),
           e(ui.Button, {
             onClick: handleReset,
             disabled: saving
@@ -2468,9 +5580,23 @@ window.__ModuleLoader__.load({
               e('div', null, t('personas.saveCovers')),
               e('div', { className: 'soul-modal-note-excl' }, t('personas.saveExcludes'))
             ),
+            // 「保存后立即应用」（0.9.0-t）：显式让用户选「存完要不要切过去」。
+            //
+            // 不加这个开关时，保存预设后表单里仍是那套未保存编辑 ⇒ 底部同时显示
+            // 「已保存预设「X」」和「有未保存的更改」，读起来矛盾。
+            // 默认不勾：存预设与改当前配置是两件事，不该替用户静默改配置。
+            e('label', { className: 'soul-modal-check' },
+              e('input', {
+                type: 'checkbox',
+                checked: applyAfterSave,
+                onChange: (ev) => setApplyAfterSave(ev.target.checked)
+              }),
+              e('span', null, t('personas.applyAfterSave')),
+              e('span', { className: 'soul-modal-check-hint' }, t('personas.applyAfterSaveHint'))
+            ),
             e('div', { className: 'soul-modal-actions' },
               e(ui.Button, {
-                onClick: () => { setShowSavePersona(false); setPersonaName('') }
+                onClick: () => { setShowSavePersona(false); setPersonaName(''); setApplyAfterSave(false) }
               }, t('button.cancel')),
               e(ui.Button, {
                 variant: 'primary',
@@ -2481,6 +5607,49 @@ window.__ModuleLoader__.load({
           )
         ),
 
+        // ——「更新到预设」弹层（0.9.0-s）——
+        // 列出可覆盖的自建预设，点一个即写入。不询问名字（名字已经定了）。
+        showUpdatePersona && e('div', {
+          className: 'soul-modal-mask',
+          role: 'presentation',
+          onClick: () => setShowUpdatePersona(false)
+        },
+          e('div', {
+            className: 'soul-modal',
+            role: 'dialog',
+            'aria-modal': 'true',
+            'aria-label': t('personas.updateTo'),
+            onClick: (ev) => ev.stopPropagation()
+          },
+            e('div', { className: 'soul-modal-title' }, t('personas.updateTo')),
+            editablePersonaNames.length === 0
+              ? e('div', { className: 'soul-modal-note' }, t('personas.updateNone'))
+              : e('div', { className: 'soul-update-list' },
+                ...editablePersonaNames.map((name) => e('button', {
+                  key: name,
+                  type: 'button',
+                  className: 'soul-update-item',
+                  disabled: saving,
+                  onClick: () => { void handleUpdatePersona(name) }
+                },
+                  e('span', { className: 'soul-update-name' }, name),
+                  // 标出「当前生效」的那个：覆盖它之后 ★ 不会变（字段本来就一样），
+                  // 覆盖别的预设会改变那个预设的内容 —— 用户该知道这一点。
+                  name === activePersona && e('span', { className: 'soul-update-badge' }, t('personas.active'))
+                ))
+              ),
+            e('div', { className: 'soul-modal-note' },
+              e('div', null, t('personas.updateCovers')),
+              e('div', { className: 'soul-modal-note-excl' }, t('personas.updateExcludes'))
+            ),
+            e('div', { className: 'soul-modal-actions' },
+              e(ui.Button, {
+                onClick: () => setShowUpdatePersona(false)
+              }, t('button.cancel'))
+            )
+          )
+        ),
+
         dirty && !saving && e('div', { className: 'soul-status soul-dirty' }, t('status.unsaved')),
 
         // —— 内联结果提示（对齐宿主模型设置页的全局形态）——
@@ -2651,6 +5820,21 @@ window.__ModuleLoader__.load({
         }
       }, 'dsh-soul: global refresh polling')
 
+      // —— 目录点选服务（0.8.1-d）——
+      //
+      // 用**动态** ctx.inject 拿 uiWorkspace，而不是把它写进上面的静态 inject 数组：
+      // 静态数组里少一个服务，整个插件就不激活（设置页、人设卡、底栏一起消失）。
+      // 目录选择器只是「能点一下就填路径」的便利，缺了它手输照常可用 ⇒ 必须可缺。
+      // 服务到齐时写进模块级 directoryPicker，SoulBindings 的「选择目录…」才可见；
+      // 调用失败（宿主 pickDirectory 抛错）时组件自行降级为手输，见 §7.5。
+      ctx.inject(['uiWorkspace'], (scope) => {
+        directoryPicker = scope.uiWorkspace
+        scope.effect(() => () => {
+          // 服务撤走 = 界面上不该再出现那个按钮（回调可能已被替换成新的 scope）
+          if (directoryPicker === scope.uiWorkspace) directoryPicker = null
+        }, 'dsh-soul: directory picker teardown')
+      })
+
       // 暗色适配说明：原生 <select> 的弹出选项列表由浏览器按 color-scheme 渲染。
       // 宿主主题呈现器会把 html 的 color-scheme 与 body[data-ds-dark-theme] 随主题
       // 投影到 document（见 dsh-client-ui-layout ThemePresenter），因此这里用纯 CSS
@@ -2813,19 +5997,157 @@ window.__ModuleLoader__.load({
       ctx.effect(() => registerSettingsNavIcon(), 'dsh-soul: settings navigation icon')
 
       // 注册到输入框工具栏：宿主会把 input.left 放在「操作权限」控件之后。
+      // conversation.input.left 是 scope:'session' 槽位 —— 宿主为它准备的标准 props
+      // 里带 sessionId（ui-session 的 BUILTIN_SOURCE: props: ["sessionId"]）。
+      //
+      // 有了它，输入框下方的标签才能显示**当前会话**实际生效的人设与来源；
+      // 否则只能读全局 store 的 activePersona，而那与模型真正拿到的人设可能不同。
       ctx.slots.inject('conversation.input.left', () => ctx.slots.register({
         name: 'conversation.input.left',
         id: 'soul-quick-toggle',
         order: 50,
         locale: NS,
+        // ⚠️ inject 回调收到的是**位置参数** [sessionId]，不是 props 对象！
+        //
+        // 宿主契约（FactoryInjectParams）：
+        //   scope 'session'      → [sessionId: SessionId]
+        //   scope 'session-maybe'→ [sessionId: SessionId | undefined]
+        //   scope 'root'         → []
+        //
+        // 这里曾写成 inject: (props) => ({ sessionId: props?.sessionId }) ——
+        // props 实际是 sessionId **字符串**，props.sessionId 是 undefined，
+        // 于是 sessionId 恒为 null，标签永远拿不到当前会话，
+        // 层级标注（本会话覆盖 / 全局配置 / 工作区）**整块不显示**。
+        inject: (sessionId) => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller,
+          sessionId: typeof sessionId === 'string' && sessionId !== '' ? sessionId : null
+        })
+      }, SoulQuickToggle))
+
+
+      // 侧栏会话行 hover 面具按钮（0.9.0-ab）。
+      //
+      // conversation.session.header.actions 与 conversation.hero.options 都挂了
+      // 同一人设标识 —— 侧栏是第三处：会话列表里不用点开就能看到每行是谁。
+      //
+      // 槽位：sidebar.workspaces.session.row.action（kind:'list' / scope:'root'）。
+      //
+      // ⚠️ sessionId 的来源与 session 槽位**不同**：renderer 的 runInject 对
+      // inject 回调只传 [binding.key, actions] —— root 槽位没有 binding ⇒
+      // inject 无参、拿不到任何东西。而这一槽位的 sessionId 是 **owner props**
+      // （SessionRowOwnerProps: { sessionId, displayTitle }），由 renderer 的
+      // guarded(entry, key, owner = ownerProps) 直接并入组件 props。
+      // ⇒ inject 只负责注入 hooks；sessionId 由组件从 props.sessionId 读。
+
+      // 侧栏面板图标（0.9.0-ac，0.9.0-ad 回滚重做）。
+      //
+      // ❌ 第一版教训：注册 id 'plugins'（复用宿主插件管理器的 cell id）——
+      // 文档里 "reusing a shipped id puts you in THAT cell" 的真正含义是
+      // **替换该单元**，不是"并存"。实测把插件管理器的图标顶没了（用户报：
+      // "你把插件整没了"）。
+      //
+      // ✅ 现在：注册**自己的 id**（'soul-persona-panel'）。点击后宿主
+      // selectPanel('soul-persona-panel') 会切到一个未注册的面板 ——
+      // 宿主文档说这种情况 "preserves the current selection"（保持当前选择，
+      // 不会白屏）。图标本身仍显示：它是 Soul 的入口标识，hover 有名字。
+      //
+      // 长期方案（未做）：注册独立 main 面板承载「预设库管理」，那时这个图标
+      // 才有真正的落地页。需要把人设管理从会话语境拆出来 —— 独立的活。
+      // ❌ 暂时隐藏（0.9.0-ag）：点击切到未注册面板会"保持当前选择"（点了没反应），
+      // 体验差。等独立 main 面板（预设库管理主页）做好后再启用。
+      // 组件 SoulPanelIcon 与本注册块保留在源码里（注释态），作为那时的起点。
+      // ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({
+      //   name: 'sidebar.panellist',
+      //   id: 'soul-persona-panel',
+      //   order: 20,
+      //   locale: NS,
+      //   label: () => navT('nav.label'),
+      //   inject: () => ({})
+      // }, SoulPanelIcon))
+
+      // 宿主 hover 信息卡里的「人设」一行（0.9.0-aj）。
+      // 与行尾徽标共用 useSessionRowPersona：同一份数据、同一套降级规则。
+      ctx.slots.inject('sidebar.session.row.hover', () => ctx.slots.register({
+        name: 'sidebar.session.row.hover',
+        id: 'soul-persona',
+        order: 50,
+        locale: NS,
         inject: () => ({
           hooks: {
             soulController: controller.store
           },
           controller
         })
-      }, SoulQuickToggle))
+      }, SoulSessionPersonaHover))
+
+      ctx.slots.inject('sidebar.workspaces.session.row.action', () => ctx.slots.register({
+        name: 'sidebar.workspaces.session.row.action',
+        id: 'soul-persona-badge',
+        order: 300,
+        locale: NS,
+        inject: (owner) => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller,
+          // 防御性兼容：宿主文档说 owner props 并入**组件** props；万一某版本把它
+          // 交给 inject，这里也把 sessionId 透传过去（组件侧两路都读）。
+          sessionId: owner && typeof owner === 'object' && typeof owner.sessionId === 'string'
+            ? owner.sessionId
+            : undefined
+        })
+      }, SoulSessionPersonaBadge))
+
+      // 会话人设标签（第二处）：**新会话**那一行（输入框上方）。
+      //
+      // conversation.hero.options —— 宿主文档："Compact options right-aligned in the
+      // New Session row after the workspace and preset controls; rendered only with a
+      // Session." 正是用户画的红框位置：工作区 chip 与「创造模式」之后、右对齐。
+      //
+      // 与 header 那个（见下）是**同一个组件**（SoulSessionPersonaLabel）、读同一份
+      // store 数据 —— 新会话时 hero 区显示这个，首轮对话后 hero 消失、header 出现，
+      // 宿主本来就做了这个交接。
+      ctx.slots.inject('conversation.hero.options', () => ctx.slots.register({
+        name: 'conversation.hero.options',
+        id: 'soul-persona-label-hero',
+        order: 10,
+        locale: NS,
+        // scope:'session' 槽位 ⇒ inject 收**位置参数** [sessionId]（宿主契约
+        // FactoryInjectParams），不是 props 对象。
+        inject: (sessionId) => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller,
+          sessionId: typeof sessionId === 'string' && sessionId !== '' ? sessionId : null
+        })
+      }, SoulSessionPersonaLabel))
 
+      // 会话人设标签：挂到会话 header（标题旁，「创造模式」「费用明细」那一行）。
+      //
+      // 槽位是 kind:'list' / scope:'session'，可安全追加（宿主的 occupants：
+      // agent-team(-20) / agent-preset(-10) / subagent-catalog(10) / job-list(20)）。
+      // order: 30 排在它们之后 —— 标签在视觉上属于「补充信息」，
+      // 不该插到「创造模式」和「费用明细」这些主动作之间。
+      //
+      // inject 收到的是**位置参数** [sessionId]（宿主契约 FactoryInjectParams：
+      // scope 'session' → [sessionId: SessionId]），不是 props 对象。
+      ctx.slots.inject('conversation.session.header.actions', () => ctx.slots.register({
+        name: 'conversation.session.header.actions',
+        id: 'soul-persona-label',
+        order: 30,
+        locale: NS,
+        inject: (sessionId) => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller,
+          sessionId: typeof sessionId === 'string' && sessionId !== '' ? sessionId : null
+        })
+      }, SoulSessionPersonaLabel))
 
       // 输入框光轨：注册到输入框卡片内部的 overlay 槽位。
       // 组件不渲染可见内容——它按会话运行态在最近的输入框卡片上挂载/隐藏 SVG 环；
@@ -2856,6 +6178,82 @@ window.__ModuleLoader__.load({
         })
       }, SoulSettings))
 
+      // —— 变更记录主入口：插件详情页（0.8.1 双入口）——
+      // 槽位 plugins.detail.section（list/root）：宿主在插件详情页自身内容下方
+      // 为每个注册者渲染一个自定义区块；subject 形态与判据见 SoulHistorySection
+      // 头注释（只服务 subject.pkg.name === 'dsh-soul' 的 bundle 详情页）。
+      // 槽位不存在时 inject 静默不注册 ⇒ 由 verify-config 的源文本契约断言钉住槽位名。
+      ctx.slots.inject('plugins.detail.section', () => ctx.slots.register({
+        name: 'plugins.detail.section',
+        id: 'soul-detail-history',
+        order: 50,
+        locale: NS,
+        inject: () => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller
+        })
+      }, SoulHistorySection))
+
+      // —— 会话「人设」tab（0.9.0-d）——
+      //
+      // 槽位 `conversation.view` 是**列表**槽位：宿主用 `slots.entries(...)` 动态枚举
+      // 生成 tab 栏（与轨迹 / 上下文 / 编队同机制），所以注册后会自动出现，不需要改宿主。
+      //
+      // 唯一的入口价值在于它的 inject 签名是 `(sessionId) => props` —— 这是插件
+      // 能拿到**当前会话 id** 的唯一正规途径（设置页的 slotInject 是空串，拿不到）。
+      // 因此 sessionId 必须原样传给组件，不能只传 controller。
+      //
+      // order 排在宿主内置视图之后（对话 0 / 轨迹 10 / 上下文 20 / 编队 30 级），
+      // 用 90 确保「人设」在最右，不打乱用户已经熟悉的顺序。
+      ctx.slots.inject('conversation.view', () => ctx.slots.register({
+        name: 'conversation.view',
+        id: 'soul-persona',
+        order: 90,
+        label: () => navT('session.tabLabel'),
+        locale: NS,
+        inject: (sessionId) => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller,
+          sessionId: typeof sessionId === 'string' ? sessionId : null
+        })
+      }, SoulSessionPersona))
+
+      // —— 工作区人设（0.9.0-e）——
+      //
+      // 注册到插件详情页：与变更记录同一槽位，宿主为每个注册者渲染一个区块。
+      // 不与设置页放在一起的原因写在 SoulWorkspaces 头注释里（低频 + 需要空间）。
+      ctx.slots.inject('plugins.detail.section', () => ctx.slots.register({
+        name: 'plugins.detail.section',
+        id: 'soul-detail-workspaces',
+        order: 40, // 排在变更记录（50）之前：人设是"怎么配"，记录是"改过什么"
+        locale: NS,
+        inject: () => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller
+        })
+      }, SoulWorkspaces))
+
+      // —— 会话覆盖清理（0.9.0-f）——
+      // 同一槽位、order 60：排在变更记录之后（它是这三块里最低频的运维动作）。
+      ctx.slots.inject('plugins.detail.section', () => ctx.slots.register({
+        name: 'plugins.detail.section',
+        id: 'soul-detail-sessions',
+        order: 60,
+        locale: NS,
+        inject: () => ({
+          hooks: {
+            soulController: controller.store
+          },
+          controller
+        })
+      }, SoulSessions))
+
       // 初始配置的拉取已并入上面的全局轮询 —— 它的 refresh() 在注册时立即执行一次
       // （含 loadConfig + loadPersonas），这里再调一次就是同一次装配发两个相同请求。
     }