dsh-soul 0.7.0 → 0.7.2

package/scripts/verify-client.mjs

@@ -0,0 +1,1319 @@
+// scripts/verify-client.mjs — 设置页客户端行为回归（离线，无浏览器）
+//
+// 为什么需要它：`verify-trail` / `verify-nav-icon` 覆盖的是**渲染层**（DOM 里的 SVG），
+// 而设置页的**交互行为**一直只有「源文本契约」——即断言客户端源码里出现了某段写法。
+// 那种断言证明不了「运行时真的走了那条分支」：把 `if (!payload)` 改成常量、或让
+// `resetConfig` 永不返回 undefined，源码看起来依然正确。
+//
+// 这里把**真实的 `client/index.mjs`** 原样载入（不复制、不裁剪），在纯 Node 里：
+//   1. 用一小撮 React 垫片实现 hooks（useState / useEffect / useRef）与 jsx-runtime；
+//   2. 用假 window / document / fetch / 定时器接管外部世界；
+//   3. 跑真实的 `apply(ctx)`，拿到真实的 `soulController` 与设置页组件；
+//   4. 像用户一样**点按钮**，断言**用户实际会看到的提示文案**。
+//
+// 覆盖的行为全部是 0.7.1 修过、而此前没有任何行为回归守着的那几处：
+//   - 两类问题分开上报：`configError`（配置读不出来）/ `deliveryWarning`（送不到会话）
+//   - 重置失败**不得**被报成成功（配置损坏时那唯一一条自救路径）
+//   - 重置成功且丢弃过损坏文件时要告知「已备份」
+//   - 保存失败**不得**误报成「配置无变化」
+//
+// 零依赖，直接 `node scripts/verify-client.mjs` 运行。
+
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { setImmediate as drainTick } from 'node:timers'
+import { assertCount } from './lib/skip-report.mjs'
+
+// 基线运行应跑出的断言数。本脚本没有环境相关跳过（客户端源码与 Node 都在），
+// 所以链里的 `--strict` 对它无额外语义；数字由下面的 assertCount 守住。
+const EXPECTED_ASSERTIONS = 23
+
+const source = readFileSync(new URL('../client/index.mjs', import.meta.url), 'utf8')
+
+// ==================== 一、React 垫片 ====================
+//
+// 只实现客户端真正用到的那几个 hook（`React.useState` × 25 / `useEffect` × 9 /
+// `useRef` × 6，无 useCallback / useMemo / useSyncExternalStore）。hook 按「组件在
+// 渲染树里的路径」分帧、按调用顺序取槽 —— 与 React 的规则一致。渲染是同步的：状态
+// 变化只置脏标记，由 settle() 收敛。
+
+const Fragment = Symbol('Fragment')
+
+function createRuntime() {
+  const frames = new Map() // 路径 -> { key, values: [], deps: [], cursor }
+  const cleanups = new Map() // `${frame.key}#${slot}` -> 清理函数
+  let frameStack = []
+  let queue = []
+  let dirty = false
+
+  const frameOf = () => {
+    const frame = frameStack[frameStack.length - 1]
+    if (!frame) throw new Error('hook 在组件外被调用')
+    return frame
+  }
+
+  const React = {
+    Fragment,
+    useState(initial) {
+      const frame = frameOf()
+      const slot = frame.cursor++
+      if (!(slot in frame.values)) {
+        frame.values[slot] = typeof initial === 'function' ? initial() : initial
+      }
+      const set = (next) => {
+        const current = frame.values[slot]
+        const value = typeof next === 'function' ? next(current) : next
+        if (Object.is(value, current)) return
+        frame.values[slot] = value
+        dirty = true
+      }
+      return [frame.values[slot], set]
+    },
+    useEffect(fn, deps) {
+      const frame = frameOf()
+      const slot = frame.cursor++
+      const prev = frame.deps[slot]
+      const same = prev !== undefined && deps !== undefined &&
+        prev.length === deps.length && deps.every((d, i) => Object.is(d, prev[i]))
+      if (same) return
+      frame.deps[slot] = deps
+      queue.push({ frame, slot, fn })
+    },
+    useRef(initial) {
+      const frame = frameOf()
+      const slot = frame.cursor++
+      if (!(slot in frame.values)) frame.values[slot] = { current: initial }
+      return frame.values[slot]
+    }
+  }
+
+  const jsx = (type, props, key) => ({ type, props: props || {}, key })
+
+  function renderChildren(children, path) {
+    if (children === undefined || children === null || typeof children === 'boolean') return []
+    if (Array.isArray(children)) return children.flatMap((c, i) => renderChildren(c, `${path},${i}`))
+    if (typeof children === 'string' || typeof children === 'number') {
+      return [{ type: '#text', text: String(children) }]
+    }
+    const node = render(children, path)
+    return node ? [node] : []
+  }
+
+  function render(node, path) {
+    if (typeof node === 'string' || typeof node === 'number') return { type: '#text', text: String(node) }
+    if (!node || typeof node !== 'object') return null
+    const { type, props } = node
+    if (type === Fragment) return { type: '#fragment', children: renderChildren(props.children, `${path}#`) }
+    if (typeof type === 'function') {
+      const frame = frames.get(path) || { key: path, values: [], deps: [], cursor: 0 }
+      frames.set(path, frame)
+      frame.cursor = 0
+      frameStack.push(frame)
+      let out
+      try {
+        out = type(props)
+      } finally {
+        frameStack.pop()
+      }
+      return render(out, `${path}/`)
+    }
+    // 宿主元素（原生标签，或 ui 垫片里的标记类型）：props 原样保留 —— 断言要读它们
+    return { type, props, children: renderChildren(props.children, `${path}>`) }
+  }
+
+  const drain = async () => {
+    for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+  }
+
+  return {
+    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++) {
+        dirty = false
+        queue = []
+        const tree = render(root, 'root')
+        for (const { frame, slot, fn } of queue) {
+          const key = `${frame.key}#${slot}`
+          const previous = cleanups.get(key)
+          if (typeof previous === 'function') previous()
+          const returned = fn()
+          cleanups.set(key, typeof returned === 'function' ? returned : null)
+        }
+        await drain()
+        if (!dirty) return tree
+      }
+      throw new Error('渲染未收敛（40 轮仍在变化）—— hook 依赖或 effect 里可能有自激循环')
+    }
+  }
+}
+
+// ==================== 二、遍历渲染树 ====================
+
+function walk(node, visit) {
+  if (!node) return
+  visit(node)
+  for (const child of node.children || []) walk(child, visit)
+}
+
+function textOf(node) {
+  if (!node) return ''
+  if (node.type === '#text') return node.text
+  return (node.children || []).map(textOf).join('')
+}
+
+function findAll(tree, predicate) {
+  const hits = []
+  walk(tree, (node) => {
+    if (predicate(node)) hits.push(node)
+  })
+  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 = {
+  setTimeout: globalThis.setTimeout,
+  clearTimeout: globalThis.clearTimeout,
+  setInterval: globalThis.setInterval,
+  clearInterval: globalThis.clearInterval
+}
+let timerQueue = []
+let fetchCalls = []
+
+const installFakeTimers = () => {
+  // 客户端有三处定时器，全部与断言直接相关，必须接管：
+  //   - toast 的 2s 自动消失（绝不能在断言之前触发）；
+  //   - 「关于你」分组的 2s 轮询刷新（真实 setInterval 会让事件循环永不空 —— 脚本
+  //     跑完最后一行却不退出，看起来像挂住）；
+  //   - 提示词预览的 400ms 防抖。
+  // 接管后由用例决定何时推进，测试才是确定性的、也才跑得完。
+  globalThis.setTimeout = (fn, delay) => {
+    const handle = { fn, delay: delay || 0, repeat: false }
+    timerQueue.push(handle)
+    return handle
+  }
+  globalThis.setInterval = (fn, delay) => {
+    const handle = { fn, delay: delay || 0, repeat: true }
+    timerQueue.push(handle)
+    return handle
+  }
+  const drop = (handle) => {
+    if (handle) timerQueue = timerQueue.filter((t) => t !== handle)
+  }
+  globalThis.clearTimeout = drop
+  globalThis.clearInterval = drop
+}
+const restoreTimers = () => {
+  globalThis.setTimeout = realTimers.setTimeout
+  globalThis.clearTimeout = realTimers.clearTimeout
+  globalThis.setInterval = realTimers.setInterval
+  globalThis.clearInterval = realTimers.clearInterval
+}
+
+const interpolate = (text, params) =>
+  String(text).replace(/\{(\w+)\}/g, (all, key) => (params && key in params ? String(params[key]) : all))
+
+/** 载入真实客户端 bundle 并装配插件（返回真实 controller 与设置页组件）。 */
+function loadClient(routes) {
+  let factory = null
+  const domNode = () => ({
+    style: { setProperty() {}, removeProperty() {} },
+    classList: { add() {}, remove() {} },
+    dataset: {},
+    setAttribute() {},
+    removeAttribute() {},
+    appendChild() {},
+    remove() {},
+    addEventListener() {},
+    removeEventListener() {},
+    children: []
+  })
+  const windowStub = {
+    __ModuleLoader__: { load: (m) => { factory = m.factory } },
+    addEventListener: (type) => { captured.events.window.push(type) },
+    removeEventListener() {},
+    location: { origin: 'http://dsh.test' }
+  }
+  const documentStub = {
+    visibilityState: 'visible',
+    body: domNode(),
+    head: domNode(),
+    addEventListener: (type) => { captured.events.document.push(type) },
+    removeEventListener() {},
+    // 插件在装配时会把样式表插到 head（用 querySelector 判重），导航图标那一层还会
+    // 挂 MutationObserver —— 这里只需让这些调用成立；本脚本断言的是行为，不是 DOM。
+    querySelector: () => null,
+    querySelectorAll: () => [],
+    createElement: () => domNode(),
+    createElementNS: () => domNode()
+  }
+
+  globalThis.window = windowStub
+  globalThis.document = documentStub
+  globalThis.MutationObserver = class { observe() {} disconnect() {} takeRecords() { return [] } }
+  globalThis.ResizeObserver = class { observe() {} unobserve() {} disconnect() {} }
+  globalThis.requestAnimationFrame = (fn) => drainTick(() => fn(0))
+  globalThis.cancelAnimationFrame = () => {}
+  globalThis.getComputedStyle = () => ({ position: 'absolute', getPropertyValue: () => '' })
+  globalThis.fetch = async (input, init = {}) => {
+    const url = new URL(String(input))
+    const method = (init.method || 'GET').toUpperCase()
+    const call = { path: url.pathname, method, body: init.body ? JSON.parse(init.body) : null }
+    fetchCalls.push(call)
+    const handler = routes[url.pathname]
+    const body = handler ? handler(call) : { ok: false, error: `no route: ${url.pathname}` }
+    if (body === false) return { ok: false, status: 500, json: async () => ({ ok: false, error: 'boom' }) }
+    return { ok: true, status: 200, json: async () => body }
+  }
+
+  installFakeTimers()
+
+  const runtime = createRuntime()
+  const requireStub = (spec) => {
+    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 / ui.Toast 单独换成宿主元素标记：这样它们连同 onClick / text /
+      // tone / holdMs / onDone 原样留在渲染树里，断言就能像用户一样
+      // 「找到那个按钮并点它」、「读出提示条的文案与色调」，而不是去猜某个闭包。
+      return { Button: 'ui-button', Toast: 'ui-toast' }
+    }
+    throw new Error(`未预料的 require：${spec}`)
+  }
+  // eslint-disable-next-line no-new-func -- 客户端是宿主加载的 bundle（无 ESM 导入），只能在受控作用域里求值
+  new Function('window', source)(windowStub)
+  const module = factory(requireStub)
+
+  // 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 }) },
+    locale: {
+      register: (_ns, dicts) => { captured.dicts = dicts },
+      bind: () => (key, params) => interpolate((captured.dicts?.zh || {})[key] ?? key, params)
+    },
+    slots: {
+      inject: (_name, cb) => cb(),
+      register: (options, component) => { captured.sections.push({ options, component }) }
+    }
+  }
+  module.apply(ctx)
+
+  const section = captured.sections.find((s) => s.options && s.options.name === 'settings.section')
+  const controller = captured.provide.soulController
+  const world = {
+    runtime,
+    captured,
+    section,
+    controller,
+    routes,
+    dicts: captured.dicts,
+    apply: module.apply,
+    module
+  }
+  return world
+}
+
+// ==================== 四、驱动器 ====================
+
+/**
+ * 装配一个干净的客户端实例（含真实的初始 loadConfig）。
+ *
+ * **桩必须与宿主真实协议同形**：`GET /api/soul/personas` 返回的是
+ * `{ personas: <对象 map>, activeName: <名字|null> }`（见 index.mjs:835 personaLibrary），
+ * 其中 personas 由 mergePersonas 生成、**恒含 7 个内置人设**（已实测：mergePersonas(null)
+ * 也有 7 个键），所以真实环境里「空列表」分支不可达。
+ * 此前这个桩写的是 `{ personas: [], activePersona: null }` —— 字段名错（activePersona
+ * 而非 activeName）、类型也错（数组而非对象 map），于是人设行与 ★ 标记的渲染在行为层
+ * **从未被执行过**：把它改成真实形状，整套 C 系列依然全绿（实测）。这正是「测试替身
+ * 与真实协议漂移」的典型：桩喂了一个真实环境不可达的输入，测试永远看不到真问题。
+ */
+async function boot(configPayload = {}, personaPayload = null) {
+  fetchCalls = []
+  timerQueue = []
+  const routes = {
+    '/api/soul/config': (call) => (call.method === 'GET'
+      ? { ok: true, config: { ...CONFIG }, ...configPayload }
+      : { ok: true, config: { ...CONFIG }, changed: [] }),
+    '/api/soul/config/reset': () => ({ ok: true, config: { ...CONFIG }, changed: [], backupPath: null }),
+    // 默认形状贴近宿主：对象 map + activeName（不是数组、不是 activePersona）
+    '/api/soul/personas': () => (personaPayload || {
+      ok: true,
+      personas: { 苏格拉底式提问者: { style: 'professional', builtin: true } },
+      activeName: null
+    }),
+    '/api/soul/prompt': () => ({ ok: true, prompt: 'P', enabled: true })
+  }
+  const world = loadClient(routes)
+  for (let i = 0; i < 8; i++) await new Promise((r) => drainTick(r))
+  return world
+}
+
+/**
+ * 渲染设置页。`useSoulController` 由宿主把槽位声明的 `hooks.soulController`
+ * （一个 subscribe / getSnapshot store）包成 hook 注入 —— 这里用垫片复刻同一语义。
+ */
+function rootElement(world) {
+  const props = world.section.options.inject()
+  const store = props.hooks.soulController
+  const useSoulController = (selector) => {
+    const [, force] = world.runtime.React.useState(0)
+    world.runtime.React.useEffect(() => store.subscribe(() => force((n) => n + 1)), [])
+    return selector(store.getSnapshot())
+  }
+  return { type: world.section.component, props: { ...props, useSoulController } }
+}
+
+const renderSettings = (world) => world.runtime.settle(rootElement(world))
+
+/** 输入框左侧的快捷开关（conversation.input.left 槽位），渲染方式与设置页同源。 */
+function quickToggleElement(world) {
+  const slot = world.captured.sections.find((s) => s.options && s.options.name === 'conversation.input.left')
+  assert.ok(slot, '未注册 conversation.input.left 槽位')
+  const props = slot.options.inject()
+  const store = props.hooks.soulController
+  const useSoulController = (selector) => {
+    const [, force] = world.runtime.React.useState(0)
+    world.runtime.React.useEffect(() => store.subscribe(() => force((n) => n + 1)), [])
+    return selector(store.getSnapshot())
+  }
+  return { type: slot.component, props: { ...props, useSoulController } }
+}
+
+/** 像用户一样点快捷开关，返回之后的按钮节点（可读 props 上的反馈）。 */
+async function clickQuickToggle(world) {
+  const before = await world.runtime.settle(quickToggleElement(world))
+  const buttons = findAll(before, (n) => n.type === 'button' && typeof n.props?.onClick === 'function')
+  assert.equal(buttons.length, 1, `快捷开关应恰好一个可点按钮，实际 ${buttons.length}`)
+  await buttons[0].props.onClick()
+  for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+  const after = await world.runtime.settle(quickToggleElement(world))
+  return findAll(after, (n) => n.type === 'button')[0]
+}
+
+/** 像用户一样点下指定文案的按钮，返回之后的 toast（{ text, kind }）。 */
+async function clickButton(world, labelKey) {
+  const tree = await renderSettings(world)
+  const label = world.dicts.zh[labelKey]
+  const buttons = findAll(tree, (n) => n.type === 'ui-button' && textOf(n) === label)
+  assert.equal(buttons.length, 1, `期望恰好一个「${label}」按钮，实际 ${buttons.length} 个`)
+  await buttons[0].props.onClick()
+  const after = await renderSettings(world)
+  // 提示形态对齐宿主模型设置页：成功走内联绿字（.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' }
+}
+
+// ==================== 五、用例 ====================
+
+const CONFIG = {
+  enabled: true,
+  nickname: '',
+  occupation: '',
+  bio: '',
+  style: 'professional',
+  headingLists: 'default',
+  emoji: 'default',
+  tables: 'default',
+  replyLength: 'normal',
+  language: 'zh',
+  customInstructions: '',
+  requireToolConfirmation: false,
+  trailEnabled: true,
+  trailColor: '#679EFE',
+  trailSpeed: 'slow',
+  trailWidth: 'thin'
+}
+
+let passed = 0
+async function check(name, fn) {
+  try {
+    await fn()
+  } catch (error) {
+    // 失败时把用例名带进消息：否则只有一行 AssertionError，无法一眼看出是哪个用例塌了。
+    // 注意 `stack` 也要改 —— 未捕获错误打印的是 stack，它的首行在 AssertionError 构造时
+    // 就已经写死，只改 `message` 在终端上根本看不见（判断力对照实测过）。
+    error.message = `【${name}】${error.message}`
+    error.stack = `【${name}】${error.stack}`
+    throw error
+  }
+  passed++
+  console.log(`  ✓ ${name}`)
+}
+
+try {
+  await check('C1 真实 client/index.mjs 可在纯 Node 里装配，并通过 settings.section 注册设置栏目', async () => {
+    const world = await boot()
+    assert.ok(world.section, '未注册 settings.section')
+    assert.equal(world.section.options.id, 'soul-settings')
+    assert.equal(typeof world.section.options.label, 'function', 'label 必须是函数（语言切换时实时解析）')
+    assert.ok(world.controller, '未 provide soulController')
+    assert.ok(world.dicts?.zh && world.dicts?.en, '双语文案表未注册')
+  })
+
+  await check('C2 装配后立即以 GET 拉取配置（而不是等用户打开设置页）', async () => {
+    await boot()
+    const got = fetchCalls.filter((c) => c.path === '/api/soul/config' && c.method === 'GET')
+    assert.equal(got.length, 1, `期望恰好一次 GET /api/soul/config，实际 ${got.length}`)
+  })
+
+  await check('C3 磁盘配置损坏时，configError 要显示在设置页上', async () => {
+    const world = await boot({ configError: 'soul-config.json 解析失败' })
+    const tree = await renderSettings(world)
+    assert.match(textOf(tree), /soul-config\.json 解析失败/, '设置页未显示 configError')
+  })
+
+  await check('C4 只有送达警告时，deliveryWarning 同样要显示出来', async () => {
+    const world = await boot({ deliveryWarning: '未送达任何活动会话' })
+    const tree = await renderSettings(world)
+    assert.match(textOf(tree), /未送达任何活动会话/, '设置页未显示 deliveryWarning')
+  })
+
+  await check('C5 两者同时存在时以 configError 为准（读不出来的问题更靠前）', async () => {
+    const world = await boot({ configError: '读不出来', deliveryWarning: '送不到' })
+    assert.equal(world.controller.store.getSnapshot().error, '读不出来')
+  })
+
+  await check('C6 保存成功但配置送不到会话时，回传的 deliveryWarning 要落到提示条上', async () => {
+    const world = await boot()
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+      ? { ok: true, config: { ...CONFIG } }
+      : { ok: true, config: { ...CONFIG }, changed: ['style'], deliveryWarning: '注入失败' })
+    const payload = await world.controller.saveConfig({ style: 'casual' })
+    assert.ok(payload, '保存成功应返回 payload')
+    assert.equal(world.controller.store.getSnapshot().error, '注入失败')
+  })
+
+  await check('C7 保存失败时 saveConfig 返回 falsy（调用方据此给失败提示，而不是误报「无变化」）', async () => {
+    const world = await boot()
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+      ? { ok: true, config: { ...CONFIG } }
+      : { ok: false, error: '写入被拒绝' })
+    const payload = await world.controller.saveConfig({ style: 'casual' })
+    assert.equal(payload, undefined, '保存失败不得返回 payload')
+    assert.match(String(world.controller.store.getSnapshot().error), /写入被拒绝/)
+  })
+
+  await check('C8 重置失败时弹「重置失败」，不得报成成功（0.7.1 修的就是这里）', async () => {
+    const world = await boot()
+    world.routes['/api/soul/config/reset'] = () => false // 失败响应
+    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['notice.reset'])
+  })
+
+  await check('C9 重置成功且丢弃过损坏文件时，提示「已备份」（而不是普通的「已重置」）', async () => {
+    const world = await boot()
+    world.routes['/api/soul/config/reset'] = () => ({
+      ok: true, config: { ...CONFIG }, changed: [], backupPath: '/x/soul-config.json.corrupt'
+    })
+    const toast = await clickButton(world, 'button.reset')
+    assert.equal(toast.kind, 'success')
+    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['notice.reset'])
+    assert.equal(world.controller.store.getSnapshot().error, null, '重置后不应残留上一轮的送达警告')
+  })
+
+  await check('C11 保存失败弹「保存失败」，不得误报「配置无变化」', async () => {
+    const world = await boot()
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+      ? { ok: true, config: { ...CONFIG } }
+      : { ok: false, error: '非法颜色' })
+    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['notice.noChanges'])
+  })
+
+  await check('C12 设置页真的渲染出可点的保存 / 重置按钮（断言不是对着空树跑）', async () => {
+    const world = await boot()
+    const tree = await renderSettings(world)
+    const buttons = findAll(tree, (n) => n.type === 'ui-button')
+    assert.ok(buttons.length >= 2, `应至少有保存与重置两个按钮，实际 ${buttons.length}`)
+    const labels = buttons.map(textOf)
+    assert.ok(labels.includes(world.dicts.zh['button.save']), `未找到保存按钮：${labels.join(' / ')}`)
+    assert.ok(labels.includes(world.dicts.zh['button.reset']), `未找到重置按钮：${labels.join(' / ')}`)
+    assert.ok(buttons.every((b) => typeof b.props.onClick === 'function'), '按钮缺少 onClick')
+    // 反「空树也通过」：不仅要有按钮，还要真的渲染出了栏目与字段
+    const text = textOf(tree)
+    for (const key of ['settings.title', 'field.nickname', 'button.save', 'button.reset']) {
+      assert.ok(
+        text.includes(world.dicts.zh[key]),
+        `设置页缺少「${key}」对应的文案（${world.dicts.zh[key]}）：${text}`
+      )
+    }
+  })
+
+  await check('C13 快捷开关保存失败时必须给出反馈（此前静默：按钮外观与文案都不变）', async () => {
+    const world = await boot()
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+      ? { ok: true, config: { ...CONFIG } }
+      : false)
+    const button = await clickQuickToggle(world)
+    assert.equal(button.props['data-failed'], 'true', '失败后 data-failed 必须为 true')
+    assert.ok(
+      String(button.props.title || '').includes('boom'),
+      `失败原因要出现在 title 上，实际：${button.props.title}`
+    )
+    assert.equal(
+      button.props['aria-label'],
+      button.props.title,
+      'aria-label 需与 title 一致（读屏用户同样要拿到失败原因）'
+    )
+    // 防空过：成功时该标记必须是 false，否则上面的断言等于写死
+    const ok = await boot()
+    const good = await clickQuickToggle(ok)
+    assert.equal(good.props['data-failed'], 'false', '成功时不应残留失败标记')
+  })
+
+  await check('C14 预设列表拉取失败时显示失败原因，不得永远停在「加载中...」', async () => {
+    const world = await boot()
+    world.routes['/api/soul/personas'] = () => false
+    // 人设分组默认折叠（Accordion 折叠时不渲染子节点），先像用户一样展开它
+    const closed = await renderSettings(world)
+    const triggers = findAll(closed, (n) => n.type === 'button' && textOf(n).includes(world.dicts.zh['group.personas']))
+    assert.equal(triggers.length, 1, `应恰好一个「人设预设」折叠标题，实际 ${triggers.length}`)
+    await triggers[0].props.onClick()
+    const text = textOf(await renderSettings(world))
+    const failedLabel = world.dicts.zh['personas.loadFailed'].split('{')[0]
+    assert.ok(text.includes(failedLabel), `应显示加载失败提示，实际渲染：${text.slice(0, 240)}`)
+    assert.ok(text.includes('boom'), '失败原因要一并显示')
+    assert.ok(
+      !text.includes(world.dicts.zh['status.loading']),
+      '失败后不得继续显示「加载中...」（此前是空 catch，personas 永为 null）'
+    )
+    // 防空过：正常加载时不应误报失败
+    const ok = await boot()
+    const okClosed = await renderSettings(ok)
+    const okTrigger = findAll(okClosed, (n) => n.type === 'button' && textOf(n).includes(world.dicts.zh['group.personas']))[0]
+    await okTrigger.props.onClick()
+    const okText = textOf(await renderSettings(ok))
+    assert.ok(!okText.includes(failedLabel), '正常加载不应误报失败')
+  })
+
+  await check('C15 只改首尾空格不算「未保存的更改」（与服务端 trim 判据一致）', async () => {
+    // 服务端对字符串字段一律 trim 后再落盘，客户端若按原始串比较 dirty，就会出现
+    // 「敲了个空格 → 保存按钮亮起 → 保存成功却提示『配置无变化』」这种自相矛盾的状态。
+    const world = await boot()
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET'
+      ? { ok: true, config: { ...CONFIG, nickname: 'NickLi6' } }
+      : { ok: true, config: { ...CONFIG, nickname: 'NickLi6' }, changed: [] })
+    await world.controller.loadConfig()
+    for (let i = 0; i < 6; i++) await new Promise((r) => drainTick(r))
+
+    const find = async () => findAll(await renderSettings(world), (n) => n.type === 'input' && n.props?.id === 'soul-nickname')
+    const inputs = await find()
+    assert.equal(inputs.length, 1, `应有一个昵称输入框，实际 ${inputs.length}`)
+    inputs[0].props.onChange({ target: { value: '  NickLi6  ' } })
+    for (let i = 0; i < 4; i++) await new Promise((r) => drainTick(r))
+    assert.ok(
+      !textOf(await renderSettings(world)).includes(world.dicts.zh['status.unsaved']),
+      '只加首尾空格不应被判成「未保存的更改」'
+    )
+    // 防空过：真有改动时必须提示，否则上面那条等于恒真
+    const inputs2 = await find()
+    inputs2[0].props.onChange({ target: { value: 'NickLi6-改过' } })
+    for (let i = 0; i < 4; i++) await new Promise((r) => drainTick(r))
+    assert.ok(
+      textOf(await renderSettings(world)).includes(world.dicts.zh['status.unsaved']),
+      '真有改动时必须提示「有未保存的更改」'
+    )
+  })
+
+  await check('C16 人设卡片按宿主协议渲染：★ 生效标记、内置徽标、卡片堆叠与翻页', async () => {
+    // 这条补的是一个**覆盖空洞**：此前桩返回 `{ personas: [], activePersona: null }`
+    // （字段名与类型都与宿主不符），于是人设行渲染与 ★ 标记从未被执行过 —— 把桩改成
+    // 真实形状后，整套 C 系列仍全绿（实测），说明没有任何断言吃过这份数据。
+    // 宿主真实协议：personas 是由 mergePersonas 生成的**对象 map**（恒含 7 个内置），
+    // activeName 是「与当前配置匹配」的预设名（client:1235 读的就是它）。
+    const world = await boot({}, {
+      ok: true,
+      personas: {
+        苏格拉底式提问者: { style: 'professional', builtin: true },
+        我的自建: { style: 'roast', emoji: 'more' }
+      },
+      activeName: '我的自建'
+    })
+    const closed = await renderSettings(world)
+    const triggers = findAll(closed, (n) => n.type === 'button' && textOf(n).includes(world.dicts.zh['group.personas']))
+    assert.equal(triggers.length, 1, '应有一个「人设预设」分组标题')
+    await triggers[0].props.onClick()
+    const tree = await renderSettings(world)
+
+    // ① activeName → store.activePersona 这条链路必须真的通（字段名写错就全灭）
+    assert.equal(
+      world.controller.store.getSnapshot().activePersona,
+      '我的自建',
+      'activeName 未被写进 store.activePersona —— 字段名与宿主协议不符'
+    )
+
+    // ② 卡片堆叠一次只渲染限定张数（当前 + 左右各一），当前张带 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(' | ')}`)
+
+    // ③ 生效预设带 ★，非生效的不带（防空过：两个方向都要断言，否则「恒加★」也会过）
+    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}`)
+
+    // ⑤ 轮播交互：位置指示、圆点、翻页按钮与边界禁用（一次只见一张，这些是必需的补偿）
+    //
+    // 注意：**展开分组时轮播会自动定位到当前生效的那张**（新功能），因此这里一进来
+    // 就已经停在「我的自建」（数组第 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 () => {
+    // 该端点不返回 deliveryWarning；此前不清 error ⇒ 上一轮保存失败过的红色提示
+    // 会一直挂在设置页上，即使随后切预设成功。
+    const world = await boot()
+    world.routes['/api/soul/config'] = (call) => (call.method === 'GET' ? { ok: true, config: { ...CONFIG } } : false)
+    const failed = await world.controller.saveConfig({ style: 'casual' })
+    assert.equal(failed, undefined, '前置条件：保存失败应返回 undefined')
+    assert.equal(world.controller.store.getSnapshot().error, 'boom', '前置条件：失败原因应写进 store')
+    world.routes['/api/soul/personas/use'] = () => ({ ok: true, config: { ...CONFIG }, changed: ['style'], invalid: [] })
+    await world.controller.usePersona('任意')
+    assert.equal(world.controller.store.getSnapshot().error, null, '应用预设成功后不得残留上一轮的失败提示')
+  })
+} finally {
+  restoreTimers()
+}
+
+if (!assertCount('verify-client', passed, EXPECTED_ASSERTIONS)) process.exit(1)
+
+console.log(`\n全部通过：${passed} 项检查`)