dsh-soul 0.7.0 → 0.7.2

package/client/index.mjs

@@ -3,12 +3,12 @@
 // 在设置页面添加「个性化」栏目：
 //   - 启用/禁用个性化设置
 //   - 「关于你」（昵称/职业/介绍）、回复风格和语调、特质、输出语言、自定义指令
-//   - 人设预设：6 个内置人设（随插件提供、不可删除，行尾标「内置」）+ 保存当前为预设、一键使用（★ 标记当前匹配项）、删除
+//   - 人设预设：7 个内置人设（随插件提供、不可删除，行尾标「内置」）+ 保存当前为预设、一键使用（★ 标记当前匹配项）、删除
 //   - Agent 工具：set_persona 确认模式开关
 //   - 输入框光轨：Agent 回复中时输入框边框的流光动效（颜色 / 速度 / 粗细 + 实时示例）
 //   - dirty 检测（无改动禁用保存）、统一 toast 提示
 //   - 提示词预览（只读）：无未保存编辑时显示「当前生效提示词」，有编辑时改为编译草稿
-//     —— 展示保存后真正会注入的内容，并在保存/重置/应用预设后自动刷新
+//     —— 展示保存后真正会生效的内容，并在保存/重置/应用预设后自动刷新
 //
 // 光轨另注册到 conversation.input.overlay 槽位（输入框卡片内部），
 // 运行时按会话 running 状态在卡片上挂载/隐藏 SVG 环，见 SoulTrail。
@@ -48,7 +48,7 @@ window.__ModuleLoader__.load({
     // -------------------------------------------------------------------------
 
     const NS = 'soul'
-    const VERSION = '0.7.0'
+    const VERSION = '0.7.2'
     const INITIAL = {
       enabled: true,
       nickname: '',
@@ -71,11 +71,10 @@ window.__ModuleLoader__.load({
       // 人设预设库与当前匹配项（GET /api/soul/personas 带回）
       personas: null,
       activePersona: null,
-      loading: false,
+      // 预设列表请求失败的原因（成功时清空）。用于把「加载中」与「加载失败」区分开
+      personasError: null,
       saving: false,
-      error: null,
-      // 最近一次保存实际变化的字段名数组（来自写路径的 changed）
-      lastChanged: null
+      error: null
     }
 
     // 第三方插件不能 require('@deepseek-ai/dsh-client-runtime/client')——
@@ -91,13 +90,43 @@ window.__ModuleLoader__.load({
         update: (mutator) => {
           const next = { ...state }
           mutator(next)
-          state = next
-          notify()
+          // 值全等时不换引用、也不通知：设置页每 2s 轮询一次宿主配置，绝大多数轮次
+          // 什么都没变，此前却每次都让订阅方（设置页 / 快捷开关 / 光轨）白重渲染一次。
+          // 取两侧键集的并集比较：只遍历 next 会漏掉「mutator 删了某个键」的情形，
+          // 那会变成静默不更新 —— 比多通知一次严重得多。
+          for (const key of new Set([...Object.keys(state), ...Object.keys(next)])) {
+            if (!Object.is(next[key], state[key])) {
+              state = next
+              notify()
+              return
+            }
+          }
         },
         set: (next) => { state = next; notify() },
       }
     }
 
+    // 一层浅比较：用于判断服务端新解析出的对象是否与已存的等价。
+    // 预设条目本身是扁平对象（人格字段 + updatedAt / builtin），所以一层足够。
+    const shallowEqual = (a, b) => {
+      if (a === b) return true
+      if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return false
+      const ka = Object.keys(a)
+      const kb = Object.keys(b)
+      if (ka.length !== kb.length) return false
+      return ka.every((key) => Object.is(a[key], b[key]))
+    }
+
+    // 预设库是「库 → 条目」两层结构，需要逐条目比。
+    const samePersonas = (a, b) => {
+      if (a === b) return true
+      if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return false
+      const ka = Object.keys(a)
+      const kb = Object.keys(b)
+      if (ka.length !== kb.length) return false
+      return ka.every((key) => shallowEqual(a[key], b[key]))
+    }
+
     function hostBase() {
       const origin = globalThis.location?.origin
       return origin !== void 0 && origin !== 'null' ? origin : 'http://dsh.internal'
@@ -338,6 +367,17 @@ window.__ModuleLoader__.load({
         this.fetcher = fetcher
         this.store = createSnapshotStore(INITIAL)
         this.disposed = false
+        // 外部轮询的暂停标记（由设置页在「有未保存编辑」时置位）。
+        //
+        // 为什么放在 controller 上而不是组件 state：轮询已从设置页组件**上移到
+        // apply()**（见那里的注释），装配层读不到组件的 dirty/saving。而「编辑中
+        // 不覆盖用户输入」这条语义仍必须保留，所以在共享的 controller 上开一个口。
+        this.paused = false
+      }
+
+      // 是否允许外部轮询写入 store
+      canRefresh() {
+        return !this.disposed && !this.paused
       }
 
       // 把服务端返回的完整配置映射进 store
@@ -362,18 +402,25 @@ window.__ModuleLoader__.load({
 
       async loadConfig() {
         if (this.disposed) return
-        this.store.update(s => { s.loading = true; s.error = null })
+        // 开始读取就清掉上一次的错误；此前还写了一个 s.loading，但全客户端零处读取
+        // （设置页首帧直接显示 INITIAL 默认值），属于只写不读的死状态，已删。
+        this.store.update(s => { s.error = null })
 
         try {
           const payload = await this.postJSON('/api/soul/config', null, { method: 'GET' })
           this.store.update(s => {
             this.applyConfig(s, payload.config)
-            s.loading = false
+            // 两类问题分开上报、合到同一条提示里：
+            //   configError     —— 磁盘配置读不出来（回退默认值，写入被拒）
+            //   deliveryWarning —— 配置送不到活动会话（agents 服务不可用等）
+            // 两者表面症状都是「改了人设不生效」，所以都要让用户看得见。
+            s.error = typeof payload.configError === 'string'
+              ? payload.configError
+              : (typeof payload.deliveryWarning === 'string' ? payload.deliveryWarning : null)
           })
         } catch (error) {
           if (this.disposed) return
           this.store.update(s => {
-            s.loading = false
             s.error = messageOf(error)
           })
         }
@@ -387,7 +434,8 @@ window.__ModuleLoader__.load({
           const payload = await this.postJSON('/api/soul/config', config)
           this.store.update(s => {
             this.applyConfig(s, payload.config)
-            s.lastChanged = Array.isArray(payload.changed) ? payload.changed : []
+            // 保存成功也可能带着送达警告（配置写下了但送不到会话）
+            s.error = typeof payload.deliveryWarning === 'string' ? payload.deliveryWarning : null
             s.saving = false
           })
           return payload
@@ -408,7 +456,7 @@ window.__ModuleLoader__.load({
           const payload = await this.postJSON('/api/soul/config/reset')
           this.store.update(s => {
             this.applyConfig(s, payload.config)
-            s.lastChanged = Array.isArray(payload.changed) ? payload.changed : []
+            s.error = typeof payload.deliveryWarning === 'string' ? payload.deliveryWarning : null
             s.saving = false
           })
           return payload
@@ -426,6 +474,32 @@ window.__ModuleLoader__.load({
         return await this.postJSON('/api/soul/personas', null, { method: 'GET' })
       }
 
+      // 拉取预设列表并写入 store。
+      //
+      // 从 SoulSettings 组件**下沉**到这里：全局轮询（apply 层）与设置页都要用它，
+      // 逻辑留在组件里会导致装配层无法调用、只能重写一遍 ⇒ 两套写 store 的代码。
+      async loadPersonas() {
+        if (this.disposed) return
+        try {
+          const payload = await this.fetchPersonas()
+          this.store.update((s) => {
+            // 内容相同就保留旧引用：每 2s 轮询都会重新解析出**新对象**，若直接赋值，
+            // store 的浅比较永远判为「变了」⇒ 去重失效，整页仍每 2s 白重渲染。
+            s.personas = samePersonas(s.personas, payload.personas) ? s.personas : payload.personas
+            s.activePersona = payload.activeName
+            // 拉取成功：清掉上一次的失败痕迹（否则失败后即便恢复，提示会一直挂着）
+            s.personasError = null
+          })
+        } catch (err) {
+          // 预设列表加载失败不打断主配置界面 —— 但必须**留下痕迹**：
+          // 否则 personas 永远是 null，摘要与面板一直显示「加载中...」，
+          // 与「真的还没有预设」无从区分，也没有任何失败提示。
+          this.store.update((s) => {
+            s.personasError = messageOf(err)
+          })
+        }
+      }
+
       async savePersona(name) {
         return await this.postJSON('/api/soul/personas/save', { name })
       }
@@ -435,7 +509,9 @@ window.__ModuleLoader__.load({
         if (!this.disposed) {
           this.store.update(s => {
             this.applyConfig(s, payload.config)
-            s.lastChanged = Array.isArray(payload.changed) ? payload.changed : []
+            // 清掉上一轮的失败提示：该端点不返回 deliveryWarning，此前一旦上一轮
+            // 保存失败过，切预设成功后红色错误条会一直挂着。
+            s.error = null
           })
         }
         return payload
@@ -468,7 +544,7 @@ window.__ModuleLoader__.load({
       }
 
       // 预览「未保存的编辑」编译出的提示词：POST 草稿字段，服务端以已保存配置为底
-      // 覆盖后编译。不落盘、不注入 —— 返回的 invalid 列出未通过校验、因而未计入
+      // 覆盖后编译。不落盘、不影响生效提示词 —— 返回的 invalid 列出未通过校验、因而未计入
       // 预览的字段名，供界面如实提示，避免用户以为改动已生效。
       async previewPrompt(draft) {
         const payload = await this.postJSON('/api/soul/prompt/preview', draft)
@@ -485,74 +561,272 @@ window.__ModuleLoader__.load({
     // -------------------------------------------------------------------------
 
     const css = [
-      '.soul-section{margin:24px 0;padding:20px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-1)}',
-      '.soul-section h3{margin:0 0 16px 0;font-size:16px;font-weight:600;color:var(--dsw-alias-label-primary)}',
-      '.soul-title-row{display:flex;align-items:center;justify-content:space-between;gap:12px;min-width:0}',
-      '.soul-version{flex:0 0 auto;color:var(--dsw-alias-label-tertiary);font-size:11px;font-weight:400;line-height:1.4;white-space:nowrap}',
-      '.soul-field{margin-bottom:16px;width:100%}',
-      '.soul-field label{display:block;margin-bottom:6px;font-size:13px;font-weight:500;color:var(--dsw-alias-label-secondary)}',
-      '.soul-field select,.soul-field textarea,.soul-field input[type=text]{width:100%;padding:8px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);font-size:13px;line-height:1.5;box-sizing:border-box}',
+      // —— 与宿主设置页对齐的栏目容器 ——
+      // 宿主其余栏目（models / plugins / plugin-inventory）都不用外框：内容直接落在
+      // 设置页 options 容器自带的 `padding:0 24px 24px` 里，靠 `max-width` 限制行长，
+      // 分组则用「卡片」表达（.5px 边框 + settings-card-* + radius-xl）。
+      // 我们此前是 `.soul-section{margin:24px 0;padding:20px;border:1px;radius:8px}`
+      // —— 等于在宿主内边距里又套了一层盒子，是观感不统一最直接的原因，故整层去掉。
+      '.soul-section{display:flex;flex-direction:column;gap:12px;width:100%;max-width:760px;color:var(--dsw-alias-label-primary)}',
+      // 标题：与宿主栏目标题同规格（16px / 500 / lh24，不是 600）
+      '.soul-section h3{margin:0;font-size:16px;font-weight:500;line-height:24px;color:var(--dsw-alias-label-primary)}',
+      '.soul-title-row{display:flex;align-items:baseline;justify-content:space-between;gap:12px;min-width:0}',
+      '.soul-version{flex:0 0 auto;color:var(--dsw-alias-label-tertiary);font-size:12px;font-weight:400;line-height:18px;white-space:nowrap}',
+      // 字段：宿主用 12px / 500 / lh18 的字段标签 + 8px 间距
+      '.soul-field{margin-bottom:14px;width:100%}',
+      '.soul-field label{display:block;margin-bottom:8px;font-size:12px;font-weight:500;line-height:18px;color:var(--dsw-alias-label-secondary)}',
+      // 与上面的 label 同形，但用于「没有对应控件」的分组标题（如光轨示例预览）：
+      // 那种位置写 <label> 会是一个指向空的标签，语义错误
+      '.soul-field-label{display:block;margin-bottom:8px;font-size:12px;font-weight:500;line-height:18px;color:var(--dsw-alias-label-secondary)}',
+      // 控件：边框换宿主卡片描边色、圆角用 sm(8px)，与宿主输入控件一致
+      '.soul-field select,.soul-field textarea,.soul-field input[type=text]{width:100%;padding:8px 12px;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:13px;line-height:20px;box-sizing:border-box}',
       '.soul-field select option{color:var(--dsw-alias-label-primary)}',
       '.soul-section{color-scheme:light}',
       'body[data-ds-dark-theme] .soul-section{color-scheme:dark}',
       '.soul-field select{color-scheme:light}',
       'body[data-ds-dark-theme] .soul-field select{color-scheme:dark}',
-      '.soul-field textarea{min-height:100px;resize:vertical}',
-      '.soul-field textarea.soul-textarea-sm{min-height:60px}',
-      '.soul-group-title{margin:20px 0 12px 0;padding-bottom:8px;border-bottom:1px solid var(--dsw-alias-border-l2);font-size:13px;font-weight:600;color:var(--dsw-alias-label-secondary)}',
-      '.soul-accordion{margin:12px 0;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;overflow:visible;background:var(--dsw-alias-bg-layer-1)}',
+      '.soul-field textarea{min-height:120px;resize:vertical}',
+      '.soul-field textarea.soul-textarea-sm{min-height:72px}',
+      // 组标题：宿主用 15px/600 的小标题，这里对齐并去掉下边框（宿主分组靠卡片分隔，不靠横线）
+      '.soul-group-title{margin:4px 0 0 0;font-size:15px;font-weight:600;line-height:22px;color:var(--dsw-alias-label-primary)}',
+      // 折叠分组＝宿主卡片：.5px 描边 + card-fill + radius-xl + overflow hidden
+      // 刻意不用 overflow:hidden 裁子元素圆角：那会把「向上弹出」的 .soul-hint-tip
+      // 在跨出分组上边界时切掉顶部（实测复现：Agent 工具分组的提示是该分组第一个
+      // 元素，上方只有 14px 内边距，而提示高约 60px，必然越界被裁）。
+      // 改为给触发器补顶圆角，让 hover 背景自己贴合 —— 视觉等价且不裁剪。
+      '.soul-accordion{margin:0;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-xl);background:var(--dsw-alias-settings-card-fill)}',
       '.soul-accordion-open{position:relative;z-index:20}',
-      // 展开时标题行下沿改直角：与下方内容区形成一条清晰的水平交界，
-      // 避免"标题与内容同为一片底色、分不清哪块是标题"
-      '.soul-accordion-open .soul-accordion-trigger{border-radius:5px 5px 0 0}',
-      '.soul-accordion-trigger{display:flex;align-items:center;width:100%;min-height:44px;gap:10px;padding:10px 12px;border:0;border-radius:5px;background:var(--dsw-alias-interactive-bg-active,rgba(127,127,127,0.12));color:var(--dsw-alias-label-primary);font:inherit;text-align:left;cursor:pointer;transition:background-color .15s ease}',
-      '.soul-accordion-trigger:hover{background:var(--dsw-alias-interactive-bg-hover-accent,rgba(127,127,127,0.2))}',
-      '.soul-accordion-title{flex:0 0 auto;font-size:13px;font-weight:600}',
-      '.soul-accordion-summary{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-tertiary);font-size:12px;font-weight:400}',
+      // 顶圆角补偿：容器不再裁剪，触发器的 hover 背景需自己贴合外层圆角
+      // （半径为外层圆角减去 0.5px 边框）。展开时底边保持直角，与 body 的分隔线相接。
+      '.soul-accordion-trigger{display:flex;align-items:center;width:100%;min-height:44px;gap:10px;padding:10px 14px;border:0;border-radius:calc(var(--dsw-radius-xl) - .5px) calc(var(--dsw-radius-xl) - .5px) 0 0;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;text-align:left;cursor:pointer;transition:background-color .15s ease}',
+      '.soul-accordion-trigger:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.soul-accordion-title{flex:0 0 auto;font-size:14px;font-weight:500;line-height:22px}',
+      '.soul-accordion-summary{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-tertiary);font-size:12px;font-weight:400;line-height:18px}',
       '.soul-accordion-icon{flex:0 0 18px;color:var(--dsw-alias-label-secondary);font-size:18px;line-height:1;text-align:center}',
-      '.soul-accordion-body{padding:12px;border-top:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1)}',
+      // 收起态只有触发器一个子元素 ⇒ 四角都要圆（展开态由上面的顶圆角规则负责）
+      '.soul-accordion:not(.soul-accordion-open) .soul-accordion-trigger{border-radius:calc(var(--dsw-radius-xl) - .5px)}',
+      '.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:16px}',
-      '.soul-toggle label{margin:0;font-size:13px;color:var(--dsw-alias-label-primary)}',
-      '.soul-buttons{display:flex;gap:8px;margin-top:16px}',
-      '.soul-quick-toggle{position:relative;isolation:isolate;display:inline-flex;align-items:center;gap:6px;min-height:28px;overflow:hidden;padding:4px 8px;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;background:transparent;color:var(--dsw-alias-label-secondary);font:inherit;font-size:12px;line-height:1;cursor:pointer;white-space:nowrap}',
+      '.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}',
       '.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:#ef4444;color:#ef4444;box-shadow:0 0 0 2px rgba(239,68,68,.18)}',
-      '.soul-quick-toggle[data-enabled="false"]:hover{border-color:#22c55e;color:#22c55e;box-shadow:0 0 0 2px rgba(34,197,94,.18)}',
-      '.soul-quick-toggle[data-enabled="true"]:hover::before{background:rgba(239,68,68,.24);animation:soul-toggle-red-sweep .55s ease-out both}',
-      '.soul-quick-toggle[data-enabled="false"]:hover::before{background:rgba(34,197,94,.24);animation:soul-toggle-green-sweep .55s ease-out both}',
+      '.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)}',
+      '.soul-quick-toggle[data-enabled="false"]:hover{border-color:var(--dsw-alias-state-success-primary);color:var(--dsw-alias-state-success-primary);box-shadow:0 0 0 2px color-mix(in srgb,var(--dsw-alias-state-success-primary) 18%,transparent)}',
+      '.soul-quick-toggle[data-enabled="true"]:hover::before{background:color-mix(in srgb,var(--dsw-alias-state-error-primary) 24%,transparent);animation:soul-toggle-red-sweep .55s ease-out both}',
+      '.soul-quick-toggle[data-enabled="false"]:hover::before{background:color-mix(in srgb,var(--dsw-alias-state-success-primary) 24%,transparent);animation:soul-toggle-green-sweep .55s ease-out both}',
       '.soul-quick-toggle::before{content:"";position:absolute;inset:0;z-index:-1;pointer-events:none;transform:translateX(100%)}',
       '.soul-quick-toggle > *{position:relative;z-index:1}',
       '.soul-quick-toggle-dot{width:7px;height:7px;flex:0 0 7px;border-radius:50%;background:var(--dsw-alias-label-tertiary)}',
-      '.soul-quick-toggle[data-enabled="true"] .soul-quick-toggle-dot{background:var(--dsw-static-green-500,#22c55e);animation:soul-status-pulse 1.8s ease-in-out infinite}',
+      '.soul-quick-toggle[data-enabled="true"] .soul-quick-toggle-dot{background:var(--dsw-alias-state-success-primary);animation:soul-status-pulse 1.8s ease-in-out infinite}',
+      // 保存失败：小圆点转红并停止脉冲（按钮文案不变，故必须靠颜色 + title/aria-label 反馈）
+      // 注意：--dsw-alias-label-error **在宿主主题里不存在**（实测 var() 回退成继承色＝黑），
+      // 宿主表达错误色统一用 --dsw-alias-state-error-primary，这里一并纠正。
+      '.soul-quick-toggle[data-failed="true"]{border-color:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-state-error-primary)}',
+      '.soul-quick-toggle[data-failed="true"] .soul-quick-toggle-dot{background:var(--dsw-alias-state-error-primary);animation:none}',
       '.soul-quick-toggle:disabled{cursor:wait;opacity:.6}',
       '@keyframes soul-toggle-red-sweep{from{transform:translateX(100%)}to{transform:translateX(-100%)}}',
       '@keyframes soul-toggle-green-sweep{from{transform:translateX(100%)}to{transform:translateX(-100%)}}',
-      '@keyframes soul-status-pulse{0%,100%{box-shadow:0 0 0 0 color-mix(in srgb,var(--dsw-static-green-500,#22c55e) 35%,transparent);opacity:.75}50%{box-shadow:0 0 0 4px color-mix(in srgb,var(--dsw-static-green-500,#22c55e) 0%,transparent);opacity:1}}',
+      '@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}}',
-      '.soul-error{margin-top:8px;padding:8px 12px;background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-label-error);border-radius:6px;color:var(--dsw-alias-label-error);font-size:12px;width:100%;box-sizing:border-box}',
+      // 快捷开关里追加的人设名（B）：同样单行省略，避免把底栏撑宽
+      '.soul-quick-toggle-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:9em;opacity:.85}',
+      // 错误提示：颜色改用宿主真实存在的 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}',
       '.soul-hint:hover{color:var(--dsw-alias-label-primary)}',
-      '.soul-hint-tip{position:absolute;bottom:calc(100% + 8px);left:0;padding:8px 10px;background:#ffffff;border:1px solid rgba(0,0,0,0.1);border-radius:6px;font-size:12px;font-weight:400;line-height:1.5;color:rgba(0,0,0,0.85);white-space:normal;width:max-content;max-width:260px;text-align:left;opacity:0;visibility:hidden;transition:opacity .15s ease;pointer-events:none;z-index:9999;box-shadow:0 4px 12px rgba(0,0,0,0.15)}',
+      '.soul-hint-tip{position:absolute;bottom:calc(100% + 8px);left:0;padding:8px 10px;background:var(--dsw-alias-bg-module-platform);border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);font-size:12px;font-weight:400;line-height:1.5;color:var(--dsw-alias-label-primary);white-space:normal;width:max-content;max-width:260px;text-align:left;opacity:0;visibility:hidden;transition:opacity .15s ease;pointer-events:none;z-index:9999;box-shadow:var(--dsw-shadow-lv3,0 4px 12px rgba(0,0,0,0.15))}',
       '.soul-hint:hover .soul-hint-tip{opacity:1;visibility:visible}',
-      '.soul-status{margin-top:8px;font-size:12px;color:var(--dsw-alias-label-secondary)}',
-      '.soul-dirty{color:#d46b08}',
-      '.soul-persona-row{display:flex;align-items:center;gap:8px;padding:6px 0;border-bottom:1px dashed var(--dsw-alias-border-l2);font-size:12px}',
-      '.soul-persona-name{color:var(--dsw-alias-label-primary);font-weight:500;white-space:nowrap}',
-      '.soul-persona-meta{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-secondary)}',
-      '.soul-persona-actions{display:flex;gap:10px;white-space:nowrap;align-items:center}',
-      '.soul-persona-badge{font-size:11px;line-height:16px;padding:0 6px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;color:var(--dsw-alias-label-secondary);white-space:nowrap}',
-      '.soul-persona-save{display:flex;gap:8px}',
-      '.soul-persona-save input[type=text]{flex:1}',
-      '.soul-prompt-link{background:none;border:none;padding:0;font-size:12px;color:var(--dsw-alias-label-secondary);cursor:pointer;text-decoration:underline}',
-      '.soul-prompt-link:hover{color:var(--dsw-alias-label-primary)}',
-      '.soul-persona-danger{color:var(--dsw-alias-label-error)}',
-      '.soul-prompt-pre{margin:8px 0 0 0;padding:12px;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.6;white-space:pre-wrap;word-break:break-word;max-height:240px;overflow:auto;font-family:Consolas,Menlo,monospace;text-align:left;width:100%;box-sizing:border-box}',
-      '.soul-toast{position:fixed;top:50%;left:50%;transform:translate(-50%,-50%);padding:8px 16px;border-radius:6px;font-size:13px;font-weight:500;z-index:10000;box-shadow:0 2px 8px rgba(0,0,0,0.15);pointer-events:none;text-align:center;min-width:auto;white-space:nowrap}',
-      '.soul-toast-success{background:#f6ffed;border:1px solid #b7eb8f;color:#52c41a}',
-      '.soul-toast-error{background:#fff1f0;border:1px solid #ffa39e;color:#f5222d}',
-      '@keyframes fadeInOut{0%{opacity:0;transform:translate(-50%,-50%) scale(0.9)}15%{opacity:1;transform:translate(-50%,-50%) scale(1)}85%{opacity:1;transform:translate(-50%,-50%) scale(1)}100%{opacity:0;transform:translate(-50%,-50%) scale(0.9)}}',
+      // 键盘聚焦同样要能拿到说明：只有 :hover 的话，键盘 / 读屏用户永远看不到提示
+      '.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-dirty{color:var(--dsw-alias-state-warn-primary)}',
+      // —— 人设预设：竖版卡牌 + 堆叠轮播 ——
+      // 方案 B：插画是卡面主视觉（方形满铺），名称与摘要压在图上由渐变承接，
+      // 效果与按钮在下方的白色信息区。卡牌竖版后「一次只见一张」的代价更大，
+      // 因此保留位置指示、圆点与左右翻页（见 .soul-persona-nav）。
+      '.soul-persona-carousel{position:relative;display:flex;flex-direction:column;gap:12px}',
+      // 堆叠容器：卡牌绝对定位其中，容器高度固定 ⇒ 切换时不跳动。
+      // 竖版卡牌高度 = 插画 260（等于卡宽的正方形）+ 信息区约 92 + 边框 ⇒ 取 372。
+      // 左右留白不需要 padding：卡片以 margin:auto 居中，±92px 的两张展开后总宽约 430px，
+      // 远小于容器宽度（设置页 max-width 760px），不会溢出。
+      '.soul-persona-stack{position:relative;min-height:372px}',
+      // 卡牌：固定宽度居中（left/right:0 + margin auto），靠 transform 做叠层位移与缩放。
+      // top/bottom:0 让三张卡等高 —— 内容长短不同的卡片高度一致，堆叠才整齐。
+      //
+      // ⚠️ 卡片**不能**有 overflow:hidden：CSS 规范规定 overflow != visible 会强制
+      //    transform-style: flat，3D 翻转会被压平。裁切职责已下沉到 .soul-persona-face
+      //    （它带 overflow:hidden + border-radius:inherit，效果等价）。
+      '.soul-persona-card{position:absolute;top:0;bottom:0;left:0;right:0;width:260px;margin:0 auto;display:flex;flex-direction:column;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;transform-origin:center top;will-change:transform;perspective:1000px}',
+      // —— 卡牌的两面（正面 = 卡面，背面 = 详情）：真 3D 翻转 ——
+      //
+      // 三层职责分离（这是能做真 3D 而不伤叠层几何的关键）：
+      //   .soul-persona-card      叠层位置（translateX/Y/scale，内联）
+      //   .soul-persona-flipper   翻到哪一面（rotateY 0 ↔ 180）
+      //   .soul-persona-face-*    两个面各自的内容
+      // 若把 rotateY 写进卡片，就要和叠层偏移合成同一个 transform 字符串 ⇒
+      // 偏移几何变脆。
+      //
+      // ⚠️ perspective 已并入上面的 .soul-persona-card 规则（单条规则，便于断言核对）：
+      //    它必须挂在**翻转元素的父级**（卡片）上才生效。
+      '.soul-persona-card{perspective:1000px}',
+      '.soul-persona-flipper{position:absolute;inset:0;transform-style:preserve-3d;transition:transform .5s cubic-bezier(.2,.7,.3,1);border-radius:inherit}',
+      '.soul-persona-card[data-flipped="true"] .soul-persona-flipper{transform:rotateY(180deg)}',
+      // 两个面：各自裁圆角 + 隐藏背面，构成标准 3D 翻转
+      '.soul-persona-face{position:absolute;inset:0;display:flex;flex-direction:column;overflow:hidden;border-radius:inherit;backface-visibility:hidden;-webkit-backface-visibility:hidden;transition:opacity .18s ease}',
+      // 整面可点（任意处点击翻到卡背）：cursor 提示可点性
+      '.soul-persona-face-front{opacity:1}',
+      // 当前卡整面可点翻背（cursor 提示）；叠层侧边卡的点击是翻页，不提示翻面
+      '.soul-persona-card[data-current="true"]:not([data-flipped="true"]) .soul-persona-face-front{cursor:pointer}',
+      // 背面预先转到 180°，随 flipper 一起转回正面
+      // 卡背整面可点返回（与正面「整面点击翻到背面」对称）：cursor 提示可点。
+      // 全文块单独覆盖为 text —— 那里是可选中的文字，光标形态要与之相符。
+      '.soul-persona-face-back{gap:6px;padding:10px;box-sizing:border-box;transform:rotateY(180deg);opacity:1;cursor:pointer}',
+      // 未翻面时背面整层不可点、也不被读屏念到（它虽被 backface 隐藏，但仍在树里）
+      '.soul-persona-card:not([data-flipped="true"]) .soul-persona-face-back{pointer-events:none}',
+      // 尊重「减少动态效果」：不做 3D 位移，直接切换
+      '@media (prefers-reduced-motion:reduce){.soul-persona-flipper{transition:none}}',
+      // 背面头部：名称 + 内置徽标。
+      // 名称用 flex:0 1 auto（**不是** flex:1 1 auto）：后者会把它撑满整行，
+      // 于是徽标与名称**重叠在同一位置**（实测：名称 [44,272]、徽标 [44,77]，
+      // 视觉上徽标盖住了名称开头，看起来像被截成了「协作者」）。
+      // 现在名称按内容取宽、仅在过长时收缩（min-width:0 + ellipsis 兜底），
+      // 徽标 flex:none 紧随其后。
+      '.soul-persona-back-head{display:flex;align-items:center;gap:6px;flex:none}',
+      '.soul-persona-back-name{flex:0 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-primary);font-size:13px;font-weight:600;line-height:18px}',
+      // 卡背里的徽标必须**重置定位**：.soul-persona-badge 为压在插画上而设了
+      // position:absolute（见该规则），在卡背的 flex 行里它脱离流 ⇒ 与名称重叠
+      // （实测：名称 [44,75]、徽标 [44,77]，视觉上徽标盖住名称开头）。
+      // 这里改回 static 让它正常参与 flex 布局。
+      '.soul-persona-back-head .soul-persona-badge{position:static;flex:none}',
+      // 维度列表：label 左、值右，两列对齐
+      '.soul-persona-dims{display:flex;flex-direction:column;gap:2px;flex:none}',
+      '.soul-persona-dim{display:flex;align-items:baseline;justify-content:space-between;gap:8px;font-size:11px;line-height:16px}',
+      '.soul-persona-dim span{flex:none;color:var(--dsw-alias-label-tertiary)}',
+      '.soul-persona-dim b{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-secondary);font-weight:500}',
+      '.soul-persona-back-label{flex:none;margin-top:2px;color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px}',
+      // 全文：**不截断**（正面效果栏才截断）。
+      // 滚动放在**这一块自己**身上（不是 face），这样「返回」按钮始终贴在卡底可见 ——
+      // 实测把 overflow-y 放 face 上时，长文本会把按钮一起推出视野并被文字压住。
+      // 需要的背景：卡片高度固定 372px，而实测 339 字占 272px（17 行 × 16px），
+      // 加头部/维度/按钮后已无余量，稍长就必然要滚。
+      '.soul-persona-fulltext{flex:1 1 auto;min-height:0;overflow-y:auto;overscroll-behavior:contain;cursor:text;color:var(--dsw-alias-label-secondary);font-size:11px;line-height:16px;white-space:pre-wrap;word-break:break-word}',
+      // 背面的「返回」：贴底按钮，做成描边式（不抢视觉，但必须好点）。
+      //
+      // ⚠️ 选择器必须带 .soul-persona-face-back 前缀（提高权重），不能只写
+      // `.soul-persona-back-btn`：基类 `.soul-persona-action` 有 `flex:1 1 auto`，
+      // 而两者都是单类选择器（权重相同）⇒ **后声明者胜**。本规则在源码里排在
+      // 基类之前，于是基类的 flex:1 覆盖了这里的 flex:none —— 后果是自定义预设
+      // 指令较短时，剩余空间把「返回」按钮**拉伸到 98px 高**（实测：短文本 98px
+      // vs 长文本 21px）。加前缀后权重更高，与声明顺序无关。
+      // 卡背底部按钮行：返回（弹性占满）+ 删除（自建卡才有，定宽）。
+      // .soul-persona-back-btn 的 margin-top:auto 移到本行容器上 —— 按钮行整体贴底。
+      '.soul-persona-back-actions{display:flex;align-items:center;gap:8px;flex:none;margin-top:auto}',
+      '.soul-persona-back-btn{flex:1 1 auto}',
+      // 删除在卡背是「次要管理操作」：定宽描边（armed 态复用正面同款变实心样式）
+      '.soul-persona-back-del{flex:0 0 64px}',
+      '.soul-persona-details{flex:0 0 auto;padding:0 10px;background:transparent;color:var(--dsw-alias-label-secondary);box-shadow:inset 0 0 0 .5px var(--dsw-alias-settings-card-stroke);font-size:12px;font-weight:500}',
+      '.soul-persona-details:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover);filter:none}',
+      // 插画区：正方形主视觉。非内置预设没有配套插画，用主题色渐变兜底
+      // 所有卡片都出图（自建预设由宿主返回专用默认贴图）；图未就绪时露出渐变底。
+      '.soul-persona-art{position:relative;width:100%;aspect-ratio:1/1;flex:none;overflow:hidden;background:linear-gradient(150deg,color-mix(in srgb,var(--dsw-alias-brand-primary) 22%,var(--dsw-alias-bg-module-platform)),var(--dsw-alias-bg-module-platform))}',
+      '.soul-persona-art-img{position:absolute;inset:0;width:100%;height:100%;object-fit:cover;display:block;user-select:none}',
+      // 底部渐变：让压在图上的名称/摘要有足够对比度（浅色插画上白字会糊）
+      '.soul-persona-art-veil{position:absolute;inset:auto 0 0 0;height:62%;background:linear-gradient(180deg,rgba(10,14,35,0),rgba(10,14,35,.62) 55%,rgba(10,14,35,.86));pointer-events:none}',
+      // 名称 + 摘要压在图底部
+      '.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-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)}',
+      // 位置指示：图上右上角的胶囊
+      '.soul-persona-card-pos{position:absolute;top:10px;right:10px;padding:2px 7px;border-radius:999px;background:rgba(10,14,35,.5);color:var(--dsw-static-neutral-bluish-00,#fff);font-size:10px;line-height:14px;font-variant-numeric:tabular-nums;backdrop-filter:blur(8px)}',
+      // 信息区：效果说明 + 操作按钮
+      '.soul-persona-body{display:flex;flex-direction:column;gap:8px;flex:1;min-height:0;padding:10px 12px 12px}',
+      '.soul-persona-eff{color:var(--dsw-alias-label-secondary);font-size:11px;line-height:16px;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}',
+      // 非当前卡片是「背景层」：可点击切过去，但不可抢注意力
+      '.soul-persona-card[data-current="false"]{cursor:pointer}',
+      // 「翻开」动画：切张时当前卡片轻微放大，给出卡牌被拨动的实感
+      '.soul-persona-card[data-current="true"]{animation:soul-card-in .3s cubic-bezier(.22,.61,.36,1) both}',
+      '@keyframes soul-card-in{from{opacity:.72;transform:translateX(0) scale(.96)}to{opacity:1;transform:translateX(0) scale(1)}}',
+      // 位置指示与翻页：竖版卡牌一次只见一张，这三处是对该损失的补偿
+      '.soul-persona-nav{display:flex;align-items:center;justify-content:center;gap:12px}',
+      '.soul-persona-navbtn{box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;width:32px;height:32px;padding:0;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-settings-card-fill);color:var(--dsw-alias-label-secondary);font:inherit;font-size:16px;line-height:1;cursor:pointer;transition:background-color .15s ease,color .15s ease}',
+      '.soul-persona-navbtn:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}',
+      '.soul-persona-navbtn:disabled{cursor:default;opacity:.3}',
+      '.soul-persona-navbtn:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
+      '.soul-persona-dots{display:flex;align-items:center;gap:6px;min-width:0;flex-wrap:wrap;justify-content:center}',
+      '.soul-persona-dot{width:6px;height:6px;padding:0;border:0;border-radius:50%;background:var(--dsw-alias-label-tertiary);opacity:.35;cursor:pointer;transition:opacity .15s ease,transform .15s ease}',
+      '.soul-persona-dot[data-active="true"]{opacity:1;transform:scale(1.3);background:var(--dsw-alias-brand-primary)}',
+      '.soul-persona-dot:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}',
+      // 操作区：固定宽度 + 两个等宽轨道，「使用」永远在第 1 轨、删除位永远在第 2 轨。
+      // 间距对齐宿主 .zGbnIq_rowActions 的 gap:4px；margin-top:auto 让它贴卡片底部，
+      // 于是不同摘要长度的卡片按钮仍对齐（堆叠容器高度固定，不会被内容撑变）。
+      // 操作区：「使用」是卡牌主操作（要突出），弹性占满可用宽度；
+      // 「删除」是次要破坏性操作，定宽小按钮，不抢主次。
+      // 内置预设无删除 ⇒ 不渲染删除按钮，「使用」自然占满整行。
+      '.soul-persona-actions{display:flex;align-items:center;gap:8px;margin-top:auto;padding-top:2px}',
+      // 主按钮：走主题的主按钮色族（brand 底 + 反色前景）。
+      // 为什么不再沿用「对齐宿主 linkButton」的 28px 透明底：那是**列表行**里的
+      // 文字按钮规格，而卡牌的主操作需要更强的视觉权重（样张里也是实心主色按钮）。
+      '.soul-persona-action{box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;gap:5px;height:36px;padding:0 14px;border:0;border-radius:var(--dsw-radius-md,12px);background:var(--dsw-alias-button-primary-fill);color:var(--dsw-alias-label-primary-foreground);font:inherit;font-size:13px;font-weight:600;line-height:20px;cursor:pointer;white-space:nowrap;flex:1 1 auto;min-width:0;transition:filter .15s ease}',
+      '.soul-persona-action:hover:not(:disabled){filter:brightness(1.08)}',
+      '.soul-persona-action:active:not(:disabled){filter:brightness(0.96)}',
+      '.soul-persona-action:disabled{cursor:default;opacity:.5}',
+      '.soul-persona-action:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}',
+      // 当前生效的预设：按钮文字为「使用中」，样式改为**描边式**（透明底 + 品牌色边框与文字），
+      // 与其它卡片的实心主色按钮形成对比 —— 这样即使不看名称前的 ★，也能一眼认出当前配置。
+      // 仍可点击（再点一次是无变化的幂等操作，宿主会回「配置无变化」），不刻意禁用：
+      // 禁用会让用户以为卡住了，而这里并无副作用。
+      '.soul-persona-active{background:transparent;color:var(--dsw-alias-brand-primary);box-shadow:inset 0 0 0 .5px var(--dsw-alias-brand-primary)}',
+      '.soul-persona-active:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover);filter:none}',
+      // 删除：定宽描边式危险按钮（43px），明显小于「使用」，形成主次对比
+      '.soul-persona-danger{flex:0 0 43px;background:transparent;color:var(--dsw-alias-state-error-primary);border:.5px solid var(--dsw-alias-state-error-primary);font-size:12px;font-weight:500}',
+      '.soul-persona-danger:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover-danger);filter:none}',
+      // 内置预设：不渲染删除按钮（后端也拒绝删除），「使用」占满整行。
+      // 类名保留是为了兼容既有断言与「空占位不能是可点控件」这条历史契约。
+      '.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}',
+      // ——「存为新预设」命名弹层（方案 A）——
+      // 遮罩用 fixed 全屏 + 半透明；层级要低于 toast（toast 是 10000），
+      // 因为保存成功后 toast 要能盖在弹层之上被看到。
+      '.soul-modal-mask{position:fixed;inset:0;z-index:9000;display:flex;align-items:center;justify-content:center;background:rgba(10,14,35,.42);padding:24px}',
+      '.soul-modal{box-sizing:border-box;width:100%;max-width:380px;display:flex;flex-direction:column;gap:14px;padding:18px;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-lv3,0 12px 32px rgba(0,0,0,.18))}',
+      '.soul-modal-title{color:var(--dsw-alias-label-primary);font-size:15px;font-weight:600;line-height:22px}',
+      '.soul-modal .soul-field{margin-bottom:0}',
+      // 「将保存 / 不含」两行说明：这是消除「不知道存了哪些值」的关键，用弱化样式但仍可读
+      '.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)}',
+      '.soul-modal-actions{display:flex;justify-content:flex-end;gap:8px}',
+      // 二次确认态：描边 → 实心危险色，**并放宽按钮**。
+      // 放宽是必须的：普通态按「删除」两字定宽 43px，而「确认删除？」是五个字，
+      // 沿用 43px 会把文字挤到贴边/溢出（实测截图确认）。此时它是需要用户看清的
+      // 关键动作，宽度优先于「不与主按钮抢视觉」这条次要原则。
+      '.soul-persona-danger-armed{flex:0 0 auto;padding:0 10px;background:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-label-primary-foreground);border-color:var(--dsw-alias-state-error-primary)}',
+      '.soul-persona-danger-armed:hover:not(:disabled){background:var(--dsw-alias-state-error-primary);filter:brightness(1.08)}',
+      // 提示词预览：宿主用 bg-module-platform 表达「内嵌代码/只读区」
+      '.soul-prompt-pre{margin:8px 0 0 0;padding:12px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-module-platform);color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.6;white-space:pre-wrap;word-break:break-word;max-height:240px;overflow:auto;font-family:var(--ds-font-family-code,Consolas,Menlo,monospace);text-align:left;width:100%;box-sizing:border-box}',
+      // —— 保存成功的内联绿字 ——
+      // 规格照抄宿主模型设置页的 .savedNotice（zGbnIq_savedNotice）：
+      // color:var(--dsw-alias-state-success-primary)、margin:0、12px/18px。
+      // 位置也一致：标题区之后、分组列表之前。生命周期不自动消失，
+      // 由下一次编辑（dirty）清除 —— 见组件里的 effect。
+      // 「已偏离任何预设」的出口：一行提示 + 一个行动按钮。
+      // 用与宿主一致的弱化文字色 + 品牌色可点文字（不是实心按钮 —— 它是提示性的
+      // 建议动作，不该与「使用」抢视觉权重）。
+      '.soul-drift{display:flex;align-items:center;flex-wrap:wrap;gap:8px;margin-top:8px;padding:8px 12px;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:var(--dsw-alias-bg-module-platform)}',
+      '.soul-drift-text{min-width:0;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:18px}',
+      '.soul-drift-action{box-sizing:border-box;display:inline-flex;align-items:center;height:24px;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;white-space:nowrap}',
+      '.soul-drift-action:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+      '.soul-drift-action:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',      '.soul-saved-notice{margin:0;color:var(--dsw-alias-state-success-primary);font-size:12px;line-height:18px}',
+      // 失败红字：规格照抄宿主 .zGbnIq_error（state-error-primary、margin:0、12px/18px），
+      // role=alert。与绿字同位互斥（失败压过成功），都不自动消失。
+      '.soul-error-notice{margin:0;color:var(--dsw-alias-state-error-primary);font-size:12px;line-height:18px}',
       // —— 输入框光轨 ——
       // 几何规则（position/尺寸/contain）同时内联在元素上，见 mountTrailRing；
       // 这里保留一份等价声明作为兜底，并让样式可读、可被第三方主题安全覆盖（仅颜色/速度/粗细）
@@ -588,14 +862,16 @@ window.__ModuleLoader__.load({
       '[data-composer-card][data-soul-trail="on"]{--dsw-elevation-stroke-color:transparent}',
       // 设置页：颜色控件与实时示例
       '.soul-trail-colors{display:flex;align-items:center;gap:8px;flex-wrap:wrap}',
-      '.soul-trail-swatch{width:26px;height:26px;padding:0;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;cursor:pointer}',
+      '.soul-trail-swatch{width:26px;height:26px;padding:0;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);cursor:pointer}',
       '.soul-trail-swatch[data-active="true"]{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:1px}',
-      '.soul-trail-picker{width:34px;height:26px;padding:0;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:none;cursor:pointer}',
-      '.soul-field .soul-trail-colors input.soul-trail-hex{width:104px;padding:5px 8px;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);font-size:12px;line-height:1.4;font-family:Consolas,Menlo,monospace;box-sizing:border-box}',
-      '.soul-trail-preview{position:relative;margin-top:6px;padding:16px;border:1px solid var(--dsw-alias-border-l2);border-radius:22px;background:var(--dsw-alias-bg-layer-1)}',
+      '.soul-trail-picker{width:34px;height:26px;padding:0;border:.5px solid var(--dsw-alias-settings-card-stroke);border-radius:var(--dsw-radius-sm);background:none;cursor:pointer}',
+      '.soul-field .soul-trail-colors input.soul-trail-hex{width:104px;padding:5px 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-size:12px;line-height:1.4;font-family:Consolas,Menlo,monospace;box-sizing:border-box}',
+      '.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)}',
-      '@media (prefers-reduced-motion:reduce){.soul-trail-layer{animation:none}}'
+      // 开了「减少动态效果」时：光轨层与卡片停动画。
+      // 结果提示（绿字/红字）不需要在这里照顾 —— 它们是静态文字、没有动画。
+      '@media (prefers-reduced-motion:reduce){.soul-trail-layer{animation:none}.soul-persona-card{animation:none!important;transition:none}}'
     ].join('')
 
     const tagId = 'dsh-soul/styles.css'
@@ -624,6 +900,8 @@ window.__ModuleLoader__.load({
       'settings.title': '个性化设置',
       'accordion.filled': '项已填写',
       'accordion.empty': '未填写',
+      // 分组摘要在「拉取失败」时的显示（折叠态下用户只看得到这一行）
+      'accordion.loadFailed': '加载失败',
       'accordion.personas': '个预设',
       'accordion.on': '已开启',
       'accordion.off': '未开启',
@@ -631,7 +909,10 @@ window.__ModuleLoader__.load({
       'quick.enable': '开启个性化',
       'quick.disable': '关闭个性化',
       'quick.statusEnabled': '个性化已启用',
+      'quick.custom': '自定义',
       'quick.statusDisabled': '个性化已关闭',
+      // 快捷开关保存失败时的兜底文案（有服务端 error 时优先显示它）
+      'quick.toggleFailed': '保存失败，请重试',
       'group.aboutYou': '关于你',
       'field.nickname': '用户昵称',
       'field.nicknamePlaceholder': '输入你的昵称，回复时会称呼你',
@@ -657,13 +938,34 @@ window.__ModuleLoader__.load({
       'field.instructionsPlaceholder': '输入自定义指令，可以是其他行为、回复风格和语调等偏好设置',
       'group.personas': '人设预设',
       'personas.save': '保存当前为预设',
+      // 方案 A：入口移出预设列表，与「保存设置」并列（文案用「存为预设…」表示会再问一步）
+      'personas.saveAs': '存为预设…',
+      'personas.saveNameLabel': '新预设名称',
+      'personas.saveConfirm': '保存',
+      'personas.saveCovers': '将保存：回复风格和语调、特质、回复长度、输出语言、自定义指令',
+      'personas.saveExcludes': '不含：昵称、职业、介绍（这些属于「关于你」，预设不动它们）',
+      'personas.confirmDeleteShort': '确认删除？',
+      // —— 卡背（详情面）——
+      'personas.details': '详情',
+      'personas.flipBack': '返回',
+      'personas.dims': '人设维度',
+      'personas.customInstructions': '自定义指令',
+      'personas.dimDefault': '默认',
+      'personas.noCustomInstructions': '这个人设没有额外的自定义指令',
       'personas.savePlaceholder': '预设名称（1-30 字符）',
       'personas.use': '使用',
+      'personas.active': '使用中',
       'personas.delete': '删除',
+      'personas.prev': '上一个预设',
+      'personas.next': '下一个预设',
       'personas.confirmDelete': '确定删除预设「{name}」？',
       'personas.empty': '暂无人设预设，保存当前配置后可一键切换',
+      // 列表拉取失败（此前是空 catch ⇒ 界面会永远停在「加载中...」）
+      'personas.loadFailed': '人设预设加载失败：{reason}',
       'personas.builtin': '内置',
-      'personas.hint': '内置预设随插件提供，不可删除；保存当前配置可创建自己的预设',
+      'personas.drift': '当前配置与任何预设都不一致。',
+      'personas.driftAction': '存为新预设',
+      'personas.hint': '预设只保存 Agent 的人设（风格 / 特质 / 回复长度 / 输出语言 / 自定义指令），不含「关于你」；内置预设随插件提供，不可删除',
       'style.professional': '专业严谨',
       'style.casual': '轻松自然',
       'style.humorous': '幽默风趣',
@@ -694,21 +996,36 @@ window.__ModuleLoader__.load({
       'meta.language.en': '英文',
       'group.tool': 'Agent 工具',
       'field.toolConfirm': '人设变更需确认',
-      'hint.toolConfirm': '开启后，Agent 通过 set_persona 工具做出的修改不会立即生效，需在会话中使用 /soul confirm 确认或 /soul reject 拒绝。',
+      'hint.toolConfirm': '开启后，Agent 改人设会先在输入框处弹出审批面板（Enter 允许 / Esc 拒绝）。若会话审批通道不可用（策略为 never），则退化为待确认提议，需用 /soul confirm 处理 —— 此时建议关闭本开关，否则每次改动都要手输命令。',
       'button.save': '保存设置',
       'button.saving': '保存中...',
+      'button.cancel': '取消',
       'button.reset': '重置默认',
       'status.loading': '加载中...',
       'status.unsaved': '有未保存的更改',
+      // —— 内联绿字（对齐宿主模型设置页的 savedNotice）——
+      // 保存类成功提示不再走 toast（宿主那里根本不用 toast 报成功），
+      // 文案对齐宿主语气：句末带句号、不带 emoji（宿主绿字没有装饰符号）
+      'notice.saved': '设置已保存。',
+      'notice.noChanges': '配置无变化。',
+      'notice.reset': '已重置为默认值。',
+      'notice.resetRecovered': '已重置为默认值（损坏的配置已备份）。',
+      'notice.personaSaved': '已保存预设「{name}」。',
+      'notice.personaUsed': '已应用预设「{name}」。',
+      'notice.personaUnchanged': '预设与当前配置一致。',
+      'notice.personaDeleted': '已删除预设「{name}」。',
+      // 以下错误类仍走 toast（打断性提示）
       'toast.saved': '✅ 设置已保存',
       'toast.noChanges': '✅ 配置无变化',
       'toast.reset': '✅ 已重置为默认值',
+      'toast.resetRecovered': '✅ 已重置为默认值（损坏的配置已备份）',
+      'toast.resetFailed': '❌ 重置失败',
       'toast.personaSaved': '✅ 预设已保存',
       'toast.personaUsed': '✅ 预设已应用',
+      // 预设含非法取值时服务端只应用合法部分，被跳过的字段必须回报
+      'toast.personaPartial': '⚠ 预设仅部分应用，以下字段取值非法已跳过：{fields}',
       'toast.personaUnchanged': 'ℹ 预设与当前配置一致',
       'toast.personaDeleted': '✅ 预设已删除',
-      'prompt.view': '查看当前生效提示词',
-      'prompt.hide': '收起提示词',
       'prompt.title': '当前生效提示词',
       'prompt.summaryEnabled': '已启用',
       'prompt.summaryDisabled': '已禁用',
@@ -719,6 +1036,9 @@ window.__ModuleLoader__.load({
       'prompt.titleDraft': '保存后将生效的提示词',
       'prompt.summaryDraft': '{n} 字符 · 未保存',
       'prompt.invalid': '以下字段未通过校验，未计入本次预览：{fields}',
+      // 列表分隔符：中文用顿号、英文用逗号 + 空格。此前英文界面里也硬编码「、」，
+      // 会渲染成 `...excluded from this preview: style、tables`（中英混排）。
+      'common.listSep': '、',
       'toast.saveFailed': '❌ 保存失败，请检查配置',
       'trail.title': '输入框光轨',
       'trail.enable': '启用输入框光轨',
@@ -741,6 +1061,8 @@ window.__ModuleLoader__.load({
       'settings.title': 'Personalization Settings',
       'accordion.filled': 'fields filled',
       'accordion.empty': 'No fields set',
+      // 分组摘要在「拉取失败」时的显示（折叠态下用户只看得到这一行）
+      'accordion.loadFailed': 'Failed to load',
       'accordion.personas': 'personas',
       'accordion.on': 'enabled',
       'accordion.off': 'disabled',
@@ -748,7 +1070,10 @@ window.__ModuleLoader__.load({
       'quick.enable': 'Enable personalization',
       'quick.disable': 'Disable personalization',
       'quick.statusEnabled': 'Personalization enabled',
+      'quick.custom': 'Custom',
       'quick.statusDisabled': 'Personalization disabled',
+      // 快捷开关保存失败时的兜底文案（有服务端 error 时优先显示它）
+      'quick.toggleFailed': 'Save failed, please retry',
       'group.aboutYou': 'About you',
       'field.nickname': 'Nickname',
       'field.nicknamePlaceholder': 'Your nickname — the agent will address you by it',
@@ -774,13 +1099,32 @@ window.__ModuleLoader__.load({
       'field.instructionsPlaceholder': 'Custom instructions — other behaviors, style or tone preferences',
       'group.personas': 'Personas',
       'personas.save': 'Save current as persona',
+      'personas.saveAs': 'Save as persona…',
+      'personas.saveNameLabel': 'New persona name',
+      'personas.saveConfirm': 'Save',
+      'personas.saveCovers': 'Saves: reply style & tone, traits, reply length, reply language, custom instructions',
+      'personas.saveExcludes': 'Excludes: nickname, occupation, bio (those are "About you" — personas never touch them)',
+      'personas.confirmDeleteShort': 'Confirm delete?',
+      'personas.details': 'Details',
+      'personas.flipBack': 'Back',
+      'personas.dims': 'Persona dimensions',
+      'personas.customInstructions': 'Custom instructions',
+      'personas.dimDefault': 'Default',
+      'personas.noCustomInstructions': 'This persona adds no custom instructions',
       'personas.savePlaceholder': 'Persona name (1-30 chars)',
       'personas.use': 'Use',
+      'personas.active': 'Active',
       'personas.delete': 'Delete',
+      'personas.prev': 'Previous persona',
+      'personas.next': 'Next persona',
       'personas.confirmDelete': 'Delete persona "{name}"?',
       'personas.empty': 'No personas yet — save the current config to switch with one click',
+      // 列表拉取失败（此前是空 catch ⇒ 界面会永远停在「加载中...」）
+      'personas.loadFailed': 'Failed to load personas: {reason}',
       'personas.builtin': 'Built-in',
-      'personas.hint': 'Built-in personas ship with the plugin and cannot be deleted; save the current config to create your own',
+      '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',
       'style.professional': 'Professional',
       'style.casual': 'Casual',
       'style.humorous': 'Humorous',
@@ -811,21 +1155,33 @@ window.__ModuleLoader__.load({
       'meta.language.en': 'English',
       'group.tool': 'Agent tools',
       'field.toolConfirm': 'Require confirmation for persona changes',
-      'hint.toolConfirm': 'When enabled, changes made by the agent through the set_persona tool do not apply immediately — confirm with /soul confirm or reject with /soul reject in the conversation.',
+      '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.',
       'button.save': 'Save Settings',
       'button.saving': 'Saving...',
+      'button.cancel': 'Cancel',
       'button.reset': 'Reset to Default',
       'status.loading': 'Loading...',
       'status.unsaved': 'You have unsaved changes',
+      // Inline success notice (mirrors the host models page savedNotice)
+      'notice.saved': 'Settings saved.',
+      'notice.noChanges': 'No changes to save.',
+      'notice.reset': 'Reset to defaults.',
+      'notice.resetRecovered': 'Reset to defaults (the damaged config was backed up).',
+      'notice.personaSaved': 'Saved persona "{name}".',
+      'notice.personaUsed': 'Applied persona "{name}".',
+      'notice.personaUnchanged': 'Persona matches current config.',
+      'notice.personaDeleted': 'Deleted persona "{name}".',
       'toast.saved': '✅ Settings saved',
       'toast.noChanges': '✅ No changes to save',
       'toast.reset': '✅ Reset to defaults',
+      'toast.resetRecovered': '✅ Reset to defaults (the damaged config was backed up)',
+      'toast.resetFailed': '❌ Reset failed',
       'toast.personaSaved': '✅ Persona saved',
       'toast.personaUsed': '✅ Persona applied',
+      // 预设含非法取值时服务端只应用合法部分，被跳过的字段必须回报
+      'toast.personaPartial': '⚠ Persona applied partially; skipped as invalid: {fields}',
       'toast.personaUnchanged': 'ℹ Persona matches current config',
       'toast.personaDeleted': '✅ Persona deleted',
-      'prompt.view': 'View the active system prompt',
-      'prompt.hide': 'Hide the prompt',
       'prompt.title': 'Active system prompt',
       'prompt.summaryEnabled': 'Enabled',
       'prompt.summaryDisabled': 'Disabled',
@@ -836,6 +1192,9 @@ window.__ModuleLoader__.load({
       'prompt.titleDraft': 'Prompt after saving',
       'prompt.summaryDraft': '{n} chars · unsaved',
       'prompt.invalid': 'These fields failed validation and are excluded from this preview: {fields}',
+      // 列表分隔符：中文用顿号、英文用逗号 + 空格。此前英文界面里也硬编码「、」，
+      // 会渲染成 `...excluded from this preview: style、tables`（中英混排）。
+      'common.listSep': ', ',
       'toast.saveFailed': '❌ Save failed — please check the config',
       'trail.title': 'Composer light trail',
       'trail.enable': 'Enable composer light trail',
@@ -913,9 +1272,12 @@ window.__ModuleLoader__.load({
     // 编译结果，不该因此重新请求，也不该让预览被标成「未保存」。
     const PROMPT_FIELD_KEYS = ['enabled', 'nickname', 'occupation', 'bio', 'style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language', 'customInstructions']
 
-    // 提示词小图标：hover 展示说明文字
+    // 提示词小图标：hover / 键盘聚焦都展示说明文字。
+    // 此前只有 :hover 可达，且提示节点用 visibility:hidden —— 那会把它移出无障碍树，
+    // 键盘与读屏用户拿不到字段说明。这里补 tabIndex 让它可以聚焦，并在 :focus-visible
+    // 下显示提示（同时保留 aria-label，聚焦时读屏会念出说明本身）。
     function SoulHint(props) {
-      return e('span', { className: 'soul-hint', 'aria-label': props.text },
+      return e('span', { className: 'soul-hint', 'aria-label': props.text, tabIndex: 0 },
         e('svg', {
           viewBox: '0 0 24 24',
           width: 14,
@@ -961,33 +1323,54 @@ 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)
+      const failureText = failed ? (state.error || t('quick.toggleFailed')) : null
 
       const toggle = async () => {
         if (busy) return
-        await controller.saveConfig({ enabled: !enabled })
+        setFailed(false)
+        const payload = await controller.saveConfig({ enabled: !enabled })
+        // saveConfig 失败时返回 undefined；成功时返回载荷
+        setFailed(!payload)
       }
 
       return e('button', {
         type: 'button',
-        className: 'soul-quick-toggle',
+        className: failed ? 'soul-quick-toggle soul-quick-toggle-failed' : 'soul-quick-toggle',
         'data-enabled': enabled ? 'true' : 'false',
+        'data-failed': failed ? 'true' : 'false',
         'aria-pressed': enabled,
-        'aria-label': enabled ? t('quick.disable') : t('quick.enable'),
-        title: enabled ? t('quick.disable') : t('quick.enable'),
+        // 失败时把原因写进 aria-label / title：否则按钮外观不变，用户无从得知保存失败
+        'aria-label': failureText || (enabled ? t('quick.disable') : t('quick.enable')),
+        title: failureText || (enabled ? t('quick.disable') : t('quick.enable')),
         disabled: busy,
         onClick: toggle
       },
         e('span', { className: 'soul-quick-toggle-dot', 'aria-hidden': true }),
-        enabled ? t('quick.statusEnabled') : t('quick.statusDisabled')
+        enabled ? t('quick.statusEnabled') : t('quick.statusDisabled'),
+        // 启用时**始终**缀上「当前是哪套人设」：匹配到预设显示预设名，
+        // 未匹配（手改过特质、或纯自定义配置）显示「自定义」。
+        //
+        // 为什么不再留空：留空等于「我现在用的到底是什么」没有答案，而
+        // 「未匹配预设」这种说法听着像报错。底栏这里是输入框旁唯一的常驻状态，
+        // 必须给确定的落点 —— 有名字就是那个预设，没名字就是自定义。
+        // 关闭个性化时不显示（人设此时不生效，挂名字会误导）。
+        enabled && e('span', { className: 'soul-quick-toggle-name' },
+          `· ${activePersona || t('quick.custom')}`)
       )
     }
 
-    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, loading, saving, error } = 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 [localEnabled, setLocalEnabled] = React.useState(enabled)
       const [localNickname, setLocalNickname] = React.useState(nickname || '')
@@ -1006,7 +1389,59 @@ window.__ModuleLoader__.load({
       const [localTrailSpeed, setLocalTrailSpeed] = React.useState(trailSpeed || 'slow')
       const [localTrailWidth, setLocalTrailWidth] = React.useState(trailWidth || 'thin')
       const [personaName, setPersonaName] = React.useState('')
-      const [toast, setToast] = React.useState(null)
+      // 「存为预设」的命名弹层是否打开。
+      //
+      // 方案 A：把「保存当前为预设」从预设列表里**移出来**，做成「保存设置」旁的同级动作，
+      // 点开才问名字。原因（用户反馈「比较迷茫」）：
+      //   ① 它原先被塞在预设列表最下面，而用户此时的心理模型是「我在看别人的预设」，
+      //      突然出现「保存当前」的输入框，说不清「当前」指什么；
+      //   ② 真正被保存的是「关于你/特质」里的字段，那些字段在**别的分组**里，
+      //      用户在预设区输入名字，不知道到底存了哪些值；
+      //   ③ 「保存设置」与「保存当前为预设」两个保存并列，语义没区分；
+      //      且名字要先想好才能点（disabled 依赖非空），交互顺序也别扭。
+      const [showSavePersona, setShowSavePersona] = React.useState(false)
+      // 待删除的预设名（null = 没有待确认的删除）。
+      //
+      // 替代原生 window.confirm：原生模态框在 webview 里可能把文档焦点留在异常状态
+      // （表现为「页面看得见却点不动、打不了字」，最小化再恢复才好）。宿主自己的设置页
+      // 也不用原生 confirm，这里改为**内联二次确认**：第一次点「删除」把按钮切换成
+      // 「确认删除？」，再点一次才真删；点别处或超时则复位。
+      const [pendingDelete, setPendingDelete] = React.useState(null)
+      // 卡片堆叠轮播的当前索引（人设预设一次只展示一张，左右可滑动/翻页）。
+      // 索引在预设数组变化后可能越界（删除、加载失败后重取），渲染时统一夹取，
+      // 不在 effect 里回写 —— 回写会多一次渲染，且删除后「看过的那张」位置语义
+      // 本就有歧义（见 personaIndex 的夹取逻辑）。
+      const [personaIndex, setPersonaIndex] = React.useState(0)
+      // 卡背（详情面）状态：存「哪一张卡被翻到了背面」。
+      //
+      // 设计要点（这是 E 方案最容易做错的地方）：
+      //   **卡背不是轮播的第 N+1 张，而是当前卡的另一种「面」** —— 所以索引
+      //   index/total/go()/自动定位全部不用改，翻页翻的是「卡」，翻面翻的是「面」。
+      //   若把卡背也算一张，total 要变 2N、位置指示与圆点全要跟着改，得不偿失。
+      //
+      //   状态绑定在**人设名**而不是索引：删除/刷新后同名的卡仍是同一张，
+      //   绑索引会在列表变短时翻错面。
+      const [flippedName, setFlippedName] = React.useState(null)
+      // —— 内联结果提示（对齐宿主模型设置页的全局形态）——
+      //
+      // 查证：宿主设置页（dsh-client-ui-settings-models）**从不使用 toast** ——
+      // 成功是顶部一行绿字（.savedNotice，role=status），失败是内联红字
+      // （.error，role=alert），两者同字号（12px/18px）、就地出现、不自动消失。
+      // 因此这里对称地用两个状态承载：savedNotice（绿）/ errorNotice（红），
+      // 均在「下一次操作开始」时被替换，编辑时清除绿字。
+      const [savedNotice, setSavedNotice] = React.useState(null)
+      const showSavedNotice = (text) => setSavedNotice(text)
+      const [errorNotice, setErrorNotice] = React.useState(null)
+      const showError = (text) => {
+        // 失败要压过之前的成功提示（用户要知道最新一次操作的结果）
+        setSavedNotice(null)
+        setErrorNotice(text)
+      }
+      //
+      // 查证：宿主保存成功的提示不是 toast，而是设置页顶部的一行绿字
+      // （.savedNotice：state-success-primary 绿、12px/18px、role:status +
+      // aria-live:polite），且**不会自动消失** —— 只在开始编辑/删除/新增时清除。
+      // 这里保持同一生命周期：下一次 dirty（开始编辑）时清除，见下方 effect。
       const [showPrompt, setShowPrompt] = React.useState(false)
       const [promptText, setPromptText] = React.useState('')
       const [promptLoading, setPromptLoading] = React.useState(false)
@@ -1033,42 +1468,92 @@ window.__ModuleLoader__.load({
       }, [openSection])
 
       // 同步状态
+      // 用 store 回填本地表单 —— 但**按字段**决定，而不是一刀切。
+      //
+      // 此前是「dirty || saving 就整体不回填」：点「使用」应用预设后，store 先变、
+      // 本地表单还是旧值 ⇒ 那一次渲染 dirty 恒为 true ⇒ 回填被挡 ⇒ 表单停在旧值。
+      // 之后「保存设置」亮起（用户没改任何东西也亮），一点保存就把**旧表单值**
+      // 整体 POST 上去，把刚应用的预设覆盖回旧配置 —— 正是「使用后人设变回默认」。
+      //
+      // 现在的判据：记录「上次与 store 同步时的本地快照」。某字段的当前本地值
+      // 仍等于快照 ⇒ 用户没动过它 ⇒ 安全回填新值；不等于 ⇒ 用户正在编辑 ⇒ 保留。
+      // 既有保护（轮询不覆盖正在编辑的内容）逐字段保留，语义不变。
+      //
+      // saving 期间仍然整体跳过：保存流程自身会带着响应回填（见 saveConfig →
+      // applyConfig → 本 effect），中途再插一次写入只会造成闪烁。
+      const formKeys = ['enabled', 'nickname', 'occupation', 'bio', 'style', 'headingLists', 'emoji', 'tables', 'replyLength', 'language', 'customInstructions', 'requireToolConfirmation', 'trailEnabled', 'trailColor', 'trailSpeed', 'trailWidth']
+      const localValues = { 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 serverValues = { enabled, nickname: nickname || '', occupation: occupation || '', bio: bio || '', style, headingLists, emoji, tables, replyLength, language: language || 'zh', customInstructions, requireToolConfirmation: requireToolConfirmation === true, trailEnabled: trailEnabled === true, trailColor: trailColor || TRAIL_COLOR_FALLBACK, trailSpeed: trailSpeed || 'slow', trailWidth: trailWidth || 'thin' }
+      const lastSyncRef = React.useRef(null)
+      // 判断某字段是否被用户动过：与「上次同步的快照」比。没有快照（首帧）时
+      // 一律视为未动过 —— 首帧本地值本来就来自 store，无从谈起「编辑过」。
+      const userEdited = (key) => {
+        const snap = lastSyncRef.current
+        if (!snap) return false
+        return !sameValue(localValues[key], snap[key])
+      }
       React.useEffect(() => {
-        setLocalEnabled(enabled)
-        setLocalNickname(nickname || '')
-        setLocalOccupation(occupation || '')
-        setLocalBio(bio || '')
-        setLocalStyle(style)
-        setLocalHeadingLists(headingLists)
-        setLocalEmoji(emoji)
-        setLocalTables(tables)
-        setLocalReplyLength(replyLength)
-        setLocalLanguage(language || 'zh')
-        setLocalInstructions(customInstructions)
-        setLocalToolConfirm(requireToolConfirmation === true)
-        setLocalTrailEnabled(trailEnabled === true)
-        setLocalTrailColor(trailColor || TRAIL_COLOR_FALLBACK)
-        setLocalTrailSpeed(trailSpeed || 'slow')
-        setLocalTrailWidth(trailWidth || 'thin')
+        if (saving) return
+        const next = {}
+        let changed = false
+        for (const key of formKeys) {
+          // 用户改过的字段一律保留；没动过的字段跟随 store
+          const target = userEdited(key) ? localValues[key] : serverValues[key]
+          next[key] = target
+          if (!sameValue(target, localValues[key])) changed = true
+        }
+        lastSyncRef.current = next
+        if (!changed) return
+        setLocalEnabled(next.enabled)
+        setLocalNickname(next.nickname)
+        setLocalOccupation(next.occupation)
+        setLocalBio(next.bio)
+        setLocalStyle(next.style)
+        setLocalHeadingLists(next.headingLists)
+        setLocalEmoji(next.emoji)
+        setLocalTables(next.tables)
+        setLocalReplyLength(next.replyLength)
+        setLocalLanguage(next.language)
+        setLocalInstructions(next.customInstructions)
+        setLocalToolConfirm(next.requireToolConfirmation)
+        setLocalTrailEnabled(next.trailEnabled)
+        setLocalTrailColor(next.trailColor)
+        setLocalTrailSpeed(next.trailSpeed)
+        setLocalTrailWidth(next.trailWidth)
+        // 依赖与 serverValues 的来源一致；localValues/sameValue 每次渲染都是新的，
+        // 但只在「某字段真要写」时才 setState，故不会形成死循环。
       }, [enabled, nickname, occupation, bio, style, headingLists, emoji, tables, replyLength, language, customInstructions, requireToolConfirmation, trailEnabled, trailColor, trailSpeed, trailWidth])
 
-      // toast 自动消失
-      React.useEffect(() => {
-        if (toast) {
-          const timer = setTimeout(() => setToast(null), 2000)
-          return () => clearTimeout(timer)
-        }
-      }, [toast])
+      // toast 的消失交给宿主 Toast 组件自己（holdMs 后淡出并回调 onDone）。
+      // 此前这里有个 2s 定时器 + 自绘 CSS 动画，两者时长必须手工对齐，
+      // 且与全局提示条的 3s + 1s 淡出不一致 ⇒ 已删除。
 
-      // dirty 检测：本地表单与已保存配置逐字段比较
+      // dirty 检测：本地表单与已保存配置逐字段比较。
+      //
+      // 字符串一律先 trim 再比：服务端对每个字符串字段都会 trim（文本字段 trim、枚举值
+      // trim、颜色 trim），所以「只改了首尾空格」落盘后与原值完全相同。此前按原始串
+      // 比较会出现「用户敲了个空格 → 保存按钮亮了 → 保存成功却提示『配置无变化』」。
+      // 不另造一份 TEXT_FIELDS 复刻表：那会多一处需要手工同步的常量。
+      const sameValue = (a, b) => (typeof a === 'string' && typeof b === 'string'
+        ? a.trim() === b.trim()
+        : 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) => savedMap[key] !== localMap[key])
+      const dirty = FIELD_KEYS.some((key) => !sameValue(savedMap[key], localMap[key]))
+
+      // 宿主 savedNotice 语义：一旦用户开始新的编辑（dirty 变 true），
+      // 上一条「已保存」就过时了 ⇒ 清除。（effect 必须放在 dirty 定义之后：
+      // 依赖数组在渲染期求值，放前面会 TDZ —— 实测踩过。）
+      React.useEffect(() => {
+        if (dirty) setSavedNotice(null)
+      }, [dirty])
 
       // 预览是否反映未保存的编辑：只看参与编译的字段（见 PROMPT_FIELD_KEYS）。
       // 这里用 localMap/savedMap 逐字段比，而不是复用上面的 dirty —— 改光轨颜色会让
       // dirty 为真，但那不影响提示词，此时预览仍是「已生效内容」，标成草稿反而误导。
-      const promptDirty = PROMPT_FIELD_KEYS.some((key) => savedMap[key] !== localMap[key])
+      // 必须与 dirty 用**同一个** sameValue 判据：否则「只改了首尾空格」时 dirty 为假
+      // （保存按钮禁用）而 promptDirty 为真（预览标成草稿），两处自相矛盾。
+      const promptDirty = PROMPT_FIELD_KEYS.some((key) => !sameValue(savedMap[key], localMap[key]))
       // 草稿指纹：仅在影响编译的字段真的变化时才重新预览
       const promptDraftKey = PROMPT_FIELD_KEYS.map((key) => String(localMap[key])).join('\u0000')
 
@@ -1079,7 +1564,7 @@ window.__ModuleLoader__.load({
         return out
       }
 
-      // 有未保存编辑时预览草稿（＝保存后真正会注入的内容），否则预览已生效提示词
+      // 有未保存编辑时预览草稿（＝保存后真正会生效的内容），否则预览已生效提示词
       const loadPrompt = async () => {
         const asDraft = promptDirty
         setPromptLoading(true)
@@ -1101,43 +1586,31 @@ window.__ModuleLoader__.load({
       // 展开/收起只切状态；编译由下方 effect 统一驱动（唯一入口，避免重复请求）
       const togglePrompt = () => setShowPrompt((open) => !open)
 
-      const loadPersonas = async () => {
-        try {
-          const payload = await controller.fetchPersonas()
-          controller.store.update((s) => {
-            s.personas = payload.personas
-            s.activePersona = payload.activeName
-          })
-        } catch {
-          // 预设列表加载失败不打断主配置界面
-        }
-      }
+      // 逻辑已下沉到 controller.loadPersonas（全局轮询与设置页共用一份实现）。
+      const loadPersonas = () => controller.loadPersonas()
 
-      // 设置页打开后重新读取宿主配置，补齐 /soul 命令等外部写入路径。
-      // 表单 dirty 或正在保存时暂停，避免远端刷新覆盖用户未保存的输入。
+      // 定时轮询已**上移到 apply()**（全局一份，与设置页是否挂载无关）——
+      // 这里只负责告诉它「现在别刷」：有未保存编辑或正在保存时暂停，
+      // 否则远端刷新会把用户正在改的值拽回去。
+      //
+      // 用 effect 而不是渲染期直接赋值：赋值要放在提交后（且卸载时必须复位，
+      // 否则关掉设置页会永久暂停轮询 —— 那正是这次要修的 bug 的镜像）。
       React.useEffect(() => {
-        const refresh = () => {
-          if (dirty || saving) return
-          void controller.loadConfig()
-          void loadPersonas()
-        }
-        const onVisibilityChange = () => {
-          if (document.visibilityState === 'visible') refresh()
-        }
-        refresh()
-        window.addEventListener('focus', refresh)
-        document.addEventListener('visibilitychange', onVisibilityChange)
-        const timer = setInterval(refresh, 2000)
-        return () => {
-          window.removeEventListener('focus', refresh)
-          document.removeEventListener('visibilitychange', onVisibilityChange)
-          clearInterval(timer)
-        }
+        controller.paused = dirty || saving
+        return () => { controller.paused = false }
       }, [controller, dirty, saving])
 
+      // 进入设置页时立即对齐一次宿主状态（补齐 /soul 命令等外部写入路径），
+      // 不必等下一个 2s 轮询周期。
+      React.useEffect(() => {
+        if (!controller.canRefresh()) return
+        void controller.loadConfig()
+        void controller.loadPersonas()
+      }, [controller])
+
       // 提示词预览的编译入口（唯一）。
       // 展开时立即编译一次；此后只要影响编译的字段或脏状态变化，停止 400ms 再编译 —
-      // 边改边看保存后真正会注入的内容。
+      // 边改边看保存后真正会生效的内容。
       // promptSettled 用来区分「刚展开」与「展开后字段又变了」：否则展开这一动作自身
       // 会先立即编译一次、再被防抖重复编译一次。
       // 依赖里刻意不放 loadPrompt（组件体内每次渲染都会重建函数，放进去会无限循环）；
@@ -1161,34 +1634,47 @@ window.__ModuleLoader__.load({
         const payload = await controller.saveConfig(localMap)
         // saveConfig 失败时内部已记录 error 并返回 undefined：给出失败提示，而非误报「无变化」
         if (!payload) {
-          setToast({ text: t('toast.saveFailed'), kind: 'error' })
+          showError(t('toast.saveFailed'))
           return
         }
-        setToast({
-          text: Array.isArray(payload.changed) && payload.changed.length > 0 ? t('toast.saved') : t('toast.noChanges'),
-          kind: 'success'
-        })
+        // 成功提示走**内联绿字**（对齐宿主模型设置页的 savedNotice —— 见渲染处注释）：
+        // 有实际变化时报「已保存」；无变化时报「配置无变化」。
+        showSavedNotice(
+          Array.isArray(payload.changed) && payload.changed.length > 0
+            ? t('notice.saved')
+            : t('notice.noChanges')
+        )
         // 预览刷新交由下方 effect 统一驱动（保存 / 重置 / 应用预设都会改变
         // promptDraftKey 或 promptDirty，effect 自会带上最新闭包重编译）
       }
 
       const handleReset = async () => {
-        await controller.resetConfig()
-        setToast({ text: t('toast.reset'), kind: 'success' })
+        // resetConfig 失败时内部已记录 error 并返回 undefined。
+        // 此前这里无条件报「已重置」——失败也显示成功，正好把「配置损坏时唯一的自救操作
+        // 没成功」这件事藏了起来。
+        const payload = await controller.resetConfig()
+        if (!payload) {
+          showError(t('toast.resetFailed'))
+          return
+        }
+        showSavedNotice(payload.backupPath ? t('notice.resetRecovered') : t('notice.reset'))
         // 预览刷新交由下方 effect 统一驱动（保存 / 重置 / 应用预设都会改变
         // promptDraftKey 或 promptDirty，effect 自会带上最新闭包重编译）
       }
 
+      // 存为预设：把「关于你/特质」里的**当前设置**存成一个新预设。
+      // 名字来自命名弹层；成功后关闭弹层并清空输入。
       const handleSavePersona = async () => {
         const name = personaName.trim()
         if (!name) return
         try {
           await controller.savePersona(name)
           setPersonaName('')
+          setShowSavePersona(false)
           await loadPersonas()
-          setToast({ text: t('toast.personaSaved'), kind: 'success' })
+          showSavedNotice(t('notice.personaSaved', { name }))
         } catch (err) {
-          setToast({ text: messageOf(err), kind: 'error' })
+          showError(messageOf(err))
         }
       }
 
@@ -1196,25 +1682,87 @@ window.__ModuleLoader__.load({
         try {
           const payload = await controller.usePersona(name)
           await loadPersonas()
-          setToast({ text: payload && payload.unchanged ? t('toast.personaUnchanged') : t('toast.personaUsed'), kind: 'success' })
+          // 服务端回报了被丢弃的非法字段 ⇒ 预设只被部分应用，必须说出来而不是报「已应用」
+          const invalid = Array.isArray(payload && payload.invalid) ? payload.invalid : []
+          if (invalid.length > 0) {
+            showError(t('toast.personaPartial', { fields: invalid.join(', ') }))
+          } else {
+            // 成功提示走内联绿字（对齐宿主 savedNotice）；无变化也照报
+            showSavedNotice(payload && payload.unchanged
+              ? t('notice.personaUnchanged')
+              : t('notice.personaUsed', { name }))
+          }
           // 预览刷新交由下方 effect 统一驱动（保存 / 重置 / 应用预设都会改变
         // promptDraftKey 或 promptDirty，effect 自会带上最新闭包重编译）
         } catch (err) {
-          setToast({ text: messageOf(err), kind: 'error' })
+          showError(messageOf(err))
         }
       }
 
+      // 删除预设：**内联二次确认**，不用原生 window.confirm。
+      //
+      // 为什么换掉：原生模态框在 webview 里可能把文档焦点留在异常状态 —— 症状正是用户
+      // 报的「删除后页面看得见却点不动、下拉框与输入框都无法操作」，而最小化再恢复
+      // （触发 focus/visibilitychange）就变好。宿主自己的设置页也不用原生 confirm。
+      //
+      // 交互：第一次点「删除」→ 该按钮变成「确认删除？」且进入待确认态；再点一次才真删。
+      // 期间点别处 / 切换卡片 / 超时（见下方 effect）都会复位，避免误删。
       const handleDeletePersona = async (name) => {
-        if (typeof globalThis.confirm === 'function' && !globalThis.confirm(t('personas.confirmDelete', { name }))) return
+        if (pendingDelete !== name) {
+          setPendingDelete(name)
+          return
+        }
+        setPendingDelete(null)
         try {
           await controller.deletePersona(name)
           await loadPersonas()
-          setToast({ text: t('toast.personaDeleted'), kind: 'success' })
+          showSavedNotice(t('notice.personaDeleted', { name }))
         } catch (err) {
-          setToast({ text: messageOf(err), kind: 'error' })
+          showError(messageOf(err))
         }
       }
 
+      // 二次确认的超时复位：进入待确认态后 5 秒内没有再次点击就取消。
+      // 没有这道兜底，「确认删除？」会一直挂着 —— 用户过一会儿回来随手一点就真删了。
+      React.useEffect(() => {
+        if (pendingDelete === null) return
+        const timer = setTimeout(() => setPendingDelete(null), 5000)
+        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
+      }
+
       const styleOptions = STYLE_VALUES.map((value) => ({ value, label: t(`style.${value}`) }))
       const headingListsOptions = TRAIT_VALUES.map((value) => ({ value, label: t(`trait.headingLists.${value}`) }))
       const emojiOptions = TRAIT_VALUES.map((value) => ({ value, label: t(`trait.emoji.${value}`) }))
@@ -1229,10 +1777,47 @@ window.__ModuleLoader__.load({
           return aBuiltin - bBuiltin
         })
         : null
+
+      // 展开「人设预设」分组时，轮播自动定位到**当前生效**的那张，而不是永远停在第 1 张。
+      //
+      // 为什么需要：卡片一次只展示一张，若固定从第 1 张开始，用户点开分组后要翻好几下
+      // 才能看到自己正在用的是哪个（内置项排在前面，自建/生效项往往在后面）。
+      //
+      // 三个边界都要处理：
+      //   ① **只在「展开」这一刻定位**，不在展开期间持续定位 —— 否则 2s 轮询刷新 personas
+      //      会把用户手动翻到的位置拽回去。用 ref 记住「本次展开已定位过」。
+      //   ② **折叠时重置标记** —— 下次展开要重新定位（这正是需求本身）。
+      //   ③ **数据未就绪时不下手** —— personas 还在加载（null）时定位会误判成第 0 张，
+      //      等数据到了、effect 依赖变化会自然补上（标记此时仍为 false）。
+      const autoPositionedRef = React.useRef(false)
+      React.useEffect(() => {
+        if (openSection !== 'personas') {
+          // 折叠状态：清掉标记，让下次展开能重新定位。
+          //
+          // 刻意**不在这里**清翻面态：折叠期间 body 不渲染，翻面态在 UI 上不可观测，
+          // 清与不清行为等价（判断力验证证实：删掉它所有用例仍通过）。可观测的点是
+          // 「重新展开」那一刻，由下方 autoPositionedRef 分支的 setFlippedName(null)
+          // 承担 —— 职责归属唯一，避免两处重复同一件事、日后改动只更新一处。
+          autoPositionedRef.current = false
+          return
+        }
+        if (autoPositionedRef.current) return
+        if (!personaNames || personaNames.length === 0) return
+        // 当前无生效人设（或名字对不上任何一项）时退回第 0 张 —— 总要给个确定的落点
+        const at = activePersona ? personaNames.indexOf(activePersona) : -1
+        // 自动定位同样是一次「换一张看」：清掉翻面态，避免定位到的那张
+        // 恰好是上次翻过面的卡而以背面出现
+        setFlippedName(null)
+        setPersonaIndex(at >= 0 ? at : 0)
+        autoPositionedRef.current = true
+      }, [openSection, personaNames, activePersona])
       const aboutFilled = [localNickname, localOccupation, localBio].filter(Boolean).length
       const aboutSummary = aboutFilled > 0 ? `${aboutFilled}/3 ${t('accordion.filled')}` : t('accordion.empty')
       const traitsSummary = t(`style.${localStyle}`)
-      const personasSummary = personas === null ? t('status.loading') : `${Object.keys(personas).length} ${t('accordion.personas')}`
+      // 失败时摘要也要区分（折叠状态下用户只看得到这一行）
+      const personasSummary = personasError
+        ? t('accordion.loadFailed')
+        : (personas === null ? t('status.loading') : `${Object.keys(personas).length} ${t('accordion.personas')}`)
       const toolSummary = localToolConfirm ? t('accordion.on') : t('accordion.off')
       const promptSummary = promptText.length > 0
         ? t(promptIsDraft ? 'prompt.summaryDraft' : 'prompt.summaryChars', { n: String(promptText.length) })
@@ -1241,15 +1826,15 @@ window.__ModuleLoader__.load({
         setOpenSection(current => current === section ? null : section)
       }
 
-      // 预设行摘要：风格 + 昵称 + 所有「偏离默认值」的维度。
-      // 内置预设刻意不声明昵称等用户自有信息，所以它们只显示风格与维度差异——
-      // 这恰好也是比较两个预设时最需要看到的信息。
+      // 预设行摘要：风格 + 所有「偏离默认值」的人设维度。
+      // 预设只描述 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)
-        if (row.nickname) parts.push(row.nickname)
         for (const [field, allowed] of Object.entries(META_FIELD_VALUES)) {
           const value = row[field]
           if (!value || value === META_FIELD_DEFAULTS[field]) continue
@@ -1259,6 +1844,20 @@ window.__ModuleLoader__.load({
         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
+      }
+
       return e('div', { className: 'soul-section' },
         e('div', { className: 'soul-title-row' },
           e('h3', null, t('settings.title')),
@@ -1421,40 +2020,277 @@ window.__ModuleLoader__.load({
             onToggle: toggleSection('personas')
           },
             e('div', { className: 'soul-field' },
-              personaNames === null
+              // 加载失败优先于「加载中」：否则失败时界面永远停在加载态，与「还没有预设」无从区分
+              personasError
+                ? e('div', { className: 'soul-error' }, t('personas.loadFailed', { reason: personasError }))
+                : (personaNames === null
                 ? e('div', { className: 'soul-status' }, t('status.loading'))
                 : (personaNames.length === 0
                   ? e('div', { className: 'soul-status' }, t('personas.empty'))
-                  : e(Fragment, null,
-                    ...personaNames.map((name) => {
+                  : (() => {
+                    // —— 卡片堆叠轮播 ——
+                    // 一次只展示一张，左右各留一张做层叠露边。为什么用绝对定位 + transform：
+                    // 三张卡片共存于同一堆叠容器内，若走文档流则容器高度会随张数变化而跳动。
+                    const total = personaNames.length
+                    // 夹取索引：预设可能被删除、或列表刷新后变短，索引会越界。
+                    // 刻意不在 effect 里回写 state —— 那会多一次渲染，且「删除后该看哪张」
+                    // 本就有歧义，渲染时夹取即可保证不越界。
+                    const index = Math.min(Math.max(personaIndex, 0), total - 1)
+                    // 翻页时**同时清掉翻面态**：翻面是「看这张卡背面」的临时阅读动作，
+                    // 翻页是「换一张看」—— 用户的注意力已经重置。若记住它，切回来时
+                    // 这张卡会以背面出现，看起来像「它默认就是背面」（用户实测反馈）。
+                    const go = (next) => {
+                      setFlippedName(null)
+                      setPersonaIndex(Math.min(Math.max(next, 0), total - 1))
+                    }
+                    const renderCard = (name, offset) => {
                       const entry = personas[name] || {}
-                      // 内置预设不提供删除（后端也会拒绝），在 actions 区原删除按钮的
-                      // 位置显示「内置」标记，行宽因此不会跳动。
                       const builtin = !!entry.builtin
-                      return e('div', { className: 'soul-persona-row', key: name },
-                        e('span', { className: 'soul-persona-name' }, name === activePersona ? `★ ${name}` : name),
-                        e('span', { className: 'soul-persona-meta' }, personaRowMeta(entry)),
-                        e('span', { className: 'soul-persona-actions' },
-                          builtin && e('span', { className: 'soul-persona-badge' }, t('personas.builtin')),
-                          e('button', { type: 'button', className: 'soul-prompt-link', onClick: () => handleUsePersona(name) }, t('personas.use')),
-                          !builtin && e('button', { type: 'button', className: 'soul-prompt-link soul-persona-danger', onClick: () => handleDeletePersona(name) }, t('personas.delete'))
+                      const current = offset === 0
+                      // 只有当前卡能翻面（叠层两张不参与交互）
+                      const flipped = current && flippedName === name
+                      return e('div', {
+                        key: name,
+                        className: 'soul-persona-card',
+                        'data-offset': String(offset),
+                        'data-current': current ? 'true' : 'false',
+                        'data-builtin': builtin ? 'true' : 'false',
+                        'data-flipped': flipped ? 'true' : 'false',
+                        style: {
+                          // 叠层几何：当前张居中不动；±1 两张向左/右偏移并缩小。
+                          // 竖版卡牌宽 260px，偏移要足够大才能看出「左右两张卡」，
+                          // 太小会与当前卡重叠成一坨。92px 偏移 + 6% 缩小，叠层露出的
+                          // 是一条完整的卡边（约 40px 可见宽度）。
+                          //
+                          // ⚠️ 这个 transform 归**叠层偏移**所有，绝不可把翻转的
+                          // rotateY 写进来 —— 两者合成同一个 transform 字符串会让
+                          // 偏移几何变脆。翻转交给中间的 .soul-persona-flipper
+                          // （它有自己的 rotateY 0↔180，见 CSS），职责分离：
+                          // 卡片管「叠层位置」，flipper 管「翻到哪一面」。
+                          transform: `translateX(${offset * 92}px) translateY(${Math.abs(offset) * 10}px) scale(${1 - Math.abs(offset) * 0.06})`,
+                          zIndex: String(10 - Math.abs(offset)),
+                          // 叠层卡片压暗一点，形成前后景深（不能用 filter:brightness，
+                          // 那会连带把文字变灰、看起来像禁用态）
+                          opacity: offset === 0 ? '1' : '0.55'
+                        },
+                        // 非当前卡片不参与交互、也不让读屏念到（否则会念出重复内容）
+                        'aria-hidden': current ? undefined : 'true',
+                        ...(current ? {} : { onClick: () => go(index + offset) })
+                      },
+                        // —— 3D 翻转容器（中间层）——
+                        //
+                        // 为什么需要这一层：卡片的 transform 归**叠层偏移**所有
+                        // （translateX/translateY/scale 内联在卡片上），翻转的
+                        // rotateY(180deg) 必须落在**另一层**，否则两者要合成同一个
+                        // transform 字符串，偏移几何会随之变脆。
+                        // 现在职责分离：卡片管「叠层位置」，flipper 管「翻到哪一面」。
+                        e('div', { className: 'soul-persona-flipper', 'aria-hidden': undefined },
+                        e('div', {
+                          className: 'soul-persona-face soul-persona-face-front',
+                          // 翻到背面时正面要彻底退出交互与读屏（否则 Tab 会落到看不见的按钮上）
+                          'aria-hidden': flipped ? 'true' : undefined,
+                          ...(flipped ? { inert: '' } : {}),
+                          // 整面点击翻到卡背（用户期望：任意处点击都能翻面）。
+                          // ⚠️ 只对【当前卡】生效（current 条件）：叠层侧边卡的点击
+                          // 必须留给卡片的 go() 翻页 —— 否则点击先冒泡到 face 的
+                          // setFlippedName(侧边卡名)，再冒泡到卡片的 go() 翻页，
+                          // 翻页后它成了当前卡 ⇒ flippedName === 它 ⇒ 直接以背面
+                          // 姿态出现（用户实测：切下一个人设时自动翻面了）。
+                          // 面上的控件用 stopPropagation 自己接管：「使用」点了就该用，
+                          // 不能顺带翻面；「详情」的语义本来就是翻面，不拦（双保险）。
+                          // cursor 由 CSS 给整面（含插画区），提示可点。
+                          onClick: (current && !flipped) ? () => setFlippedName(name) : undefined
+                        },
+                          // 插画区（卡面主视觉）：**所有卡片都出图**。
+                          //
+                          // 内置预设：宿主按人设名返回 assets/personas/<名>.webp；
+                          // 自建预设：宿主返回专用默认贴图（调色板，与官方的鲸鱼区分
+                          // 「你自己配的」与「官方提供的」）。本版只做样式调整 ——
+                          // 允许用户上传本地图片作插画是后续版本功能。
+                          // 仍留 onError 兜底隐藏：路由不可用时退化为渐变底而非破图。
+                          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' }
+                            }),
+                            // 渐变遮罩：让压在图上的名称/摘要有足够对比度
+                            e('div', { className: 'soul-persona-art-veil', 'aria-hidden': true }),
+                            builtin && e('span', { className: 'soul-persona-badge' }, t('personas.builtin')),
+                            // 位置指示只出现在当前卡片上：左右露边的卡片若也显示「i / n」，
+                            // 三张会同时出现同一个计数，看起来像显示错误。
+                            current && e('span', { className: 'soul-persona-card-pos' }, `${index + 1} / ${total}`),
+                            // 名称与摘要压在图上
+                            e('div', { className: 'soul-persona-art-title' },
+                              e('span', { className: 'soul-persona-name' },
+                                e('span', { className: 'soul-persona-label' }, name === activePersona ? `★ ${name}` : name)
+                              ),
+                              e('div', { className: 'soul-persona-meta' }, personaRowMeta(entry))
+                            )
+                          ),
+                          e('div', { className: 'soul-persona-body' },
+                            // 效果栏：卡牌的核心信息（这个预设会怎么回答）
+                            e('div', { className: 'soul-persona-eff' }, personaEffectText(entry)),
+                            e('div', { className: 'soul-persona-actions' },
+                              // 当前生效的人设：按钮文字变「使用中」+ 描边式样式（区别于实心主色），
+                              // 一眼就能看出哪张卡是当前配置。名称前的 ★ 保留，双重标识互相强化。
+                              e('button', {
+                                type: 'button',
+                                className: name === activePersona ? 'soul-persona-action soul-persona-active' : 'soul-persona-action',
+                                onClick: (ev) => {
+                                  // 整面点击=翻面；点「使用」只想用预设，不能顺带翻面
+                                  ev?.stopPropagation()
+                                  void handleUsePersona(name)
+                                }
+                              }, name === activePersona ? t('personas.active') : t('personas.use')),
+                              // 「删除」已移到**卡背**（管理语境，与「返回」并排）——
+                              // 此前夹在「使用/详情」中间的 43px 窄条观感怪异（用户反馈），
+                              // 且自建卡三钮 vs 内置卡两钮导致两类卡观感不齐。
+                              // 现在两类卡正面都是「使用 + 详情」，完全一致。
+                              // 「详情」只在当前卡上出现（叠层两张不给点）。
+                              current && e('button', {
+                                type: 'button',
+                                className: 'soul-persona-action soul-persona-details',
+                                title: t('personas.details'),
+                                onClick: () => setFlippedName(name)
+                              }, t('personas.details'))
+                            )
+                          )
+                        ),
+                        // —— 背面（详情）——
+                        // 只读信息面：列全部维度 + customInstructions 全文。
+                        // 不放「使用/删除」按钮：这是阅读态，且实测卡背内容已占 370/372px，
+                        // 再放 36px 的按钮必然溢出（按钮留在正面即可，翻面后仍可返回）。
+                        e('div', {
+                          className: 'soul-persona-face soul-persona-face-back',
+                          'aria-hidden': flipped ? undefined : 'true',
+                          ...(flipped ? {} : { inert: '' }),
+                          // 整面点击返回正面（与正面「整面点击翻到背面」对称）。
+                          //
+                          // ⚠️ 必须排除「拖选文字」：卡背有 339 字可滚动全文，用户很可能
+                          // 拖选复制。拖选结束时会触发一次 click，若不判断就等于「一选就
+                          // 翻回去」。判据用 window.getSelection() 是否落在卡背内 ——
+                          // 有非折叠选区就说明这是一次选择操作，不返回。
+                          // 另外点击「删除」按钮时靠它的 stopPropagation 挡住（见下），
+                          // 否则删除确认会被返回动作打断。
+                          onClick: () => {
+                            if (!flipped) return
+                            const sel = globalThis.getSelection?.()
+                            if (sel && !sel.isCollapsed && sel.toString().trim() !== '') return
+                            setFlippedName(null)
+                          }
+                        },
+                          e('div', { className: 'soul-persona-back-head' },
+                            e('span', { className: 'soul-persona-back-name' }, name),
+                            builtin && e('span', { className: 'soul-persona-badge' }, t('personas.builtin'))
+                          ),
+                          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, personaDimLabel(entry, dim))
+                            ))
+                          ),
+                          e('div', { className: 'soul-persona-back-label' }, t('personas.customInstructions')),
+                          e('div', { className: 'soul-persona-fulltext' }, personaFullText(entry)),
+                          // 底部按钮行：「返回」+「删除」（仅自建卡）。
+                          // 「删除」从正面移到这里（用户反馈正面三钮拥挤、夹缝观感差）：
+                          // 背面是「查看 / 管理」语境，删除放这里语义顺；且底部本就是
+                          // 一行按钮，并排进来零高度成本。二次确认（armed 态 + 5s 超时）
+                          // 逻辑不变。
+                          e('div', { className: 'soul-persona-back-actions' },
+                            e('button', {
+                              type: 'button',
+                              className: 'soul-persona-action soul-persona-back-btn',
+                              // 整面点击=返回；「返回」自己就是返回，stopPropagation 只为
+                              // 语义清晰（避免同一动作触发两次 setState）
+                              onClick: (ev) => {
+                                ev?.stopPropagation()
+                                setFlippedName(null)
+                              }
+                            }, t('personas.flipBack')),
+                            !builtin && e('button', {
+                              type: 'button',
+                              className: pendingDelete === name
+                                ? 'soul-persona-action soul-persona-danger soul-persona-danger-armed'
+                                : 'soul-persona-action soul-persona-danger soul-persona-back-del',
+                              'data-armed': pendingDelete === name ? 'true' : 'false',
+                              title: t('personas.confirmDelete', { name }),
+                              // 必须 stopPropagation：卡背整面点击=返回，
+                              // 不挡住的话「确认删除」会被返回动作打断（翻回正面、看不到提示）
+                              onClick: (ev) => {
+                                ev?.stopPropagation()
+                                void handleDeletePersona(name)
+                              }
+                            }, pendingDelete === name ? t('personas.confirmDeleteShort') : t('personas.delete'))
+                          )
                         )
+                        )   // ← 关闭 .soul-persona-flipper
+                      )
+                    }
+                    const cards = []
+                    for (let offset = -1; offset <= 1; offset++) {
+                      const at = index + offset
+                      if (at < 0 || at >= total) continue
+                      cards.push(renderCard(personaNames[at], offset))
+                    }
+                    return e('div', { className: 'soul-persona-carousel' },
+                      e('div', { className: 'soul-persona-stack' }, ...cards),
+                      // 翻页 + 位置指示：一次只见一张，就必须给出「共几张 / 现在第几张」
+                      // 与可点的翻页入口 —— 列表本可一眼扫完，这几处是对该损失的补偿。
+                      e('div', { className: 'soul-persona-nav' },
+                        e('button', {
+                          type: 'button',
+                          className: 'soul-persona-navbtn',
+                          'data-dir': 'prev',
+                          disabled: index === 0,
+                          'aria-label': t('personas.prev'),
+                          onClick: () => go(index - 1)
+                        }, '‹'),
+                        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 === index ? 'true' : 'false',
+                            'aria-selected': i === index ? 'true' : 'false',
+                            'aria-label': `${n}（${i + 1}/${total}）`,
+                            onClick: () => go(i)
+                          }))
+                        ),
+                        e('button', {
+                          type: 'button',
+                          className: 'soul-persona-navbtn',
+                          'data-dir': 'next',
+                          disabled: index === total - 1,
+                          'aria-label': t('personas.next'),
+                          onClick: () => go(index + 1)
+                        }, '›')
                       )
-                    })
-                  ))
+                    )
+                  })())
+                )
             ),
-            e('div', { className: 'soul-field soul-persona-save' },
-              e('input', {
-                type: 'text',
-                value: personaName,
-                maxLength: 30,
-                onChange: (ev) => setPersonaName(ev.target.value),
-                placeholder: t('personas.savePlaceholder')
-              }),
-              e(ui.Button, {
-                onClick: handleSavePersona,
-                disabled: saving || !personaName.trim()
-              }, t('personas.save'))
+            // —— 「已偏离任何预设」的出口 ——
+            //
+            // 每个内置预设现在都声明全部 6 个人格维度，所以**改任何特质都会丢 ★**
+            // （不再匹配任何预设）。这是个诚实但**没有出路**的状态：用户刚调出来的
+            // 这套配置无处安放。这里给一个明确落点：一句话说明 + 直接打开命名弹层存为新预设。
+            //
+            // 判据：activePersona === null（不匹配任何预设）且 personas 已就绪
+            // （加载中/失败不算偏离）。全部为默认值时命中的是「默认」预设，
+            // activeName 不为 null，不会走到这里。
+            (activePersona === null && personaNames !== null && !personasError) && e('div', { className: 'soul-drift' },
+              e('span', { className: 'soul-drift-text' }, t('personas.drift')),
+              e('button', {
+                type: 'button',
+                className: 'soul-drift-action',
+                onClick: () => { setPersonaName(''); setShowSavePersona(true) }
+              }, t('personas.driftAction'))
             ),
             e('div', { className: 'soul-status' }, t('personas.hint'))
           ),
@@ -1542,9 +2378,10 @@ window.__ModuleLoader__.load({
                 )
               ),
               e('div', { className: 'soul-field' },
-                e('label', null, t('trail.preview')),
+                // 预览示例不是表单控件，没有可关联的 id —— 用 label 会是「指向空的标签」，
+                // 所以改用同风格的 div（样式见 .soul-field-label）
+                e('div', { className: 'soul-field-label' }, t('trail.preview')),
                 e(SoulTrailPreview, {
-                  enabled: localTrailEnabled,
                   color: localTrailColor,
                   speed: localTrailSpeed,
                   width: localTrailWidth,
@@ -1570,7 +2407,7 @@ window.__ModuleLoader__.load({
                 e('pre', { className: 'soul-prompt-pre' }, promptText || t('prompt.empty')),
                 e('div', { className: 'soul-status' }, t('prompt.chars', { n: String(promptText.length) })),
                 promptInvalid.length > 0 && e('div', { className: 'soul-error' },
-                  t('prompt.invalid', { fields: promptInvalid.join('、') }))
+                  t('prompt.invalid', { fields: promptInvalid.join(t('common.listSep')) }))
               ))
         ),
 
@@ -1582,20 +2419,92 @@ window.__ModuleLoader__.load({
             onClick: handleSave,
             disabled: saving || !dirty
           }, saving ? t('button.saving') : t('button.save')),
+          // 方案 A：「保存当前为预设」从预设列表移到这里，与「保存设置」并列为同级动作。
+          // 两个保存动作放在一起，差异一眼可见（就地生效 vs 另存一份），
+          // 且按钮就贴在刚编辑过的表单旁 ⇒ 用户自然理解「存的是我刚才编的」。
+          e(ui.Button, {
+            onClick: () => { setPersonaName(''); setShowSavePersona(true) },
+            disabled: saving
+          }, t('personas.saveAs')),
           e(ui.Button, {
             onClick: handleReset,
             disabled: saving
           }, t('button.reset'))
         ),
 
+        // ——「存为新预设」命名弹层 ——
+        // 点开才问名字（而不是原先「先填名字、按钮才可点」的别扭顺序），
+        // 并**明确列出会保存什么 / 不会保存什么** —— 这直接消灭了
+        // 「不知道到底存了哪些值」这个困惑。
+        showSavePersona && e('div', {
+          className: 'soul-modal-mask',
+          role: 'presentation',
+          onClick: () => { setShowSavePersona(false); setPersonaName('') }
+        },
+          e('div', {
+            className: 'soul-modal',
+            role: 'dialog',
+            'aria-modal': 'true',
+            'aria-label': t('personas.saveAs'),
+            onClick: (ev) => ev.stopPropagation()
+          },
+            e('div', { className: 'soul-modal-title' }, t('personas.saveAs')),
+            e('div', { className: 'soul-field' },
+              e('label', { htmlFor: 'soul-new-persona-name' }, t('personas.saveNameLabel')),
+              e('input', {
+                id: 'soul-new-persona-name',
+                type: 'text',
+                value: personaName,
+                maxLength: 30,
+                placeholder: t('personas.savePlaceholder'),
+                onChange: (ev) => setPersonaName(ev.target.value),
+                onKeyDown: (ev) => {
+                  if (ev.key === 'Enter' && personaName.trim() && !saving) void handleSavePersona()
+                  if (ev.key === 'Escape') { setShowSavePersona(false); setPersonaName('') }
+                }
+              })
+            ),
+            e('div', { className: 'soul-modal-note' },
+              e('div', null, t('personas.saveCovers')),
+              e('div', { className: 'soul-modal-note-excl' }, t('personas.saveExcludes'))
+            ),
+            e('div', { className: 'soul-modal-actions' },
+              e(ui.Button, {
+                onClick: () => { setShowSavePersona(false); setPersonaName('') }
+              }, t('button.cancel')),
+              e(ui.Button, {
+                variant: 'primary',
+                onClick: handleSavePersona,
+                disabled: saving || !personaName.trim()
+              }, saving ? t('button.saving') : t('personas.saveConfirm'))
+            )
+          )
+        ),
+
         dirty && !saving && e('div', { className: 'soul-status soul-dirty' }, t('status.unsaved')),
 
-        toast && e('div', {
-          className: `soul-toast ${toast.kind === 'error' ? 'soul-toast-error' : 'soul-toast-success'}`,
-          style: {
-            animation: 'fadeInOut 2s ease-in-out'
-          }
-        }, toast.text)
+        // —— 内联结果提示（对齐宿主模型设置页的全局形态）——
+        //
+        // 查证（dsh-client-ui-settings-models/lib/client.js）：宿主设置页**从不使用
+        // toast**（Toast 引用 = 0），成功与失败都是设置页内的**一行内联文字**：
+        //   成功 → .savedNotice（state-success-primary 绿、12px/18px、role:status +
+        //          aria-live:polite），位于标题/简介之后、分组列表之前；
+        //   失败 → .error（state-error-primary 红、12px/18px、role:alert），
+        //          就地出现在问题发生处（行内/卡片顶部），共 11 处使用。
+        // 两者同字号同行高，仅红绿与 role 之差 —— 完全对称。
+        //
+        // 因此这里对称承载：绿字（成功）/ 红字（失败），同一位置、互斥显示
+        // （失败压过成功 —— 用户要看到最新一次操作的结果）。两者都不自动消失：
+        // 绿字在开始编辑（dirty）时清除，红字在下一次操作开始时被替换或清除。
+        errorNotice && e('p', {
+          className: 'soul-error-notice',
+          role: 'alert'
+        }, errorNotice),
+        !errorNotice && savedNotice && e('p', {
+          className: 'soul-saved-notice',
+          role: 'status',
+          'aria-live': 'polite'
+        }, savedNotice)
       )
     }
 
@@ -1605,33 +2514,29 @@ window.__ModuleLoader__.load({
 
     // 设置页内的实时示例：与线上光轨共用同一渲染层、同一挂载点解析（resolveTrailMountPoint）
     // 与同一份 CSS，因此「示例所见」即「回复时所得」；颜色/速度/粗细随表单实时联动。
+    //
+    // 本组件**只在光轨开启时**被渲染（见调用处的 `localTrailEnabled &&`），所以它没有
+    // 「关闭」这一态：此前它接了一个 `enabled` prop 并写了 off 分支，那是永不执行的死
+    // 代码（且 `data-soul-trail="off"` 会连带影响 CSS 选择器），现在去掉。
     function SoulTrailPreview(props) {
       const t = typeof props.t === 'function' ? props.t : FALLBACK_T
       const hostRef = React.useRef(null)
       const anchorRef = React.useRef(null)
-      const mountedRef = React.useRef(null)
 
       React.useEffect(() => {
         const host = hostRef.current
         if (!host) return undefined
         // 与线上 SoulTrail 同一条路径：解析出的挂载点即示例内的零高度锚点 .soul-trail-anchor
         const mounted = mountTrailRing(host, resolveTrailMountPoint(host, anchorRef.current))
-        mountedRef.current = mounted
-        return () => {
-          mountedRef.current = null
-          mounted.unmount()
-        }
+        // 环的内联样式以 display:none 起（见 mountTrailRing），必须显式显形一次
+        mounted.setVisible(true)
+        return () => mounted.unmount()
       }, [])
 
-      React.useEffect(() => {
-        const mounted = mountedRef.current
-        if (mounted) mounted.setVisible(props.enabled !== false)
-      }, [props.enabled])
-
       return e('div', {
         ref: hostRef,
         className: 'soul-trail-preview',
-        'data-soul-trail': props.enabled ? 'on' : 'off',
+        'data-soul-trail': 'on',
         'data-soul-trail-speed': props.speed || 'slow',
         'data-soul-trail-width': props.width || 'thin',
         style: { '--soul-trail-color': safeTrailColor(props.color) }
@@ -1716,6 +2621,36 @@ window.__ModuleLoader__.load({
       }, 'dsh-soul: browser lifecycle')
       ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-soul: dictionaries')
 
+      // —— 全局轮询：让**不打开设置页**时底栏也能跟上宿主侧的变化 ——
+      //
+      // 修掉的 bug：用户用 /soul confirm 确认人设变更后，宿主已写盘（配置文件正确），
+      // 但底栏「个性化已启用 · 人设名」仍显示旧值。根因是三条刷新路径
+      // （setInterval / focus / visibilitychange）**全部注册在 SoulSettings 组件内**，
+      // 设置页没挂载时它们都不存在 ⇒ 底栏读的 store 无人刷新。
+      //
+      // 底栏（conversation.input.left）是常驻组件，它的数据链路不该依赖另一个
+      // 组件的生命周期。放到装配层后：注册一次、全生命周期有效，且天然只有一份
+      // 定时器（不会与设置页的重复 ⇒ 请求翻倍）。
+      ctx.effect(() => {
+        const refresh = () => {
+          // 页面不可见时不轮询：后台标签页不必发请求
+          if (document.visibilityState !== 'visible') return
+          // 有未保存编辑时暂停（由设置页置位）—— 否则会把用户正在改的值拽回去
+          if (!controller.canRefresh()) return
+          void controller.loadConfig()
+          void controller.loadPersonas()
+        }
+        refresh()
+        window.addEventListener('focus', refresh)
+        document.addEventListener('visibilitychange', refresh)
+        const timer = setInterval(refresh, 2000)
+        return () => {
+          window.removeEventListener('focus', refresh)
+          document.removeEventListener('visibilitychange', refresh)
+          clearInterval(timer)
+        }
+      }, 'dsh-soul: global refresh polling')
+
       // 暗色适配说明：原生 <select> 的弹出选项列表由浏览器按 color-scheme 渲染。
       // 宿主主题呈现器会把 html 的 color-scheme 与 body[data-ds-dark-theme] 随主题
       // 投影到 document（见 dsh-client-ui-layout ThemePresenter），因此这里用纯 CSS
@@ -1799,6 +2734,9 @@ window.__ModuleLoader__.load({
 
       const registerSettingsNavIcon = () => {
         let disposed = false
+        // 改画前记下宿主 svg 的原始子节点：此前卸载时只清 marker 属性、不还原内容，
+        // 于是禁用插件 / HMR 之后导航栏仍显示插件图标，直到壳层重建那个按钮。
+        const originalIcons = new Map()
 
         const sync = () => {
           if (disposed) return
@@ -1817,6 +2755,7 @@ window.__ModuleLoader__.load({
               if (existingIcon) {
                 // 标记已替换；React 重建按钮时标记随之消失，会重新画一次
                 button.setAttribute(SOUL_ICON_MARKER, 'true')
+                originalIcons.set(existingIcon, Array.from(existingIcon.childNodes))
                 paintSoulNavIcon(existingIcon)
               }
             } else {
@@ -1827,14 +2766,24 @@ window.__ModuleLoader__.load({
 
         // 延迟执行初始同步，等待设置页面渲染完成
         let timer = setTimeout(sync, 500)
+        // 最长等待：防抖只该合并「一连串变化」，不该被无限推迟 —— 会话流式输出时
+        // body 每帧都在变，纯 100ms 防抖会让 sync 永远排不到（图标一直不替换）。
+        const MAX_WAIT_MS = 600
+        let pendingSince = 0
 
         // 监听 DOM 变化（只监听子节点添加，不监听所有变化）
         const observer = new MutationObserver(() => {
           // 防抖：每次变化都重置计时器，停止变化 100ms 后执行
           // （修复：此前新计时器未赋回 timer，clearTimeout 永远只清除首个 500ms
           // 计时器，防抖实际失效，每次 DOM 变化都会调度一次 sync）
+          const now = Date.now()
+          if (!pendingSince) pendingSince = now
           clearTimeout(timer)
-          timer = setTimeout(sync, 100)
+          const waited = now - pendingSince
+          timer = setTimeout(() => {
+            pendingSince = 0
+            sync()
+          }, waited >= MAX_WAIT_MS ? 0 : 100)
         })
 
         observer.observe(document.body, {
@@ -1846,6 +2795,11 @@ window.__ModuleLoader__.load({
           disposed = true
           clearTimeout(timer)
           observer.disconnect()
+          // 先还原图标内容，再清 marker：顺序反了会留下「无标记但已被改画」的节点
+          for (const [svg, nodes] of originalIcons) {
+            if (svg && typeof svg.replaceChildren === 'function') svg.replaceChildren(...nodes)
+          }
+          originalIcons.clear()
           document.querySelectorAll(`[${SOUL_NAV_MARKER}]`).forEach((element) => {
             element.removeAttribute(SOUL_NAV_MARKER)
           })
@@ -1872,6 +2826,7 @@ window.__ModuleLoader__.load({
         })
       }, SoulQuickToggle))
 
+
       // 输入框光轨：注册到输入框卡片内部的 overlay 槽位。
       // 组件不渲染可见内容——它按会话运行态在最近的输入框卡片上挂载/隐藏 SVG 环；
       // 同一份 soulController store 保证与设置页的开关、颜色实时一致。
@@ -1901,8 +2856,8 @@ window.__ModuleLoader__.load({
         })
       }, SoulSettings))
 
-      // 加载初始配置
-      controller.loadConfig()
+      // 初始配置的拉取已并入上面的全局轮询 —— 它的 refresh() 在注册时立即执行一次
+      // （含 loadConfig + loadPersonas），这里再调一次就是同一次装配发两个相同请求。
     }
 
     exports.apply = apply