dsh-soul 0.7.1 → 0.7.2

package/scripts/verify-client.mjs

@@ -26,7 +26,7 @@ import { assertCount } from './lib/skip-report.mjs'
 
 // 基线运行应跑出的断言数。本脚本没有环境相关跳过（客户端源码与 Node 都在），
 // 所以链里的 `--strict` 对它无额外语义；数字由下面的 assertCount 守住。
-const EXPECTED_ASSERTIONS = 17
+const EXPECTED_ASSERTIONS = 23
 
 const source = readFileSync(new URL('../client/index.mjs', import.meta.url), 'utf8')
 
@@ -129,6 +129,20 @@ function createRuntime() {
     React,
     jsx,
     Fragment,
+    /**
+     * 卸载：执行所有已注册 effect 的清理函数。
+     *
+     * 为什么需要：垫片原先只在**依赖变化**时跑清理（见 settle 里的 previous()），
+     * 组件卸载时从不执行 —— 于是「卸载时必须复位某状态」这类契约在测试台里根本
+     * 无法触发（判断力验证实测：变异「卸载不复位 paused」漏网，底栏会永久停摆）。
+     * 这不是产品缺陷而是测试台能力缺口，故补在这里。
+     */
+    unmount() {
+      for (const fn of cleanups.values()) if (typeof fn === 'function') fn()
+      cleanups.clear()
+      dirty = false
+      queue = []
+    },
     /** 渲染 + 跑本轮 effect，直到状态不再变化（含 effect / handler 里已 resolve 的 promise）。 */
     async settle(root) {
       for (let pass = 0; pass < 40; pass++) {
@@ -172,6 +186,20 @@ function findAll(tree, predicate) {
   return hits
 }
 
+/**
+ * 按**类名 token 精确匹配**取元素。
+ *
+ * 不要用 `className.includes('soul-persona-card')` 这种子串匹配：它同时命中
+ * `soul-persona-card-head`、`soul-persona-card-pos` —— 实测导致「2 张卡片」被数成
+ * 6 个节点（每个卡片还带着两个同前缀的子元素），断言报出误导性的「渲染了 6 张」。
+ */
+function findAllByClass(tree, cls) {
+  return findAll(tree, (n) => {
+    const c = n.props?.className
+    return typeof c === 'string' && c.split(/\s+/).includes(cls)
+  })
+}
+
 // ==================== 三、沙箱：假 window / document / 定时器 / fetch ====================
 
 const realTimers = {
@@ -233,7 +261,7 @@ function loadClient(routes) {
   })
   const windowStub = {
     __ModuleLoader__: { load: (m) => { factory = m.factory } },
-    addEventListener() {},
+    addEventListener: (type) => { captured.events.window.push(type) },
     removeEventListener() {},
     location: { origin: 'http://dsh.test' }
   }
@@ -241,7 +269,7 @@ function loadClient(routes) {
     visibilityState: 'visible',
     body: domNode(),
     head: domNode(),
-    addEventListener() {},
+    addEventListener: (type) => { captured.events.document.push(type) },
     removeEventListener() {},
     // 插件在装配时会把样式表插到 head（用 querySelector 判重），导航图标那一层还会
     // 挂 MutationObserver —— 这里只需让这些调用成立；本脚本断言的是行为，不是 DOM。
@@ -276,9 +304,10 @@ function loadClient(routes) {
     if (spec === 'react') return runtime.React
     if (spec === 'react/jsx-runtime') return { jsx: runtime.jsx, jsxs: runtime.jsx, Fragment }
     if (spec === '@deepseek-ai/dsh-client-ui-primitives') {
-      // ui.Button 单独换成宿主元素标记：这样它连同 onClick / children 原样留在渲染树里，
-      // 断言就能像用户一样「找到那个按钮并点它」，而不是去猜某个闭包。
-      return { Button: 'ui-button' }
+      // ui.Button / ui.Toast 单独换成宿主元素标记：这样它们连同 onClick / text /
+      // tone / holdMs / onDone 原样留在渲染树里，断言就能像用户一样
+      // 「找到那个按钮并点它」、「读出提示条的文案与色调」，而不是去猜某个闭包。
+      return { Button: 'ui-button', Toast: 'ui-toast' }
     }
     throw new Error(`未预料的 require：${spec}`)
   }
@@ -286,7 +315,10 @@ function loadClient(routes) {
   new Function('window', source)(windowStub)
   const module = factory(requireStub)
 
-  const captured = { provide: {}, sections: [], dicts: null, runtime }
+  // events：window/document 上注册过的事件名。用于断言「轮询与页面级监听挂在
+  // **装配层**」—— 此前它们全在 SoulSettings 组件内，设置页没挂载时全部失效
+  // （底栏人设名因此不刷新）。stub 原本是空实现，这里让它可观测。
+  const captured = { provide: {}, sections: [], dicts: null, runtime, events: { window: [], document: [] } }
   const ctx = {
     provide: (name, value) => { captured.provide[name] = value },
     effect: (fn) => { const dispose = fn(); if (typeof dispose === 'function') captured.sections.push({ dispose }) },
@@ -401,12 +433,16 @@ async function clickButton(world, labelKey) {
   assert.equal(buttons.length, 1, `期望恰好一个「${label}」按钮，实际 ${buttons.length} 个`)
   await buttons[0].props.onClick()
   const after = await renderSettings(world)
-  const toasts = findAll(after, (n) => typeof n.props?.className === 'string' && n.props.className.includes('soul-toast'))
-  assert.equal(toasts.length, 1, `期望恰好一个 toast，实际 ${toasts.length} 个`)
-  return {
-    text: textOf(toasts[0]),
-    kind: toasts[0].props.className.includes('soul-toast-error') ? 'error' : 'success'
+  // 提示形态对齐宿主模型设置页：成功走内联绿字（.soul-saved-notice，role=status）、
+  // 失败走内联红字（.soul-error-notice，role=alert）—— 宿主设置页从不使用 toast。
+  const notices = findAll(after, (n) => typeof n.props?.className === 'string' && n.props.className.includes('soul-saved-notice'))
+  if (notices.length > 0) {
+    assert.equal(notices.length, 1, `期望恰好一条成功绿字，实际 ${notices.length} 条`)
+    return { text: textOf(notices[0]), kind: 'success' }
   }
+  const errs = findAll(after, (n) => typeof n.props?.className === 'string' && n.props.className.includes('soul-error-notice'))
+  assert.equal(errs.length, 1, `期望恰好一条失败红字，实际 ${errs.length} 条`)
+  return { text: textOf(errs[0]), kind: 'error' }
 }
 
 // ==================== 五、用例 ====================
@@ -505,7 +541,7 @@ try {
     const toast = await clickButton(world, 'button.reset')
     assert.equal(toast.kind, 'error', `重置失败的提示应为错误样式，实际 ${toast.kind}`)
     assert.equal(toast.text, world.dicts.zh['toast.resetFailed'])
-    assert.notEqual(toast.text, world.dicts.zh['toast.reset'])
+    assert.notEqual(toast.text, world.dicts.zh['notice.reset'])
   })
 
   await check('C9 重置成功且丢弃过损坏文件时，提示「已备份」（而不是普通的「已重置」）', async () => {
@@ -515,14 +551,14 @@ try {
     })
     const toast = await clickButton(world, 'button.reset')
     assert.equal(toast.kind, 'success')
-    assert.equal(toast.text, world.dicts.zh['toast.resetRecovered'])
+    assert.equal(toast.text, world.dicts.zh['notice.resetRecovered'])
   })
 
   await check('C10 普通重置只提示「已重置」，且不留残余的送达警告', async () => {
     const world = await boot({ deliveryWarning: '旧的送达警告' })
     world.routes['/api/soul/config/reset'] = () => ({ ok: true, config: { ...CONFIG }, changed: [], backupPath: null })
     const toast = await clickButton(world, 'button.reset')
-    assert.equal(toast.text, world.dicts.zh['toast.reset'])
+    assert.equal(toast.text, world.dicts.zh['notice.reset'])
     assert.equal(world.controller.store.getSnapshot().error, null, '重置后不应残留上一轮的送达警告')
   })
 
@@ -534,7 +570,7 @@ try {
     const toast = await clickButton(world, 'button.save')
     assert.equal(toast.kind, 'error')
     assert.equal(toast.text, world.dicts.zh['toast.saveFailed'])
-    assert.notEqual(toast.text, world.dicts.zh['toast.noChanges'])
+    assert.notEqual(toast.text, world.dicts.zh['notice.noChanges'])
   })
 
   await check('C12 设置页真的渲染出可点的保存 / 重置按钮（断言不是对着空树跑）', async () => {
@@ -632,7 +668,7 @@ try {
     )
   })
 
-  await check('C16 人设行真的按宿主协议渲染，且「当前生效」预设带 ★ 标记', async () => {
+  await check('C16 人设卡片按宿主协议渲染：★ 生效标记、内置徽标、卡片堆叠与翻页', async () => {
     // 这条补的是一个**覆盖空洞**：此前桩返回 `{ personas: [], activePersona: null }`
     // （字段名与类型都与宿主不符），于是人设行渲染与 ★ 标记从未被执行过 —— 把桩改成
     // 真实形状后，整套 C 系列仍全绿（实测），说明没有任何断言吃过这份数据。
@@ -659,24 +695,607 @@ try {
       'activeName 未被写进 store.activePersona —— 字段名与宿主协议不符'
     )
 
-    // ② 两行都渲染出来，且 line 文本各自完整
-    const rows = findAll(tree, (n) => typeof n.props?.className === 'string' && n.props.className.includes('soul-persona-row'))
-    assert.equal(rows.length, 2, `应渲染两行预设，实际 ${rows.length}`)
-    const rowText = rows.map(textOf)
+    // ② 卡片堆叠一次只渲染限定张数（当前 + 左右各一），当前张带 data-current="true"
+    const cards = findAllByClass(tree, 'soul-persona-card')
+    assert.equal(cards.length, 2, `两个预设应渲染 2 张卡片（左右无更多），实际 ${cards.length}`)
+    const current = cards.filter((c) => c.props['data-current'] === 'true')
+    assert.equal(current.length, 1, `应恰好一张当前卡片，实际 ${current.length}`)
+
+    const cardText = cards.map(textOf)
+    const activeCard = cardText.find((t2) => t2.includes('我的自建'))
+    const idleCard = cardText.find((t2) => t2.includes('苏格拉底式提问者'))
+    assert.ok(activeCard, `未渲染「我的自建」卡片：${cardText.join(' | ')}`)
+    assert.ok(idleCard, `未渲染「苏格拉底式提问者」卡片：${cardText.join(' | ')}`)
 
     // ③ 生效预设带 ★，非生效的不带（防空过：两个方向都要断言，否则「恒加★」也会过）
-    const activeRow = rowText.find((t) => t.includes('我的自建'))
-    const idleRow = rowText.find((t) => t.includes('苏格拉底式提问者'))
-    assert.ok(activeRow, `未渲染「我的自建」行：${rowText.join(' | ')}`)
-    assert.ok(idleRow, `未渲染「苏格拉底式提问者」行：${rowText.join(' | ')}`)
-    assert.ok(activeRow.includes('★'), `生效预设应带 ★：${activeRow}`)
-    assert.ok(!idleRow.includes('★'), `非生效预设不应带 ★：${idleRow}`)
-
-    // ④ 内置行带「内置」标记、且不渲染删除按钮；自建行相反
-    assert.ok(idleRow.includes(world.dicts.zh['personas.builtin']), `内置行应带「内置」标记：${idleRow}`)
-    assert.ok(!activeRow.includes(world.dicts.zh['personas.builtin']), `自建行不应带「内置」标记：${activeRow}`)
+    assert.ok(activeCard.includes('★'), `生效预设应带 ★：${activeCard}`)
+    assert.ok(!idleCard.includes('★'), `非生效预设不应带 ★：${idleCard}`)
+
+    // ④ 内置卡片带「内置」标记、且不渲染删除按钮；自建卡片相反
+    assert.ok(idleCard.includes(world.dicts.zh['personas.builtin']), `内置卡片应带「内置」标记：${idleCard}`)
+    assert.ok(!activeCard.includes(world.dicts.zh['personas.builtin']), `自建卡片不应带「内置」标记：${activeCard}`)
     const deleteButtons = findAll(tree, (n) => n.type === 'button' && textOf(n) === world.dicts.zh['personas.delete'])
-    assert.equal(deleteButtons.length, 1, `只应有一个删除按钮（内置行不得有），实际 ${deleteButtons.length}`)
+    assert.equal(deleteButtons.length, 1, `只应有一个删除按钮（内置卡片不得有），实际 ${deleteButtons.length}`)
+
+    // ⑤ 轮播交互：位置指示、圆点、翻页按钮与边界禁用（一次只见一张，这些是必需的补偿）
+    //
+    // 注意：**展开分组时轮播会自动定位到当前生效的那张**（新功能），因此这里一进来
+    // 就已经停在「我的自建」（数组第 2 项 ⇒ 索引 1），而不是首张。位置指示应为 2 / 2。
+    const nav = findAllByClass(tree, 'soul-persona-navbtn')
+    assert.equal(nav.length, 2, `应有前后两个翻页按钮，实际 ${nav.length}`)
+    const pos0 = findAllByClass(tree, 'soul-persona-card-pos')
+    assert.equal(pos0.length, 1, `当前卡片应显示位置指示（i / n），实际 ${pos0.length}`)
+    const [prev, next] = nav
+    assert.equal(textOf(pos0[0]), '2 / 2', `展开后应定位到生效项（末张），位置指示应为「2 / 2」，实际「${textOf(pos0[0])}」`)
+    assert.equal(prev.props.disabled, false, '已定位到末张时「上一张」应可用')
+    assert.equal(next.props.disabled, true, '已定位到末张时「下一张」应禁用')
+    const dots = findAllByClass(tree, 'soul-persona-dot')
+    assert.equal(dots.length, 2, `圆点数量应等于预设数，实际 ${dots.length}`)
+    assert.equal(dots.filter((d) => d.props['data-active'] === 'true').length, 1, '应恰好一个圆点为激活态')
+    // 激活的圆点必须是生效项那个索引（1），而不是恒为第 0 个
+    assert.equal(dots[1].props['data-active'], 'true', '激活圆点应落在生效项（索引 1）上')
+    assert.equal(dots[0].props['data-active'], 'false', '非生效项的圆点不应是激活态')
+
+    // ⑥ 点「上一张」→ 索引前移，位置指示与当前卡片内容同步变化
+    const posBefore = textOf(findAllByClass(tree, 'soul-persona-card-pos')[0])
+    const textBefore = textOf(current[0])
+    await prev.props.onClick()
+    const tree2 = await renderSettings(world)
+    const cur2 = findAllByClass(tree2, 'soul-persona-card').filter((c) => c.props['data-current'] === 'true')
+    assert.equal(cur2.length, 1, '翻页后仍应恰好一张当前卡片')
+    const posAfter = textOf(findAllByClass(tree2, 'soul-persona-card-pos')[0])
+    assert.notEqual(posAfter, posBefore, `位置指示应随翻页变化（翻页前后都是「${posAfter}」）`)
+    assert.notEqual(textOf(cur2[0]), textBefore, '当前卡片内容应随翻页变化')
+    // 位置指示与当前卡片必须是同一个预设（防止「指示变了但卡片没换」）。
+    // 不硬编码名字与序号的对应关系 —— 顺序由 store 决定，从「翻页前那张」推导即可：
+    // 翻页后指示从 i/2 变成 j/2，卡片内容必须是**另一张**，且两张合起来正好是两个预设。
+    const allNames = ['我的自建', '苏格拉底式提问者']
+    const shown = [textBefore, textOf(cur2[0])]
+    for (const n of allNames) {
+      assert.equal(
+        shown.filter((t2) => t2.includes(n)).length,
+        1,
+        `「${n}」应在翻页前后各出现恰好一次，实际出现在：${shown.map((s) => s.slice(0, 26)).join(' | ')}`
+      )
+    }
+    // 翻到首张后「上一张」应禁用（边界）
+    const nav2 = findAllByClass(tree2, 'soul-persona-navbtn')
+    assert.equal(nav2[0].props.disabled, true, '翻到首张后「上一张」应禁用')
+  })
+
+  await check('C19 应用预设后表单必须跟随 store，保存按钮不得误亮', async () => {
+    // 用户实测：点「使用」显示正常，但「保存设置」亮起；一点保存，刚应用的预设
+    // 被本地旧表单整体覆盖回旧配置（activeName 变回默认）。
+    //
+    // 根因：回填 effect 原是「dirty || saving 就整体不回填」。应用预设后 store 先变、
+    // 本地表单还是旧值 ⇒ 那一次渲染 dirty 恒为 true ⇒ 回填被挡 ⇒ 表单停在旧值 ⇒
+    // 「保存」把旧值整体 POST 上去覆盖预设。
+    //
+    // 修法：按字段判断（本地值 == 上次同步快照 ⇒ 用户没动过 ⇒ 回填）。
+    // 本断言验证行为：应用预设后（未手改任何字段）dirty 必须为 false。
+    const world = await boot({}, {
+      ok: true,
+      personas: {
+        苏格拉底式提问者: { style: 'professional', builtin: true },
+        资深架构师: { style: 'professional', headingLists: 'more', tables: 'more', replyLength: 'detailed', builtin: true }
+      },
+      activeName: '苏格拉底式提问者'
+    })
+    // 找到「使用」按钮所在卡（资深架构师）并应用它 —— 用卡片按钮而不是直接调 controller，
+    // 这样测的是用户真实路径（handleUsePersona → store → 回填 effect）。
+    // 注意：「人设预设」分组默认折叠，必须先展开（与 C16 同样的前置）。
+    //
+    // boot 默认桩没有 /personas/use 路由（点了会 404、被 catch 吞掉、store 不变），
+    // 那样本断言会得到「保存按钮不亮」的**假阳性** —— 所以这里覆盖该路由，
+    // 让它返回真实的「应用预设后的完整配置」（宿主行为：usePersona 会改活动配置）。
+    // 同时 GET /config 也必须跟随 —— 否则 2s 轮询会把 store 打回旧值；
+    // 真实宿主的 GET /config 本来就返回当前配置，测试桩此前没有模拟这一点。
+    let appliedPersona = false
+    const appliedConfig = () => ({ ...CONFIG, headingLists: 'more', tables: 'more', replyLength: 'detailed' })
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+      ? { ok: true, config: appliedPersona ? appliedConfig() : { ...CONFIG }, configError: null, deliveryWarning: null }
+      : { ok: true, config: { ...CONFIG }, changed: [] })
+    world.routes['/api/soul/personas/use'] = () => {
+      appliedPersona = true
+      return { ok: true, config: appliedConfig(), changed: ['headingLists', 'tables', 'replyLength'], invalid: [] }
+    }
+    const tree0 = await renderSettings(world)
+    const trigger0 = findAll(tree0, (n) => n.type === 'button' && textOf(n).includes(world.dicts.zh['group.personas']))
+    await trigger0[0].props.onClick()
+    const treeOpen = await renderSettings(world)
+    const useBtns = findAll(treeOpen, (n) => n.type === 'button' && textOf(n) === world.dicts.zh['personas.use'])
+    assert.ok(useBtns.length >= 1, '应存在「使用」按钮（前置条件）')
+    // 资深架构师与苏格拉底式提问者的 style 相同但 headingLists/tables/replyLength 不同，
+    // 应用后 store 的这些字段必然变化 —— 足以检验回填。
+    // 点按钮是 fire-and-forget（handleUsePersona 内部 await），必须排空微任务，
+    // store 才会被 usePersona 的响应写入（排空后还要再排空一次：写入触发的渲染链）。
+    await useBtns[useBtns.length - 1].props.onClick()
+    for (let i = 0; i < 10; i++) await new Promise((r) => drainTick(r))
+    const tree1 = await renderSettings(world)
+    // ① 保存按钮必须**不亮**（disabled）—— 用户什么都没改
+    const saveBtn = findAll(tree1, (n) => n.type === 'ui-button' && textOf(n) === world.dicts.zh['button.save'])
+    assert.equal(saveBtn.length, 1, `应恰好一个「保存设置」按钮，实际 ${saveBtn.length}`)
+    assert.equal(
+      saveBtn[0].props.disabled,
+      true,
+      '应用预设后（未手改字段）「保存设置」应禁用 —— 亮起说明表单没跟上 store（本 bug 的第一症状）'
+    )
+    // ② store 与「已保存配置」一致（usePersona 已写回）
+    const snap = world.controller.store.getSnapshot()
+    assert.equal(snap.headingLists, 'more', '应用后 store.headingLists 应为预设值 more')
+    assert.equal(snap.replyLength, 'detailed', '应用后 store.replyLength 应为预设值 detailed')
+    // ③ 关键回归点：本地表单必须与 store 一致（dirty 的两侧相等）
+    //    通过「不再有未保存提示」与保存按钮禁用间接验证（树里没有 dirty 标记）
+    const dirtyHint = findAll(tree1, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-dirty'))
+    assert.equal(dirtyHint.length, 0, '不应出现「未保存的更改」提示')
+    // ④ 编辑某字段后 dirty 仍应正常亮起（确认按字段判断没有把保护一并去掉）。
+    //    折叠分组是**互斥**的（toggleSection 会关掉人设分组），先切回「特质」分组。
+    const triggerTraits = findAll(tree1, (n) => n.type === 'button' && textOf(n).includes(world.dicts.zh['group.traits']))
+    assert.ok(triggerTraits.length > 0, '应存在「特质」分组标题（前置条件）')
+    await triggerTraits[0].props.onClick()
+    const treeTraits = await renderSettings(world)
+    const styleSelects = findAll(treeTraits, (n) => n.type === 'select')
+    assert.ok(styleSelects.length > 0, '应存在风格下拉框（前置条件）')
+    await styleSelects[0].props.onChange({ target: { value: 'roast' } })
+    const tree2 = await renderSettings(world)
+    const saveBtn2 = findAll(tree2, (n) => n.type === 'ui-button' && textOf(n) === world.dicts.zh['button.save'])
+    assert.equal(
+      saveBtn2[0].props.disabled,
+      false,
+      '手动改动字段后「保存设置」应恢复可用（按字段保护不能连编辑检测一起丢掉）'
+    )
+    // ⑤ 按字段保护的**另一半**：用户正在编辑的字段，不能被外部写入（loadConfig 的
+    //    applyConfig，等价于 2s 轮询干的事）覆盖。若去掉按字段判断（无条件跟随
+    //    store），这里会失败 —— C19 前半段只测「跟随」，测不出这个方向的回归
+    //    （判断力验证实测 ②③ 漏网）。
+    //    注意：不要指望 fake timer 的轮询自己跑 —— settle 不推进 timerQueue，
+    //    直接调 loadConfig 才是确定性的等价写入。
+    await styleSelects[0].props.onChange({ target: { value: 'casual' } })   // 用户正在编辑 style
+    // 外部写入（轮询的等价物）必须真的改变 store —— effect 的依赖是 store 值，
+    // 若 loadConfig 返回与 store 相同的值，effect 根本不跑，变异（无条件跟随）
+    // 就探测不到差异（判断力验证实测 ②③ 漏网的原因）。这里模拟「别处把风格
+    // 改成了 humorous」：store 即将变为 humorous，而用户手里还捏着 casual。
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+      ? { ok: true, config: { ...CONFIG, style: 'humorous' }, configError: null, deliveryWarning: null }
+      : { ok: true, config: { ...CONFIG }, changed: [] })
+    await world.controller.loadConfig()
+    // 渲染两轮：effect 按字段判断后的 setState 要到下一轮渲染才反映到树里
+    // （测试台的 set 只标记 dirty，下一帧 render() 才提交；单帧树读到的是旧值）
+    await renderSettings(world)
+    const treePolled = await renderSettings(world)
+    const polledSelects = findAll(treePolled, (n) => n.type === 'select')
+    assert.ok(polledSelects.length > 0, '轮询后仍应有风格下拉框（前置条件）')
+    assert.equal(
+      polledSelects[0].props.value,
+      'casual',
+      '用户正在编辑的字段不得被外部写入覆盖（无条件跟随 store 会把它改回 store 值）'
+    )
+  })
+
+  await check('C22 翻页会复位翻面态：切走再切回不得自动是背面', async () => {
+  // 用户实测：翻开 A 卡背面 → 切到 B → 再切回 A，A 仍以背面出现。
+  //
+  // 根因：flippedName 记住了「哪张卡被翻开过」，而 go() 只改索引、不清它 ⇒
+  // 切回来时 current && flippedName === name 又成立，于是「记得」上次的面。
+  //
+  // 语义：翻面是「看这张卡背面」的**临时阅读动作**，翻页是「换一张看」——
+  // 注意力已重置。记住它会让用户以为这张卡「默认就是背面」。
+  // 故三处换卡入口都要清：go() / 展开自动定位 / 折叠分组。
+  const lib = {
+    ok: true,
+    personas: {
+      苏格拉底式提问者: { style: 'professional', builtin: true, headingLists: 'default', emoji: 'default', tables: 'default', replyLength: 'normal', customInstructions: '' },
+      极简主义者: { style: 'efficient', builtin: true, headingLists: 'default', emoji: 'default', tables: 'default', replyLength: 'normal', customInstructions: '' },
+      资深架构师: { style: 'professional', builtin: true, headingLists: 'more', emoji: 'default', tables: 'more', replyLength: 'detailed', customInstructions: 'x' }
+    },
+    activeName: '苏格拉底式提问者'
+  }
+  const world = await boot({}, lib)
+  const closed = await renderSettings(world)
+  await findAll(closed, (n) => n.type === 'button' && textOf(n).includes(world.dicts.zh['group.personas']))[0].props.onClick()
+  const tree0 = await renderSettings(world)
+
+  const flippedCount = (tree) => findAllByClass(tree, 'soul-persona-card').filter((c) => c.props['data-flipped'] === 'true').length
+  const currentCard = (tree) => findAllByClass(tree, 'soul-persona-card').find((c) => c.props['data-current'] === 'true')
+
+  // ① 翻开当前卡背面
+  const front = findAll(currentCard(tree0), (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-persona-face-front'))
+  assert.ok(front[0] && typeof front[0].props.onClick === 'function', '前置条件：当前卡正面应可点翻面')
+  await front[0].props.onClick()
+  for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+  const tree1 = await renderSettings(world)
+  assert.equal(flippedCount(tree1), 1, '前置条件：点整面后应有 1 张处于背面')
+
+  // ② 点侧边卡切到下一张 ⇒ 无卡处于背面
+  const side = findAllByClass(tree1, 'soul-persona-card').find((c) => c.props['data-current'] === 'false' && typeof c.props.onClick === 'function')
+  assert.ok(side, '前置条件：应存在可点的叠层侧边卡')
+  await side.props.onClick()
+  for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+  const tree2 = await renderSettings(world)
+  assert.equal(flippedCount(tree2), 0, '翻页后不应有卡处于背面')
+
+  // ③ 切回原来那张 ⇒ 必须是正面（bug 时这里会是背面）
+  const side2 = findAllByClass(tree2, 'soul-persona-card').find((c) => c.props['data-current'] === 'false' && typeof c.props.onClick === 'function')
+  await side2.props.onClick()
+  for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+  const tree3 = await renderSettings(world)
+  assert.equal(
+    flippedCount(tree3),
+    0,
+    '切回原来那张时不得记住翻面态（应显示正面；bug 症状：仍以背面出现）'
+  )
+
+  // ④ 圆点导航同样要复位（不能只修侧边卡这一条路径）
+  await front[0].props.onClick()
+  for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+  const dots = findAll(await renderSettings(world), (n) => n.props?.role === 'tab')
+  assert.ok(dots.length > 1, '前置条件：应有多个位置圆点')
+  await dots[1].props.onClick()
+  for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+  assert.equal(flippedCount(await renderSettings(world)), 0, '圆点导航换卡也应复位翻面态')
+
+  // ⑤ 折叠 → 重新展开：也不得带出上次的背面
+  //
+  // ⚠️ 这一场景必须让「自动定位」落回**同一张卡**才有判别力：
+  //    自动定位会把 index 设为 activePersona 的位置。若翻的是另一张卡，
+  //    重新展开后当前卡已换人 ⇒ flippedName 天然不匹配 ⇒ 即使不清理也显示正面，
+  //    测试就成了「永远通过」（初版正因如此漏掉了这个分支 —— 判断力验证发现）。
+  //    故用独立 world，让 activeName 就是被翻的那张。
+  const w5 = await boot({}, {
+    ok: true,
+    personas: {
+      苏格拉底式提问者: { style: 'professional', builtin: true },
+      极简主义者: { style: 'efficient', builtin: true }
+    },
+    // activeName 取列表第 0 项 ⇒ 展开时自动定位回第 0 张
+    activeName: '苏格拉底式提问者'
+  })
+  const closed5 = await renderSettings(w5)
+  await findAll(closed5, (n) => n.type === 'button' && textOf(n).includes(w5.dicts.zh['group.personas']))[0].props.onClick()
+  let t5 = await renderSettings(w5)
+
+  // 翻开**第 0 张**（= activeName 指向的那张，自动定位会回到它）
+  const card0 = currentCard(t5)
+  assert.ok(card0, '前置条件：应有当前卡')
+  const front5 = findAll(card0, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-persona-face-front'))
+  await front5[0].props.onClick()
+  for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+  t5 = await renderSettings(w5)
+  assert.equal(flippedCount(t5), 1, '前置条件：应已翻到背面')
+
+  // 折叠
+  await findAll(t5, (n) => n.type === 'button' && textOf(n).includes(w5.dicts.zh['group.personas']))[0].props.onClick()
+  for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+  // 重新展开（自动定位会回到第 0 张 = 刚被翻的那张）
+  t5 = await renderSettings(w5)
+  await findAll(t5, (n) => n.type === 'button' && textOf(n).includes(w5.dicts.zh['group.personas']))[0].props.onClick()
+  for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+  assert.equal(
+    flippedCount(await renderSettings(w5)),
+    0,
+    '折叠后重新展开不得记得上次的翻面态（自动定位落回同一张卡时）'
+  )
+})
+
+await check('C23 全局轮询注册在装配层（底栏不依赖设置页是否挂载）', async () => {
+  // 用户实测：用 /soul confirm 确认人设变更后（宿主已写盘，配置文件正确），
+  // 底栏「个性化已启用 · 人设名」仍显示旧值。
+  //
+  // 根因：三条刷新路径（setInterval / focus / visibilitychange）**全部注册在
+  // SoulSettings 组件内** —— 设置页没挂载时它们都不存在，底栏读的 store 无人刷新。
+  // 底栏是常驻组件，其数据链路不该依赖另一个组件的生命周期。
+  //
+  // 这里断言三件事：
+  //   ① 定时器只在装配层注册（全客户端仅一处 setInterval）
+  //   ② 装配层注册了页面级事件监听（focus / visibilitychange）
+  //   ③ 设置页不再自己起定时器，只同步「暂停标记」
+  const world = await boot()
+  // ① 装配期即已注册（boot 会执行 ctx.effect）
+  const intervals = timerQueue.filter((t) => t.repeat === true)
+  assert.ok(intervals.length >= 1, '装配层应注册轮询定时器（interval）')
+
+  // ② 事件监听挂在 window/document 上（而非仅在设置页组件内）
+  //    测试台的 window/document stub 记录了 addEventListener 调用
+  assert.ok(
+    world.captured.events.window.includes('focus'),
+    '装配层应监听 window focus（切回窗口立即刷新，不必等下一个轮询周期）'
+  )
+  assert.ok(
+    world.captured.events.document.includes('visibilitychange'),
+    '装配层应监听 document visibilitychange'
+  )
+
+  // ③ 设置页只同步暂停标记：不打开它时轮询照常，打开且编辑时暂停
+  const before = world.controller.paused
+  assert.equal(before, false, '初始不应处于暂停态')
+  const tree = await renderSettings(world)
+  // 渲染设置页后（无改动）仍不应暂停
+  assert.equal(world.controller.paused, false, '无未保存编辑时不应暂停轮询')
+
+  // ④ 暂停语义：置位后 canRefresh 应为 false（编辑中不被远端覆盖）
+  world.controller.paused = true
+  assert.equal(world.controller.canRefresh(), false, 'paused 时不应允许刷新')
+  world.controller.paused = false
+  assert.equal(world.controller.canRefresh(), true, '复位后应恢复刷新')
+
+  // ⑤ 卸载复位：设置页卸载时必须把 paused 复原，否则**底栏永久停摆** ——
+  //    这正是本次 bug 的镜像形态（一个组件的生命周期管住了常驻组件的刷新）。
+  //    这条是判断力验证补出来的：变异「卸载时不复位 paused」首轮漏网，
+  //    同时暴露了测试台缺口（垫片原先只在依赖变化时跑清理，卸载时从不执行）。
+  const w2 = await boot()
+  await renderSettings(w2)
+  w2.controller.paused = true      // 模拟「编辑中被卸载」这一最坏情形
+  w2.runtime.unmount()
+  assert.equal(
+    w2.controller.paused,
+    false,
+    '设置页卸载后必须复位 paused（否则外部轮询永久停摆，底栏不再刷新）'
+  )
+})
+
+await check('C21 底栏展示当前人设，未匹配时显示「自定义」', async () => {
+  // 需求：底栏「个性化已启用」后必须回答「现在用的是哪套人设」。
+  // 此前只有匹配到预设才缀名字，手改过特质后留空 —— 等于没回答。
+  // 现在：匹配到预设显示预设名，否则显示「自定义」。
+  const personaLib = (activeName) => ({
+    ok: true,
+    personas: {
+      苏格拉底式提问者: {
+        style: 'professional', builtin: true, headingLists: 'default', emoji: 'default',
+        tables: 'default', replyLength: 'normal', customInstructions: ''
+      },
+      极简主义者: { style: 'efficient', builtin: true }
+    },
+    activeName
+  })
+
+  // ① 匹配到预设 ⇒ 缀预设名
+  const w1 = await boot({}, personaLib('苏格拉底式提问者'))
+  // 人设列表由**设置页组件挂载后的 refresh** 拉取（apply 阶段只拉 config）。
+  // 快捷开关单独渲染不会触发它 —— 先渲染一次设置页把人设灌进 store，
+  // 否则下面读到的 activePersona 恒为 null（此前踩过：断言读到「自定义」）。
+  await renderSettings(w1)
+  const btn1 = await w1.runtime.settle(quickToggleElement(w1))
+  const name1 = findAll(btn1, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-quick-toggle-name'))
+  assert.equal(name1.length, 1, `启用时应有一个人设名节点，实际 ${name1.length}`)
+  assert.ok(
+    textOf(name1[0]).includes('苏格拉底式提问者'),
+    `匹配到预设时应显示预设名，实际：「${textOf(name1[0])}」`
+  )
+
+  // ② 未匹配（手改过特质）⇒ 显示「自定义」，不能留空
+  const w2 = await boot({}, personaLib(null))
+  await renderSettings(w2)
+  const btn2 = await w2.runtime.settle(quickToggleElement(w2))
+  const name2 = findAll(btn2, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-quick-toggle-name'))
+  assert.equal(name2.length, 1, '未匹配时也应有人设名节点（回退为「自定义」）')
+  assert.ok(
+    textOf(name2[0]).includes(w2.dicts.zh['quick.custom']),
+    `未匹配时应显示「${w2.dicts.zh['quick.custom']}」，实际：「${textOf(name2[0])}」`
+  )
+
+  // ③ 关闭个性化 ⇒ 整块人设名不显示（此刻人设不生效，挂名字会误导）
+  const w3 = await boot({}, personaLib('苏格拉底式提问者'))
+  // 关闭个性化：必须让 GET 与 POST 都返回 enabled:false —— boot 的 configPayload
+  // 只展开进 GET 的响应，POST 分支仍是 {...CONFIG}（enabled:true），
+  // 直接 boot({enabled:false}) 会被后续 refresh 覆盖回 true（此前踩过）。
+  const disabledConfig = { ...CONFIG, enabled: false }
+  w3.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+    ? { ok: true, config: { ...disabledConfig }, configError: null, deliveryWarning: null }
+    : { ok: true, config: { ...disabledConfig }, changed: [] })
+  await renderSettings(w3)
+  w3.controller.store.update((s) => { s.enabled = false })
+  const btn3 = await w3.runtime.settle(quickToggleElement(w3))
+  const name3 = findAll(btn3, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-quick-toggle-name'))
+  assert.equal(name3.length, 0, '关闭个性化时不应显示人设名')
+})
+
+await check('C20 点叠层侧边卡只翻页、不翻面（整面点击必须限定当前卡）', async () => {
+    // 用户实测 bug：点侧边卡切换下一个人设后，新当前卡直接以【背面】出现。
+    // 根因：整面翻面的 onClick 挂在了【所有卡】的正面 face 上 —— 点侧边卡时，
+    // 事件先冒泡到它的 face onClick（setFlippedName(侧边卡名)），再冒泡到卡片的
+    // go() 翻页 ⇒ 翻页后它成了当前卡 ⇒ flippedName === 它 ⇒ 一上来就是背面。
+    // 修法：face 的 onClick 限定 current；cursor:pointer 同理只给当前卡。
+    const world = await boot({}, {
+      ok: true,
+      personas: {
+        苏格拉底式提问者: { style: 'professional', builtin: true },
+        极简主义者: { style: 'efficient', builtin: true },
+        资深架构师: { style: 'professional', headingLists: 'more', builtin: true }
+      },
+      activeName: null
+    })
+    const closed = await renderSettings(world)
+    const trigger = findAll(closed, (n) => n.type === 'button' && textOf(n).includes(world.dicts.zh['group.personas']))
+    await trigger[0].props.onClick()
+    const tree = await renderSettings(world)
+
+    // ① 叠层侧边卡的正面 face 不得挂 onClick（否则点击会先翻面再翻页）
+    const side = findAllByClass(tree, 'soul-persona-card')
+      .find((c) => c.props['data-current'] === 'false' && typeof c.props.onClick === 'function')
+    assert.ok(side, '前置条件：应存在可点的叠层侧边卡')
+    const sideFront = findAll(side, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-persona-face-front'))
+    assert.equal(
+      Boolean(sideFront[0] && sideFront[0].props.onClick),
+      false,
+      '叠层侧边卡的正面不得挂翻面 onClick（会与翻页冲突，导致新当前卡以背面出现）'
+    )
+    // ② 点它 ⇒ 只翻页
+    await side.props.onClick()
+    for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+    const after = await renderSettings(world)
+    const cur = findAllByClass(after, 'soul-persona-card').filter((c) => c.props['data-current'] === 'true')
+    assert.equal(cur.length, 1, '翻页后应恰好一张当前卡')
+    assert.equal(cur[0].props['data-flipped'], 'false', '翻页后新当前卡必须是正面（bug 症状：直接背面）')
+    // ③ 当前卡的正面仍必须可点翻面（修复不能把功能一并去掉）
+    const curFront = findAll(cur[0], (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-persona-face-front'))
+    assert.ok(curFront[0] && typeof curFront[0].props.onClick === 'function', '当前卡正面应保留整面点击翻面')
+    // ④ 翻到背面后，正面的整面点击必须撤掉（否则背面点击会再次触发翻面回调）
+    await curFront[0].props.onClick()   // 翻到背面
+    for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+    const flippedTree = await renderSettings(world)
+    const flippedCard = findAllByClass(flippedTree, 'soul-persona-card').find((c) => c.props['data-flipped'] === 'true')
+    assert.ok(flippedCard, '前置条件：应有一张卡处于背面')
+    const flippedFront = findAll(flippedCard, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-persona-face-front'))
+    assert.equal(
+      Boolean(flippedFront[0] && flippedFront[0].props.onClick),
+      false,
+      '背面状态下正面不得再挂整面点击（否则会重复触发翻面）'
+    )
+    // ⑤ 卡背整面点击=返回正面（与正面「整面点击翻到背面」对称）
+    const backFace = findAll(flippedCard, (n) => typeof n.props?.className === 'string' && String(n.props.className).includes('soul-persona-face-back'))
+    assert.ok(backFace[0] && typeof backFace[0].props.onClick === 'function', '卡背应整面可点返回')
+    // ⑥ 但拖选文字时不得返回：模拟一个非折叠选区
+    const realGetSelection = globalThis.getSelection
+    try {
+      globalThis.getSelection = () => ({ isCollapsed: false, toString: () => '选中的指令文本' })
+      backFace[0].props.onClick()
+      for (let i = 0; i < 4; i++) await new Promise((r) => drainTick(r))
+      const stillFlipped = findAllByClass(await renderSettings(world), 'soul-persona-card').filter((c) => c.props['data-flipped'] === 'true')
+      assert.equal(stillFlipped.length, 1, '拖选文字时不得翻回正面（否则一选就跳走）')
+      // ⑦ 无选区时点击 ⇒ 正常返回
+      globalThis.getSelection = () => ({ isCollapsed: true, toString: () => '' })
+      backFace[0].props.onClick()
+      for (let i = 0; i < 4; i++) await new Promise((r) => drainTick(r))
+      const afterBack = findAllByClass(await renderSettings(world), 'soul-persona-card').filter((c) => c.props['data-flipped'] === 'true')
+      assert.equal(afterBack.length, 0, '无选区时点卡背应返回正面')
+    } finally {
+      if (realGetSelection === undefined) delete globalThis.getSelection
+      else globalThis.getSelection = realGetSelection
+    }
+  })
+
+  await check('C18 展开「人设预设」时自动定位到当前生效的那张（而不是永远第 1 张）', async () => {
+    // 需求背景：卡片一次只展示一张，内置项排在前面，生效项（尤其是自建）往往在后面。
+    // 若固定从第 1 张开始，用户点开分组后要翻好几下才能看到自己在用哪个。
+    //
+    // 这里用**行为**验证（不看源码）：生效项排在第 2 位 ⇒ 展开后应直接停在 2 / 2。
+    const personaLib = {
+      ok: true,
+      personas: {
+        苏格拉底式提问者: { style: 'professional', builtin: true },
+        我的自建: { style: 'roast', emoji: 'more' }
+      },
+      activeName: '我的自建'   // ← 生效项是第 2 个（内置排前面）
+    }
+    const open = async (w) => {
+      const closed = await renderSettings(w)
+      const trigger = findAll(closed, (n) => n.type === 'button' && textOf(n).includes(w.dicts.zh['group.personas']))
+      await trigger[0].props.onClick()
+      return renderSettings(w)
+    }
+    // ① 展开即定位到生效项
+    const w1 = await boot({}, personaLib)
+    const t1 = await open(w1)
+    assert.equal(
+      textOf(findAllByClass(t1, 'soul-persona-card-pos')[0]),
+      '2 / 2',
+      '展开后应定位到生效项（第 2 张），而不是停在首张'
+    )
+    // ② 定位的是**生效项本身**，不是碰巧的末张 —— 换个生效项再验一次
+    const w2 = await boot({}, {
+      ok: true,
+      personas: personaLib.personas,
+      activeName: '苏格拉底式提问者'   // ← 生效项改成第 1 个
+    })
+    const t2 = await open(w2)
+    assert.equal(
+      textOf(findAllByClass(t2, 'soul-persona-card-pos')[0]),
+      '1 / 2',
+      '生效项换到第 1 个时应定位到 1 / 2（证明是按生效项定位，而不是恒取末张）'
+    )
+    // ③ 无生效项（都不匹配）时退回首张 —— 总要给个确定落点
+    const w3 = await boot({}, { ok: true, personas: personaLib.personas, activeName: null })
+    const t3 = await open(w3)
+    assert.equal(
+      textOf(findAllByClass(t3, 'soul-persona-card-pos')[0]),
+      '1 / 2',
+      '没有生效项时应退回第 1 张'
+    )
+    // ④ 手动翻页后**不能被轮询拽回** —— 展开期间刷新 personas 不应重置位置
+    //    （实现上用 autoPositionedRef 记住「本次展开已定位过」）
+    const moved = await (async () => {
+      const nav = findAllByClass(t1, 'soul-persona-navbtn')
+      await nav[0].props.onClick()   // 生效项在末张 ⇒ 点「上一张」翻到首张
+      return renderSettings(w1)
+    })()
+    assert.equal(
+      textOf(findAllByClass(moved, 'soul-persona-card-pos')[0]),
+      '1 / 2',
+      '手动翻页后应停在 1 / 2'
+    )
+    // 触发一次「轮询刷新 personas」（内容不变）后位置必须还在 1 / 2
+    await w1.controller.fetchPersonas?.()
+    for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+    const afterRefresh = await renderSettings(w1)
+    assert.equal(
+      textOf(findAllByClass(afterRefresh, 'soul-persona-card-pos')[0]),
+      '1 / 2',
+      '展开期间轮询刷新不应把手动翻到的位置拽回生效项'
+    )
+    // ⑤ 折叠再展开 ⇒ 重新定位回生效项（需求原文：「每次点击开」都要展示当前使用的）
+    const collapsed = await renderSettings(w1)
+    const trigger2 = findAll(collapsed, (n) => n.type === 'button' && textOf(n).includes(w1.dicts.zh['group.personas']))
+    await trigger2[0].props.onClick()   // 折叠
+    await renderSettings(w1)
+    const reopened = await open(w1)
+    assert.equal(
+      textOf(findAllByClass(reopened, 'soul-persona-card-pos')[0]),
+      '2 / 2',
+      '折叠后再次展开应重新定位到生效项'
+    )
+    // ⑥ **展开时数据尚未就绪**（personas 仍是 null）不得抛错 —— 等数据到了再定位。
+    //    这条专防「去掉空值守卫」：无守卫时 personaNames 为 null，
+    //    `null.indexOf(...)` 会抛 TypeError，直接把设置页渲染打断。
+    //    桩用一个**永不 resolve** 的 promise 把 personas 钉在「加载中」。
+    const w4 = loadClient({
+      '/api/soul/config': (call) => (call.method === 'GET' ? { ok: true, config: { ...CONFIG } } : { ok: true, config: { ...CONFIG }, changed: [] }),
+      '/api/soul/config/reset': () => ({ ok: true, config: { ...CONFIG }, changed: [], backupPath: null }),
+      '/api/soul/personas': () => new Promise(() => {}),
+      '/api/soul/prompt': () => ({ ok: true, prompt: 'P', enabled: true })
+    })
+    for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+    assert.equal(
+      w4.controller.store.getSnapshot().personas,
+      null,
+      '前置条件：personas 应停在加载中（null）'
+    )
+    const closed4 = await renderSettings(w4)
+    const trigger4 = findAll(closed4, (n) => n.type === 'button' && textOf(n).includes(w4.dicts.zh['group.personas']))
+    await trigger4[0].props.onClick()
+    const loadingTree = await renderSettings(w4)   // 不应抛错
+    assert.ok(loadingTree, '展开时数据未就绪不应导致渲染失败')
+    assert.equal(
+      findAllByClass(loadingTree, 'soul-persona-card-pos').length,
+      0,
+      '数据未就绪时不应出现位置指示（此时还没有任何卡片）'
+    )
+    // ⑦ 更刁的组合：**personas 加载中（null）但 activePersona 已有值**。
+    //    真实场景：先应用过某个预设（配置与它匹配），随后刷新页面 —— 配置先到、
+    //    预设列表还在路上。此时若去掉 `!personaNames` 守卫，
+    //    `personaNames.indexOf(...)` 会对 null 调用而抛 TypeError，直接打断设置页渲染。
+    //    （上面 ⑥ 的桩里 activePersona 为 null，走的是 `: -1` 分支，覆盖不到这一条。）
+    const w5 = loadClient({
+      // 配置与桩里那个预签名一致 ⇒ 宿主会回报 activeName
+      '/api/soul/config': (call) => (call.method === 'GET' ? { ok: true, config: { ...CONFIG } } : { ok: true, config: { ...CONFIG }, changed: [] }),
+      '/api/soul/config/reset': () => ({ ok: true, config: { ...CONFIG }, changed: [], backupPath: null }),
+      '/api/soul/personas': () => new Promise(() => {}),
+      '/api/soul/prompt': () => ({ ok: true, prompt: 'P', enabled: true })
+    })
+    for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+    // 直接往 store 里塞一个非空 activePersona，复刻「配置先到、预设列表未到」
+    w5.controller.store.update((s) => { s.activePersona = '苏格拉底式提问者' })
+    for (let i = 0; i < 4; i++) await new Promise((r) => drainTick(r))
+    const closed5 = await renderSettings(w5)
+    const trigger5 = findAll(closed5, (n) => n.type === 'button' && textOf(n).includes(w5.dicts.zh['group.personas']))
+    await trigger5[0].props.onClick()
+    const tree5 = await renderSettings(w5)   // ← 去掉守卫时这里会抛 TypeError
+    assert.ok(tree5, '预设列表加载中但已有生效人设时，展开分组不应抛错')
+    assert.equal(
+      findAllByClass(tree5, 'soul-persona-card-pos').length,
+      0,
+      '预设列表未就绪时不应出现位置指示'
+    )
   })
 
   await check('C17 应用预设成功后清掉上一轮的失败提示', async () => {