dsh-soul 0.7.2 → 0.8.0

package/client/index.mjs

@@ -48,7 +48,7 @@ window.__ModuleLoader__.load({
     // -------------------------------------------------------------------------
 
     const NS = 'soul'
-    const VERSION = '0.7.2'
+    const VERSION = '0.8.0'
     const INITIAL = {
       enabled: true,
       nickname: '',
@@ -73,6 +73,35 @@ window.__ModuleLoader__.load({
       activePersona: null,
       // 预设列表请求失败的原因（成功时清空）。用于把「加载中」与「加载失败」区分开
       personasError: null,
+      // 变更记录（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 +156,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 +437,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() {
@@ -521,6 +562,141 @@ 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
+      }
+
       // 统一请求：body 为 null 时不携带请求体（GET 用）
       async postJSON(path, body, overrides = {}) {
         const url = new URL(path, hostBase())
@@ -605,6 +781,8 @@ 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}',
@@ -643,6 +821,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：插画是卡面主视觉（方形满铺），名称与摘要压在图上由渐变承接，
@@ -869,6 +1056,120 @@ 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}',
+      // 保留条数（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}',
+      '.soul-history-more{align-self:flex-start;margin-top:8px;padding:0;border:0;background:transparent;color:var(--dsw-alias-brand-primary);font:inherit;font-size:12px;line-height:18px;cursor:pointer}',
+      '.soul-history-more:hover{text-decoration:underline}',
+      '.soul-history-more:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
+      // —— 设置页「工作区绑定」分组（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}',
+      '.soul-bindings-pick,.soul-bindings-bind{box-sizing:border-box;flex:none;display:inline-flex;align-items:center;height:32px;padding:0 10px;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}',
+      '.soul-bindings-pick:hover,.soul-bindings-bind:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.soul-bindings-pick:focus-visible,.soul-bindings-bind:focus-visible,.soul-bindings-action:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
+      // 人设下拉不许被压到看不见：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-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}',
+      '.soul-bindings-action:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.soul-bindings-action-armed{border-color:var(--dsw-alias-state-error-primary);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}}'
@@ -965,7 +1266,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 +1301,114 @@ 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': '改',
       '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.more': '还有 {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': '取消',
@@ -1124,7 +1536,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 +1566,108 @@ 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',
       '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.more': '{count} more',
+      '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',
@@ -1264,14 +1776,100 @@ 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` 属于插件详情页的变更记录区块（改完即时落盘，不经保存按钮）。
+    const EXTERNALLY_MANAGED_FIELDS = ['historyMaxEntries']
+
+    // 配置字段全集（宿主 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'
+    }
+
+    // 与 lib/history.mjs 的 HISTORY_SOURCES 对齐；认不出的来源原样显示。
+    const HISTORY_SOURCES = ['web', 'command', 'tool', 'service', 'persona', 'rollback', 'restorePersona']
+
+    // 一次最多铺开多少条。记录上限是 200 条，全渲染会让这一组比整个设置页还长；
+    // 超出的折成一行「还有 N 条」，想看完的人再点一次。
+    const HISTORY_RENDER_LIMIT = 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
@@ -1298,6 +1896,11 @@ window.__ModuleLoader__.load({
     }
 
     // 可折叠设置面板：同一时间只展开一个区域，并持久化用户最后的选择。
+    //
+    // 曾经这里有个 `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' : ''}` },
@@ -1316,6 +1919,377 @@ window.__ModuleLoader__.load({
       )
     }
 
+    // —— 变更记录（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 [showAllHistory, setShowAllHistory] = React.useState(false)
+
+      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' },
+                  ...(showAllHistory ? history : history.slice(0, HISTORY_RENDER_LIMIT)).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')) }))
+                      )
+                    )
+                  })
+                ),
+
+                // 「最近 200 条」这句承诺得配一个能看到更多的出口。
+                !showAllHistory && history.length > HISTORY_RENDER_LIMIT && e('button', {
+                  type: 'button',
+                  className: 'soul-history-more',
+                  onClick: () => setShowAllHistory(true)
+                }, t('history.more', { count: String(history.length - HISTORY_RENDER_LIMIT) })),
+
+                e('div', { className: 'soul-status' }, t('history.footer'))
+              )))
+      )
+    }
+
     // 输入框工具栏快捷开关：复用全局 soulController，和设置页保持同一份状态。
     function SoulQuickToggle(props) {
       const { useSoulController, controller } = props
@@ -1365,12 +2339,322 @@ window.__ModuleLoader__.load({
       )
     }
 
-        function SoulSettings(props) {
+    // -------------------------------------------------------------------------
+    // 设置页「工作区绑定」分组（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)
+    }
+
+    // 「工作区绑定」主体。三块结构见 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，
+      // 客户端读不到种类。见 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。
+            !pickerFailed && directoryPicker !== null && e('button', {
+              type: 'button',
+              className: 'soul-bindings-pick',
+              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))),
+            e('button', {
+              type: 'button',
+              className: 'soul-bindings-bind',
+              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('button', {
+                                type: 'button',
+                                className: pendingUnbind === dir
+                                  ? 'soul-bindings-action soul-bindings-action-armed'
+                                  : 'soul-bindings-action',
+                                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('button', {
+            type: 'button',
+            className: 'soul-bindings-action',
+            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) {
       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 +2672,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('')
       // 「存为预设」的命名弹层是否打开。
       //
@@ -1539,7 +2827,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 定义之后：
@@ -1730,7 +3018,7 @@ window.__ModuleLoader__.load({
         return () => clearTimeout(timer)
       }, [pendingDelete])
 
-      // —— 卡背（详情面）用到的三个辅助 ——
+      // —— 卡背（详情面）用到的辅助 ——
       //
       // 列出「一个人设完整的六个维度」。顺序与设置页表单一致（风格 → 标题列表 →
       // 表情 → 表格 → 回复长度 → 语言），这样卡背读起来与设置页对得上。
@@ -1818,6 +3106,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) })
@@ -2019,6 +3321,9 @@ window.__ModuleLoader__.load({
             open: openSection === 'personas',
             onToggle: toggleSection('personas')
           },
+            // 保留条数下拉不在这里 —— 0.8.1 起它跟着变更记录走，落在**插件详情页**
+            // 的变更记录区块里（容量参数与被它约束的内容放在一起才说得通）。
+            // 设置页这一组只负责预设本身与那句去向指引。
             e('div', { className: 'soul-field' },
               // 加载失败优先于「加载中」：否则失败时界面永远停在加载态，与「还没有预设」无从区分
               personasError
@@ -2292,9 +3597,47 @@ window.__ModuleLoader__.load({
                 onClick: () => { setPersonaName(''); 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 +3735,11 @@ window.__ModuleLoader__.load({
           )
         ),
 
+        // —— 变更记录：设置页不再留独立指引行 ——
+        // 指引并入「人设预设」展开区的说明块（与 personas.hint 合并展示）：
+        // 独立一行在个性化区块里突兀，而折叠标题旁挂 hover 又说不到点上
+        //（它解释的是展开后的东西）。这里不再渲染任何 history 状态，渲染成本为零。
+
         e(SoulAccordion, {
           id: 'soul-prompt',
           title: t(promptIsDraft ? 'prompt.titleDraft' : 'prompt.title'),
@@ -2651,6 +3999,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
@@ -2856,6 +4219,24 @@ 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))
+
       // 初始配置的拉取已并入上面的全局轮询 —— 它的 refresh() 在注册时立即执行一次
       // （含 loadConfig + loadPersonas），这里再调一次就是同一次装配发两个相同请求。
     }