@arcaneorion/dsh-model-channel-manager 0.3.12 → 0.3.14

package/README.md

@@ -126,7 +126,7 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 
 - 模型行「⚡测试」→ 弹窗输入自定义问题 + maxTokens → 发送
 - prompt 存 localStorage（`mcm_test_prompt`，pi 同款，全局共用）
-- host 用 `llm.stream({provider, model, messages, maxTokens})` 真实调用（与正式对话同链路）；60s 超时
+- host 用 `llm.stream({provider, model, messages, maxTokens})` 真实调用（与正式对话同链路）；45s 总时限（0.3.13 由 60s 下调，给终态写入留余量）
 - 结果：`status:'ok'`（ttftMs/latencyMs/text）或 `status:'error'`（code/error）
 - 模型行内显示 ⏳→✓/✗ 状态标签（hover 见详情）
 
@@ -187,6 +187,33 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 
 host 侧兜底：`rewireRoutes` 发现配置组数 > 实际路由数时 `console.warn` 列出被丢弃的组 ID（此前是静默丢弃——H08：3 组保存、路由只有 1 条，界面仍显示「已保存」）。允许清空全部组（空列表合法）。
 
+## 保存时的 revision 冲突（0.3.14：自噪声识别 + 自动重试）
+
+**症状**：保存后提示「部分保存：提供商配置 已生效；轮询组配置 失败——轮询组配置已被其他页面修改（版本冲突），请点「刷新」后重试」，且要点多次才成功。
+
+**根因**（dsh-settings 源码事实）：`describe()` 里
+
+```js
+raw = JSON.stringify([fiber.uid, schema.toJSON(), entry.options.config ?? {}])
+revision = previous.revision + Number(previous.raw !== raw)
+```
+
+**revision 就是「该行 raw config 的 JSON 指纹」**。而本插件的 settings 行同时承载健康投影——宿主每 5s 的 digest 叶写、`runtime`、`testResults` 都会改动该行 raw config，revision 因此不断前进。client 加载时记下的 revision 在几秒内必然过期，保存被 `settings/conflict` 拒绝：**提示里的「其他页面」其实是插件自己写的健康数据**。providers 走的是另一个行（`llm-pi-ai`），没有这种自噪声，所以它总是先成功——这正是「部分保存」的原因。
+
+**修法**：
+
+- client：写入前**重新读取 revision**（消除过期）；仍冲突时比较远端值与我们加载时的基线
+  （`groups`+`providerOrder` / `providers`，用键序无关的规范 JSON 比较）——
+  **远端没变 = 自噪声 → 用新 revision 重试（最多 3 次）；远端真的变了 → 才报冲突**。
+  既消除误报，也保留真正的多页面冲突保护（审计 F05 的语义）。
+- host：`digest` 内容未变时不写（60s 心跳保底），从源头减少 revision 噪声。
+
+回归：`tests/revision-conflict.test.cjs`。
+
+> 真正的根治是把健康/任务通道搬出 settings 行（审计建议的 Remote + storageDomain 路线）——
+> 那时本行 revision 只随用户配置变化，连重试都不需要。当前修法在不改通信架构的前提下
+> 同时消除了症状与误报。
+
 ## 密钥写入（凭据引用虚拟化）
 
 - 面板主视图只出现「API Key」输入框：**粘贴或输入后失焦即自动写入** DSH 凭据存储（`~/.dsh/.credentials.yaml`，0600，write-only 读不回），无手动按钮；清空输入框不会删除已存 key。上游 llm-pi-ai 的供应商 profile 只有 `apiKeyEnv` 一个密钥字段（凭据引用名），不存在内联 key 的选项——secrets 不进 settings.yaml、不随 `settings.describe` 下发，是有意的安全设计。
@@ -231,24 +258,37 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 - 30m/24h 健康视图是近似口径（按最近活跃过滤，数值为 7 天累计，UI 已标注）；精确分窗口
   需 host 出多份 digest
 
-### 0.3.12 审计已确认、尚未修（按严重度）
-
-均为 2026-10-01 只读审计结论（13 项），0.3.12 先修了其中最要命的两条（去重 guard、整树回写）：
-
-- **volatile 提交静默失败仍是放大器**：loader 的 `_commitVolatile` 在 `resolveConfig` 抛错时
-  只 `logger.warn` 后返回——document 已落盘、fiber 引用不更新、**不发 volatile-update**，
-  而宿主只在 volatile-update 里消费请求 → 请求被彻底忽略且无任何可见报错。当前 payload
-  校验通过，属潜在复发路径。建议：宿主加「未结算 nonce」兜底轮询 + 未消费显式日志。
-- **remount/dispose 会打断在飞的测试**：超时守卫挂在 `ctx.effect` 上，dispose 只 `clearTimeout`，
-  promise 永不 reject → `runModelTest` 挂死 → 终态永不写入（旧闭包的排队写入只进
-  `console.error`）。建议：守卫不挂 fiber effect，dispose 时补写 ABORTED 终态。
-- **60s（host）/66s（client）预算错配**：跑满 60s 时终态写入稍晚于 client giveUp。建议 host 收到
-  45s 或 client 放弃前比较 `lastTestHandledNonce` 再补一轮。
-- **health 写不带 `expectedRevision`**（配置域已带）：叶写后危害大幅降低（不同键互不覆盖），
-  但同一叶子仍无冲突检测。
-- 低危：`digest: []` 空数组会遮蔽 settings 里的旧 `records`；`migrateLegacyConfig` 直写未走
-  `outsideTransaction`（在事务内会抛 "cannot be nested" 并被空 catch 吞掉）；health-store 的
-  `eventKey = ts|provider|model` 会把同毫秒同渠道两笔当重复合并。
+### 0.3.13：2026-10-01 审计剩余项（已修）
+
+同一份只读审计（13 项）里，0.3.12 修了最要命的两条（去重 guard、整树回写），0.3.13 清掉其余：
+
+- **R3 remount/dispose 打断在飞测试**：`timed()` 守卫不再只在 dispose 时 `clearTimeout`——
+  那样 promise 永不 settle，`await Promise.race([inner.next(), guard.promise])` 直接挂死，
+  在飞测试既不结束也不写终态。现在 dispose 会主动 reject `ABORTED`，调用方走正常失败路径。
+  另外**启动时清扫**：新进程里任何 `status: running` 且无 `finishedAt` 的条目都是上次遗留的，
+  补写 `ABORTED` 终态；`running + finishedAt` 的僵尸条目按 `ok` 归一状态位
+  （纯函数 `selectStaleTestEntries` 导出，回归见 `tests/runtime-hardening.test.cjs`）。
+- **R2 volatile 提交静默失败（放大器）**：请求存在但既未认领也未结算时，
+  ① `handleTestRequest` 显式打日志（每个 nonce 一次，不再静默忽略）；
+  ② 新增 5s 兜底轮询 `sweepPendingTestRequest`，复用同一个消费判定，主动重试一次并留日志；
+  ③ `reloadFromConfig` 检测「health 子树运行时从有到无」并大声告警——这是 0.3.11
+  schema 兜底事故的形态，以前完全无声。
+- **#7 预算错配**：host 测试总时限 60s → 45s（client 轮询上限 ≈66s，旧值只留 6s 余量）；
+  client 放弃时还会比对 `lastTestHandledNonce`，区分第三种情况
+  `POLL_TIMEOUT_SETTLED`（host 已结算但结果条目未写入）。
+- **#6 notReady 退避**：释放认领后设 5s 退避窗口（测试/测速各自），期间任何
+  volatile-update 都不再消费——旧实现释放后会被立刻再消费，并发起多个 45s 上游请求。
+- **#13 迁移直写**：`migrateLegacyConfig` 改走 `bus.writeConfig`（`outsideTransaction` 包裹），
+  不再在 HMR 事务内直写（旧写法会抛 "cannot be nested" 并被空 catch 吞掉，只剩哨兵）。
+- **#11 digest 遮蔽**：`digest: []` 且 settings 仍有 `records` 时（domain 打开成功但迁移失败、
+  或 host 刚重启尚未投影）回落到 records 路径，页面显示旧流水而不是全 0。
+- **#10 health-store**：事件去重键由 `ts|provider|model` 扩成含 ok/code/延迟/token 的指纹
+  （同毫秒同渠道的两笔真实请求不再被当重复合并）；`putSpeedRows` 与 `migrateFrom` 的测速写入
+  并入同一条写链（不与事件追加交错）；`close()` 先排干写链再关 domain（不丢排队中的最后一笔）。
+
+**仍然未修（有意保留）**：health 子树写入不带 `expectedRevision`。叶写后危害已大幅降低
+（不同叶子互不覆盖），同一叶子的并发写本身是「后写者胜」的语义，加 revision 需要调用方
+持有并维护 revision，收益不抵复杂度；配置域（groups/providerOrder）仍然带 revision。
 
 ## 引擎超时与生命周期（0.3.3 重构：审计 F01/F02/F15 已修）
 
@@ -300,6 +340,11 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 29. **去重不能依赖 nonce 的数值单调性（0.3.12）**：`last = Math.max(lastTestHandledNonce, claimedNonce)` 看似「取最新」，实则假设了 nonce 单调递增——而 0.3.2 起 nonce 是随机 53-bit，**「上一轮 > 本轮」时（≈50%）判等失效**，同一 testRequest 在每次 `loader/volatile-update`（包括宿主自己每 5s 的 digest 回写触发的那次）都被重新消费。症状是两级：① 上游被真实重复调用（计费）；② 多次执行的结果写进同一条目（线上物证：同 nonce 一条记录同时带 `code TIMEOUT / 60000ms` 与 `ok:true / text/ttftMs`，单次执行不可能）。**规则：去重只做严格等值 + 已消费集合 + 已结算值 + 已有终态，任何「大小推断」都是错的**。释放认领（notReady 重放）时必须同时释放已消费集合，否则重放被自己的去重挡住。回归：`tests/task-dedup.test.cjs`（判定表直接调用生产导出 `shouldConsumeNonce`）。
 30. **整树读-改-写会把并发终态「回灌」成旧值（0.3.12 线上事故）**：health 子树的每次写入都曾是 `cur = healthOf(); update({health:{...cur, patch}})`——payload 是调用时刻的**整树快照**。只要它晚于并发的终态写落盘，`status` 就被改回 `running`；而 `settings.update` 是深合并（只覆盖出现的键、不删键），后写入的 `finishedAt/code/error` 反而被保留 → 条目变成「running + 终态字段」的僵尸，客户端只认 `status==='ok'|'error'` 就永远等不到终态，66s 后误报「host 可能未处理该请求」。**规则：settings 里的共享子树一律叶写**（patch 命中的键逐个 `set`；单键结果用 `writeHealthLeaf(['testResults', nonce], value)`；修剪用 `unset` 而非整字典覆盖），client 侧同样不得「describe 快照 + 整树回写」。另：客户端终态判定要接受 `finishedAt`——状态位可能被写坏，但已经发生的终态字段不会消失。回归：`tests/testresult-fallback.test.cjs`（F4 直接复刻事故时序）。
 
+31. **超时守卫 dispose 时必须 settle promise（0.3.13，审计 R3）**：`timed()` 的 guard 若在 fiber dispose 时只 `clearTimeout`，promise 永不 reject——`await Promise.race([inner.next(), guard.promise])` 就永久挂住，在飞测试既不结束也不写终态，客户端只能等到 66s 假超时（表现与「host 未处理」一模一样）。**规则：任何挂在 `ctx.effect` 上的定时器，dispose 时不仅要清定时器，还要让等待它的 promise settle**（这里 reject `ABORTED`），否则卸载路径会留下永久悬挂的 await。配套：新进程启动时清扫上次遗留的 `running` 条目（补 `ABORTED` 终态）——进程内在飞任务都有 fiber 生命周期，重启后见到的 running 一定是遗留的。回归：`tests/runtime-hardening.test.cjs`。
+32. **静默失败要有出口（0.3.13，审计 R2）**：loader 的 `_commitVolatile` 在 `resolveConfig` 抛错时只 `logger.warn` 后返回 true——document 已落盘、fiber 引用不更新、**不发 `loader/volatile-update`**。而本插件的任务通道只在 volatile-update 里消费请求，于是请求被彻底忽略、客户端 66s 超时，宿主侧却「什么都没发生」。同理 `.loose(true)` 的 schema 兜底会把整棵 volatile 子树换成空对象而不报错（踩坑 28）。**规则：凡是「静默丢弃用户动作」的路径都要有可见出口**——① 未消费的请求打日志（每 nonce 一次）；② 周期性兜底重试（5s，复用同一消费判定，每 nonce 一次）；③ 关键子树从有到无时告警。回归：`tests/runtime-hardening.test.cjs`。
+
+33. **settings 的 revision 是「raw config 的 JSON 指纹」，会被插件自己的健康写入推高（0.3.14）**：`describe()` 里 `revision += raw !== previous.raw`，`raw = JSON.stringify([fiber.uid, schema.toJSON(), entry.options.config])`。本插件的行同时承载健康投影（digest 每 5s、runtime、testResults），所以 client 手里的 revision 几秒内必然过期，保存被 `settings/conflict` 拒绝，提示却是「已被其他页面修改」——**其实「其他页面」就是插件自己**；providers 在另一个行（llm-pi-ai）没有自噪声，于是表现为「部分保存：提供商成功、轮询组失败，点多次才成功」。两条教训：① **带 revision 的写入必须「写入前重读」**，加载时记下的 revision 只在「该行没有其他写入者」时才有效；② 冲突要**分类**——比较远端值与加载基线（键序无关的规范 JSON），远端没变就是自噪声（重试），真的变了才是冲突（报错）。根治方向是把高频数据搬出该行（Remote/storageDomain）。回归：`tests/revision-conflict.test.cjs`。
+
 ## 0.3.11 修复后的自愈路径（无需手工清库）
 
 重启后：schema 接受历史字符串 nonce → `records` 重新可见 → `migrateFrom` 把旧流水**合并去重**进 domain（`my-opencode-go` 桶已有新事件，按 `ts|provider|model` 去重后并入）→ path-ops 真删除 settings 里的 `records` → digest 重算包含历史。日志会打印 `legacy health imported into domain and cleared from settings`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcaneorion/dsh-model-channel-manager",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "type": "module",
   "main": "src/index.js",
   "scripts": {

package/src/client.js

@@ -566,11 +566,13 @@ window.__ModuleLoader__.load({
       const pollTest = (nonce, provider, model, attempt = 0) => {
         if (!apiRef) return
         const key = provider + '::' + model
-        // host 侧测试超时 60s，约 55 次 × 1.2s ≈ 66s 后放弃，避免结果被覆盖时无限轮询。
-        // 0.3.12：放弃时区分「host 没写结果」与「host 还在跑」，不再一律甩锅「未处理/需重启」。
-        const giveUp = (e) => setTestStates((s) => Object.assign({}, s, { [key]: (e && e.status === 'running')
-          ? { status: 'error', code: 'POLL_TIMEOUT_RUNNING', error: '测试仍在执行（约 66 秒未返回结果）：host 已收到请求，可能是渠道慢或上游挂起；稍后可在健康统计里核对' }
-          : { status: 'error', code: 'POLL_TIMEOUT', error: '等待测试结果超时：host 未写入结果（可能 host 未重启到新版，或结果写入失败）' } }))
+        // host 侧测试超时 45s（0.3.13 从 60s 下调，给终态写入留出余量），
+        // 约 55 次 × 1.2s ≈ 66s 后放弃。放弃时按现场分三种提示，不再一律甩锅「未处理」。
+        const giveUp = (e, settledHere) => setTestStates((s) => Object.assign({}, s, { [key]: settledHere
+          ? { status: 'error', code: 'POLL_TIMEOUT_SETTLED', error: 'host 已完成本次测试但结果条目未能写入（写入失败或被覆盖）：请重试，若反复出现请查看宿主日志' }
+          : (e && e.status === 'running')
+            ? { status: 'error', code: 'POLL_TIMEOUT_RUNNING', error: '测试仍在执行（约 66 秒未返回结果）：host 已收到请求，可能是渠道慢或上游挂起；稍后可在健康统计里核对' }
+            : { status: 'error', code: 'POLL_TIMEOUT', error: '等待测试结果超时：host 未写入结果（可能 host 未重启到新版，或结果写入失败）' } }))
         apiRef.settings.describe({}).then((resp) => {
           const r = resp && resp.result ? resp.result : resp
           const d = r && r.value !== undefined ? r.value : r
@@ -585,7 +587,9 @@ window.__ModuleLoader__.load({
             const norm = (e.status === 'ok' || e.status === 'error') ? e : Object.assign({}, e, { status: e.ok === true ? 'ok' : 'error' })
             setTestStates((s) => Object.assign({}, s, { [key]: norm }))
           } else if (attempt >= 55) {
-            giveUp(e)
+            // host 已结算（lastTestHandledNonce === 自己的 nonce）但结果条目不在 → 写入失败
+            const settled = ns && ns.value ? ns.value.lastTestHandledNonce : undefined
+            giveUp(e, settled !== undefined && settled !== null && String(settled) === String(nonce))
           } else {
             setTimeout(() => pollTest(nonce, provider, model, attempt + 1), 1200)
           }
@@ -1097,7 +1101,12 @@ window.__ModuleLoader__.load({
       // digest 是 7 天全窗口聚合；30m/24h 视图按 lastTs 近似（lastTs 在窗口内才计入），
       // 精细窗口统计属后续增强（需要 host 按窗口出多份 digest）。
       // 旧 host 兼容：无 digest 字段时走原始 records 路径（升级窗口不断供）。
-      const digestRows = Array.isArray(health.digest) ? health.digest : null
+      // #11（审计）：digest 是空数组时不要遮蔽 settings 里仍存在的 records——
+      // 典型场景是 domain 打开成功但迁移失败（host 保留旧流水不清理）或 host 刚重启
+      // 尚未投影。此时回落到 records 路径，页面显示旧流水而不是全 0。
+      const rawRecords = health.records || {}
+      const hasRawRecords = Object.keys(rawRecords).some((k) => Array.isArray(rawRecords[k]) && rawRecords[k].length > 0)
+      const digestRows = (Array.isArray(health.digest) && (health.digest.length > 0 || !hasRawRecords)) ? health.digest : null
       // 按 provider 分组
       const byProvider = new Map()
 
@@ -1426,6 +1435,46 @@ window.__ModuleLoader__.load({
         if (r && r.ok === false) throw new Error((r.error && (r.error.message || r.error)) || 'request failed')
         return r && r.value !== undefined ? r.value : r
       }
+      // 冲突判定：宿主以 settings/conflict 拒绝（dsh-settings 的 SettingsConflictError）
+      const isConflict = (err) => !!(err && (err.code === 'settings/conflict' || /conflict/i.test(String(err.message || ''))))
+      // 规范 JSON（对象键排序）——用于「远端是否真的改过我们关心的字段」的比较，
+      // 不受键序影响（providers/groups 的对象键序在落盘与投影之间可能不同）
+      const canonicalJson = (v) => {
+        if (Array.isArray(v)) return '[' + v.map(canonicalJson).join(',') + ']'
+        if (v && typeof v === 'object') return '{' + Object.keys(v).sort().map((k) => JSON.stringify(k) + ':' + canonicalJson(v[k])).join(',') + '}'
+        return JSON.stringify(v === undefined ? null : v)
+      }
+      const sameJson = (a, b) => canonicalJson(a) === canonicalJson(b)
+      const readNsDesc = async (ns) => {
+        const resp = await apiRef.settings.describe({})
+        const d = unwrap(resp)
+        return ((d && d.namespaces) || []).find((n) => n && n.ns === ns) || null
+      }
+      // 带 revision 的保存 + 「自噪声冲突」自动重试（0.3.14）：
+      //
+      // 为什么必须这样：本插件的 settings 行（model-channel-manager）同时承载健康投影，
+      // 宿主每 5s 的 digest 叶写都会改动该行的 raw config；而 describe() 的 revision
+      // 正是「raw config 的 JSON 指纹」（dsh-settings：revision += raw !== previous.raw）。
+      // 于是 client 手里那份 revision 在几秒内必然过期，保存被 settings/conflict 拒绝——
+      // 提示里的「其他页面修改」其实是插件自己写的健康数据。
+      //
+      // 策略：① 每次写入前取最新 revision（消除过期）；② 仍冲突时比较远端值与我们加载时
+      // 的基线：没变 = 纯 revision 噪声 → 用新 revision 重试；真的变了 = 真冲突 → 报错。
+      const saveWithRevisionRetry = async ({ ns, baseline, remoteOf, write, conflictMessage, attempts = 3 }) => {
+        let lastError = null
+        for (let attempt = 0; attempt < attempts; attempt++) {
+          const desc = await readNsDesc(ns).catch(() => null)
+          const rev = desc && typeof desc.revision === 'number' ? desc.revision : undefined
+          const r = await write(rev)
+          if (!(r && r.ok === false)) return r
+          lastError = r.error
+          if (!isConflict(r.error)) throw new Error((r.error && (r.error.message || r.error)) || (ns + ' save failed'))
+          const now = await readNsDesc(ns).catch(() => null)
+          if (!sameJson(remoteOf(now), baseline)) throw new Error(conflictMessage)
+          // 远端未变：属于插件自身健康写入造成的 revision 噪声 → 取新 revision 重试
+        }
+        throw new Error(conflictMessage.replace(/，请点「刷新」后重试/, '') + '（已自动重试 ' + attempts + ' 次仍未成功）' + (lastError ? '：' + String(lastError.message || lastError) : ''))
+      }
 
       // 按持久化的 providerOrder 重排 providers 的键序：settings-file 的 patchNode
       // 对 map 键序盲（拖拽纯重排在文件层是零 diff），顺序由 model-channels ns 里的
@@ -1645,33 +1694,43 @@ window.__ModuleLoader__.load({
           for (const k of allKeys) ops.push({ op: 'unset', path: ['providers', k] })
           for (const k of keys) ops.push({ op: 'set', path: ['providers', k], value: cleanProviders[k] })
           if (ops.length === 0) return Promise.resolve()
-          // F05：带 revision 保存——llm-pi-ai 是独立 settings 行，冲突由宿主以
-          // settings/conflict 拒绝；提示里给「刷新后重试」指引而不是静默覆盖
-          return apiRef.settings.mutate({ ns: 'llm-pi-ai', ops, expectedRevision: (state && state.nsRevisions && state.nsRevisions.piAi) || undefined }).then((resp) => {
-            const r = resp && resp.result ? resp.result : resp
-            if (r && r.ok === false) {
-              const conflict = r.error && (r.error.code === 'settings/conflict' || /conflict/i.test(String(r.error.message || '')))
-              throw new Error(conflict ? 'llm-pi-ai 配置已被其他页面修改（版本冲突），请点「刷新」后重试' : ((r.error && (r.error.message || r.error)) || 'llm-pi-ai save failed'))
-            }
-            return r
+          // F05 + 0.3.14：带 revision 保存；冲突若只是宿主侧 revision 噪声（远端 providers
+          // 与我们加载时一致）则自动重试，真的被别处改过才提示「刷新后重试」。
+          return saveWithRevisionRetry({
+            ns: 'llm-pi-ai',
+            baseline: (state && state.providers) || {},
+            remoteOf: (desc) => (desc && desc.value && desc.value.providers) || {},
+            write: (rev) => apiRef.settings.mutate({ ns: 'llm-pi-ai', ops, expectedRevision: rev }).then((resp) => {
+              const r = resp && resp.result ? resp.result : resp
+              return r
+            }),
+            conflictMessage: 'llm-pi-ai 配置已被其他页面修改（版本冲突），请点「刷新」后重试',
           })
         })() : Promise.resolve()
         // 顺序持久化：patchNode 对 map 键序盲，拖拽顺序写进 providerOrder 数组（同一次 update 落盘）；
         // 即使 channelsDraft 为空（无轮询组），只要 draft 非空也要写——这是排序的唯二持久化时机
         const orderPatch = draft ? { providerOrder: Object.keys(cleanProviders) } : {}
-        const p2 = apiRef.settings.update({
-          ns: 'model-channels',
-          expectedRevision: (state && state.nsRevisions && state.nsRevisions.channels) || undefined,
+        const channelsPatch = Object.assign({
           // 命名单一身份：写入时统一 virtualModel.name = 组 id——旧的独立呈现名
           // （如遗留的 group-1）在下一次保存时自动归一，无需迁移
-          patch: Object.assign({ groups: (channelsDraft || []).map((g) => Object.assign({}, g, { virtualModel: Object.assign({}, g.virtualModel, { name: g.id }) })) }, orderPatch)
-        }).then((resp) => {
-          const r = resp && resp.result ? resp.result : resp
-          if (r && r.ok === false) {
-            const conflict = r.error && (r.error.code === 'settings/conflict' || /conflict/i.test(String(r.error.message || '')))
-            throw new Error(conflict ? '轮询组配置已被其他页面修改（版本冲突），请点「刷新」后重试' : ((r.error && (r.error.message || r.error)) || 'model-channels save failed'))
-          }
-          return r
+          groups: (channelsDraft || []).map((g) => Object.assign({}, g, { virtualModel: Object.assign({}, g.virtualModel, { name: g.id }) }))
+        }, orderPatch)
+        // 0.3.14：本行同时承载健康投影，宿主每 5s 的 digest 叶写会不断推高它的 revision
+        // （revision = raw config 的 JSON 指纹）——旧实现用加载时的旧 revision，几乎必然
+        // 撞 settings/conflict，于是出现「部分保存：轮询组配置失败……点击多次才能成功」。
+        // 现在每次写入前取最新 revision；冲突时只有远端 groups/providerOrder 真的变了才报冲突。
+        const p2 = saveWithRevisionRetry({
+          ns: 'model-channels',
+          baseline: { groups: channels || [], providerOrder: (state && state.providerOrder) || [] },
+          remoteOf: (desc) => ({
+            groups: (desc && desc.value && desc.value.groups) || [],
+            providerOrder: (desc && desc.value && desc.value.providerOrder) || [],
+          }),
+          write: (rev) => apiRef.settings.update({ ns: 'model-channels', expectedRevision: rev, patch: channelsPatch }).then((resp) => {
+            const r = resp && resp.result ? resp.result : resp
+            return r
+          }),
+          conflictMessage: '轮询组配置已被其他页面修改（版本冲突），请点「刷新」后重试',
         })
         // F06（审计 C10，0.3.8）：两域用 allSettled 而非 all——半成功不再「整单失败」
         // 掩盖已提交的那半。各自报告，失败域给出明确指引；部分成功时提示里列明

package/src/health-store.js

@@ -67,8 +67,17 @@ const healthDomainSpec = defineDomain({
   },
 });
 
-/** 事件去重键：同一笔在 settings 与 domain 之间合并时不重复计。 */
-const eventKey = (e) => `${e.ts}|${e.provider}|${e.model}`;
+/**
+ * 事件去重键：同一笔在 settings 与 domain 之间合并时不重复计。
+ * 0.3.13（审计 #10）：旧键只有 `ts|provider|model`，同一毫秒同渠道的两笔真实请求
+ * 会被当成同一笔合并掉。把判定性字段一起纳入指纹——同毫秒 + 同渠道 + 同结果形态
+ * 的两笔在语义上本就不可区分；真正不同的两笔（成功率/延迟/token 不同）不会再被吞。
+ */
+const eventKey = (e) => [
+  e.ts, e.provider, e.model, e.ok ? 1 : 0, e.code || '',
+  e.ttftMs ?? '', e.latencyMs ?? '',
+  e.inputTokens ?? '', e.outputTokens ?? '', e.cacheReadTokens ?? '', e.cacheWriteTokens ?? '',
+].join('|');
 
 /**
  * HealthStore：封装 domain 读写 + 保留策略 + 聚合。
@@ -98,6 +107,9 @@ export class HealthStore {
   /** effect 用：domain 关闭（写入队列排干后释放）。 */
   async close() {
     if (this.ready === null) return;
+    // 0.3.13（审计 #10）：先排干类内写链再关 domain——旧实现直接 close，
+    // 排队中的 append/迁移写入可能在 domain 关闭后才执行（丢最后一笔）。
+    await this.eventChain.catch(() => {});
     const domain = await this.ready.catch(() => null);
     this.ready = null;
     this.events = null;
@@ -132,10 +144,14 @@ export class HealthStore {
     });
   }
 
-  /** 整组测速结果替换写入。 */
+  /** 整组测速结果替换写入。0.3.13（审计 #10）：也排入同一条写链，
+   * 避免与迁移/追加写入交错（快照语义下后写者胜，交错会写出半新半旧的桶）。 */
   async putSpeedRows(groupId, rows) {
     if (this.speed === null) return;
-    await this.speed.put(groupId, { rows });
+    await this.enqueueEvent(async () => {
+      if (this.speed === null) return;
+      await this.speed.put(groupId, { rows });
+    });
   }
 
   /** 读全部事件桶（迁移/聚合用）。 */
@@ -187,8 +203,11 @@ export class HealthStore {
     }
     for (const [groupId, rows] of Object.entries(speedResults || {})) {
       if (!Array.isArray(rows) || rows.length === 0) continue;
-      if (this.speed.get(groupId) !== undefined) continue;
-      await this.speed.put(groupId, { rows });
+      await this.enqueueEvent(async () => {
+        if (this.speed === null) return;
+        if (this.speed.get(groupId) !== undefined) return; // domain 已有该组结果：以 domain 为准
+        await this.speed.put(groupId, { rows });
+      });
     }
     return true;
   }

package/src/index.js

@@ -62,6 +62,24 @@ export function shouldConsumeNonce({ consumed, key, claimed, settled, hasTermina
     if (key === claimed || key === settled) return false;
     return !consumed.has(key);
 }
+/**
+ * 启动清扫的分类（纯函数）：新进程里已存在的测试条目分为两类——
+ *   aborted  : status=running 且没有 finishedAt = 上次进程遗留的在飞任务（重载打断），
+ *              必须补写 ABORTED 终态，否则客户端只会等到 66s 假超时（审计 R3）；
+ *   repaired : status=running 但有 finishedAt（终态字段已在）= status 被并发整树回写
+ *              改坏的僵尸条目，按 ok 归一状态位（审计 #2 的线上物证形态）。
+ */
+export function selectStaleTestEntries(testResults) {
+    const aborted = [];
+    const repaired = [];
+    for (const [key, e] of Object.entries(testResults || {})) {
+        if (!e || typeof e !== 'object') continue;
+        if (e.status !== 'running') continue;
+        if (!e.finishedAt) aborted.push(key);
+        else if (e.ok === true || e.code || e.error) repaired.push(key);
+    }
+    return { aborted, repaired };
+}
 export function apply(ctx, config) {
     // 本行在 profile 中的 entry id 就是 settings 命名空间；缺失时回落到包名。
     const SELF_NS = (ctx.fiber && ctx.fiber.entry && ctx.fiber.entry.options && ctx.fiber.entry.options.id) || 'model-channel-manager';
@@ -109,14 +127,25 @@ export function apply(ctx, config) {
         return g;
     };
     // ---------- 可取消超时（避免 Promise.race 留下孤儿定时器） ----------
+    // 0.3.13（审计 R3）：guard 不能只在 dispose 时 clearTimeout。
+    // dispose（= fiber 卸载/重载）时若只清定时器，promise 永不 settle，
+    // `await Promise.race([inner.next(), guard.promise])` 就永远挂住：
+    // 在飞测试既不结束也不写终态，客户端 66s 后得到假超时。
+    // 现在 dispose 会主动 reject（ABORTED），调用方走正常失败路径。
     const timed = (ms, makeError) => {
         let rejectFn;
+        let settled = false;
+        let timer = null;
         const promise = new Promise((_, reject) => { rejectFn = reject; });
-        const dispose = ctx.effect(() => {
-            const timer = setTimeout(() => rejectFn(makeError()), ms);
-            return () => clearTimeout(timer);
+        const fire = (err) => { if (settled) return; settled = true; rejectFn(err); };
+        ctx.effect(() => {
+            timer = setTimeout(() => fire(makeError()), ms);
+            return () => {
+                if (timer !== null) clearTimeout(timer);
+                fire({ code: 'ABORTED', message: 'plugin reloaded while this attempt was in flight' });
+            };
         }, 'model-channel timeout guard');
-        return { promise, dispose };
+        return { promise, dispose: () => { if (timer !== null) clearTimeout(timer); settled = true; } };
     };
     // ---------- 配置归一化（与动态原型逐行一致） ----------
     function normalizeConfig(raw) {
@@ -894,9 +923,11 @@ export function apply(ctx, config) {
     // ---------- 单模型真实请求测试（client 经 settings 总线下发，走 DSH 真实 llm.stream 链路） ----------
     async function runModelTest(provider, model, prompt, maxTokens) {
         const llm = ctx.llm;
-        // F15（与 measureCandidate 同一模式）：总时限 60s（旧行为每 chunk 重置 guard，
+        // F15（与 measureCandidate 同一模式）：总时限 45s（旧行为每 chunk 重置 guard，
         // 持续输出的请求永不超时而 client 已放弃）+ 超时 abort 上游 + 统一 finally 关闭。
-        const MODEL_TEST_TOTAL_MS = 60000;
+        // 0.3.13：60s → 45s。client 轮询上限约 66s，60s 的 host 预算只留 6s 余量给
+        // 「终态写入 + 下一次 describe」，跑满就会撞上假超时（审计 #7）。
+        const MODEL_TEST_TOTAL_MS = 45000;
         const controller = new AbortController();
         const deadline = Date.now() + MODEL_TEST_TOTAL_MS;
         const inner = llm.stream({ provider, model, messages: [{ role: 'user', content: [{ type: 'text', text: prompt || '你好' }] }], maxTokens: maxTokens || 512, sessionId: 'mcm-modeltest-' + Date.now(), signal: controller.signal });
@@ -972,6 +1003,55 @@ export function apply(ctx, config) {
             await closeInner();
         }
     }
+    // 启动清扫（审计 R3）：新进程里任何「status running 但没有 finishedAt」的测试条目
+    // 必然是上一次进程遗留的（进程内在飞任务都有 fiber 生命周期，重载会打断它们，
+    // 旧闭包的收尾写入往往以 "Configuration entry is no longer available" 失败）。
+    // 补写 ABORTED 终态，客户端就不必等到 66s 假超时。
+    // 同时修复「running + finishedAt」的僵尸条目（status 被并发整树回写改坏），
+    // 按 ok 归一状态位。
+    const sweepStaleTestResults = () => {
+        if (bus === null) return;
+        const all = healthOf().testResults || {};
+        const { aborted, repaired } = selectStaleTestEntries(all);
+        for (const key of aborted) {
+            bus.writeHealthLeaf(['testResults', key], Object.assign({}, all[key], {
+                status: 'error', code: 'ABORTED',
+                error: 'host 在测试执行期间重启/重载，结果未写入；请重试',
+                finishedAt: Date.now(),
+            })).catch((err) => console.warn('[model-channel-manager] stale test result sweep failed:', err && err.message));
+        }
+        for (const key of repaired) {
+            bus.writeHealthLeaf(['testResults', key], Object.assign({}, all[key], { status: all[key].ok === true ? 'ok' : 'error' }))
+                .catch((err) => console.warn('[model-channel-manager] zombie test result repair failed:', err && err.message));
+        }
+        if (aborted.length > 0 || repaired.length > 0)
+            console.log('[model-channel-manager] test results swept after restart: aborted =', aborted.length, ', repaired =', repaired.length);
+    };
+    // 兜底重试（审计 R2）：testRequest 存在、却既没被认领也没结算 —— 典型是 loader 的
+    // volatile 提交被静默拒绝（document 落盘、fiber 引用不更新、不发 volatile-update），
+    // 请求会被彻底忽略。这里每个 nonce 主动重试一次并留下日志，不再无声失败。
+    const sweepPendingTestRequest = () => {
+        if (bus === null) return;
+        const health = healthOf();
+        const req = health.testRequest;
+        const key = nonceKey(req && req.nonce);
+        if (key === null) return;
+        const entry = (health.testResults || {})[key];
+        const hasTerminal = !!(entry && (entry.finishedAt || entry.status === 'ok' || entry.status === 'error'));
+        // 复用与消费路径同一个（已被测试覆盖的）判定：返回 true = 这个请求还没被消费
+        const needsSweep = shouldConsumeNonce({
+            consumed: consumedTestNonces,
+            key,
+            claimed: nonceKey(claimedTestNonce),
+            settled: settledNonceKey(health.lastTestHandledNonce),
+            hasTerminal,
+        });
+        if (!needsSweep || pendingSweepAttempted.has(key)) return;
+        markConsumed(pendingSweepAttempted, key);
+        console.warn('[model-channel-manager] testRequest nonce', key,
+            '既未结算也未消费——疑似 volatile 提交被静默拒绝，主动重试一次（若仍无结果，请看宿主 stdout 的 loader 警告）');
+        reloadFromConfig(false);
+    };
     function handleTestRequest(next) {
         const req = next.testRequest;
         // nonce 接受 number（现行 client 的随机 53-bit 整数）与 string（0.3.2–0.3.8 的 UUID）
@@ -985,9 +1065,26 @@ export function apply(ctx, config) {
         // 终态判定用 finishedAt（写入后不会被覆盖），不只信 status：
         // 整树快照回写曾把 status 改回 running 却保留 finishedAt/code/error（0.3.11 事故）。
         const hasTerminal = !!(entry && (entry.finishedAt || entry.status === 'ok' || entry.status === 'error'));
-        if (!req || typeof req.provider !== 'string' || typeof req.model !== 'string'
-            || !shouldConsumeNonce({ consumed: consumedTestNonces, key: reqKey, claimed: claimedKey, settled, hasTerminal }))
+        if (!req || typeof req.provider !== 'string' || typeof req.model !== 'string' || reqKey === null) {
+            // 字段非法：显式记一次，别再静默吞掉（审计 R2）
+            if (req && reqKey !== null && !warnedTestNonces.has(reqKey)) {
+                markConsumed(warnedTestNonces, reqKey);
+                console.warn('[model-channel-manager] testRequest 字段非法，已忽略（需要 provider/model/nonce）:', JSON.stringify(req).slice(0, 200));
+            }
             return;
+        }
+        if (Date.now() < testBackoffUntil) return; // 退避窗口内不消费（等重放）
+        if (!shouldConsumeNonce({ consumed: consumedTestNonces, key: reqKey, claimed: claimedKey, settled, hasTerminal })) {
+            // 未消费的显式解释：请求存在但既没被认领、也没终态 → 多半是 volatile 提交被
+            // loader 静默拒绝（document 已落盘、fiber 引用不更新、不发 volatile-update，
+            // 审计 R2），此时请求会被彻底忽略且没有任何可见报错。
+            if (!hasTerminal && reqKey !== claimedKey && !warnedTestNonces.has(reqKey)) {
+                markConsumed(warnedTestNonces, reqKey);
+                console.warn('[model-channel-manager] testRequest 未被消费: nonce', reqKey,
+                    '（已结算或已消费命中）——若本次测试始终没有结果，检查宿主 stdout 是否有 loader 的 "volatile config update failed"');
+            }
+            return;
+        }
         markConsumed(consumedTestNonces, reqKey);
         claimedTestNonce = reqNonce;
         // nonce 的落盘推迟到本次测试得出结论之后：只有「真跑过」才算 handled。
@@ -1037,6 +1134,8 @@ export function apply(ctx, config) {
                 // 凭据服务尚未就绪（典型是启动瞬间的重放）：不写成假 error，释放认领并延后重试
                 claimedTestNonce = null;
                 releaseConsumed(consumedTestNonces, reqKey); // 释放后才能靠重放再消费
+                releaseConsumed(warnedTestNonces, reqKey);
+                testBackoffUntil = Date.now() + 5000;       // 退避窗口：期间任何 volatile-update 都不再消费
                 scheduleReplay('test', () => reloadFromConfig(false));
                 return;
             }
@@ -1078,6 +1177,8 @@ export function apply(ctx, config) {
     // digest：写进 settings health 子树的小投影（client 健康页渲染用）。
     // 聚合上移 host，client 不再拉原始流水全量 describe——settings 里不再出现 records。
     let digestTimer = null;
+    let lastDigestJson = null;   // 上次落盘的 digest 内容（相同则跳过，减少 revision 噪声）
+    let lastDigestWriteAt = 0;
     const DIGEST_INTERVAL = 5000;
     const buildDigest = () => {
         // 与旧 client HealthPanel 聚合口径一致：total/success/ttft/latency/token（计费口径
@@ -1121,7 +1222,16 @@ export function apply(ctx, config) {
     const flushDigest = () => {
         digestTimer = null;
         if (bus !== null) {
-            bus.writeHealth({ digest: buildDigest(), digestAt: Date.now() }).catch(() => { });
+            const digest = buildDigest();
+            // 0.3.14：内容没变就不写。settings 行的 revision 是 raw config 的 JSON 指纹
+            // （dsh-settings describe：revision += raw !== previous.raw），每一次无意义的写
+            // 都会让 client 手里的 revision 过期，表现为保存时的 settings/conflict。
+            // 60s 心跳保证 digestAt 不会永远停住。
+            const json = JSON.stringify(digest);
+            if (json === lastDigestJson && Date.now() - lastDigestWriteAt < 60000) return;
+            lastDigestJson = json;
+            lastDigestWriteAt = Date.now();
+            bus.writeHealth({ digest, digestAt: Date.now() }).catch(() => { });
         }
     };
     const scheduleDigest = () => {
@@ -1189,9 +1299,16 @@ export function apply(ctx, config) {
     // 回归见 tests/task-dedup.test.cjs。
     let claimedTestNonce = null; // string UUID 或旧数字；null = 未认领
     let claimedSpeedNonce = null; // string UUID 或旧数字；null = 未认领
+    let lastHealthKeyCount = -1;  // health 子树键数（用于探测「被兜底清空」，审计 R2/#4）
     const consumedTestNonces = new Set();  // 已消费过的 nonce 字符串键（含本次）
     const consumedSpeedNonces = new Set();
+    const warnedTestNonces = new Set();    // 每个 nonce 只提醒一次（防日志刷屏）
+    const pendingSweepAttempted = new Set(); // 兜底重试每个 nonce 只做一次
     const CONSUMED_NONCE_CAP = 256; // 上限：只用于防重复消费，不需要无限历史
+    // notReady（凭据服务未就绪）释放认领后的退避窗口：期间不再消费，等 scheduleReplay 到点。
+    // 否则释放后任何一次 volatile-update 都会立刻再消费，并发起多个 60s 上游请求（审计 #6）。
+    let testBackoffUntil = 0;
+    let speedBackoffUntil = 0;
     const markConsumed = (set, key) => {
         set.add(key);
         if (set.size > CONSUMED_NONCE_CAP) {
@@ -1223,6 +1340,13 @@ export function apply(ctx, config) {
         const cfg = cfgOf();
         state.config = clone(cfg) || { groups: [] };
         const health = healthOf();
+        // 意外清空告警（审计 R2/#4）：health 子树本来有内容，运行时却变成空对象 =
+        // schema 校验失败被 .loose(true) 兜底（0.3.11 事故形态），必须大声报出来。
+        const healthKeys = Object.keys(health || {}).length;
+        if (healthKeys === 0 && lastHealthKeyCount > 0) {
+            console.warn('[model-channel-manager] health 子树在运行时变空（上一轮有 ' + lastHealthKeyCount + ' 个键）——极可能是 schema 校验失败被 .loose(true) 静默兜底，请检查最近一次写入的字段类型');
+        }
+        lastHealthKeyCount = healthKeys;
         state.records = healthStore !== null
             ? clone(healthStore.allEventBuckets())
             : clone(health.records || {});
@@ -1247,6 +1371,7 @@ export function apply(ctx, config) {
         const speedKey = nonceKey(req && req.nonce);
         const speedClaimed = nonceKey(claimedSpeedNonce);
         const speedSettled = settledNonceKey(health.lastHandledNonce);
+        if (req && typeof req.group === 'string' && Date.now() < speedBackoffUntil) return;
         if (req && typeof req.group === 'string'
             && shouldConsumeNonce({ consumed: consumedSpeedNonces, key: speedKey, claimed: speedClaimed, settled: speedSettled, hasTerminal: false })) {
             markConsumed(consumedSpeedNonces, speedKey);
@@ -1263,6 +1388,7 @@ export function apply(ctx, config) {
                     if (r && r.deferred) {
                         claimedSpeedNonce = null;
                         releaseConsumed(consumedSpeedNonces, speedKey);
+                        speedBackoffUntil = Date.now() + 5000; // 退避：别让 volatile-update 立刻再消费
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -1272,6 +1398,7 @@ export function apply(ctx, config) {
                     if (notReady(e)) {
                         claimedSpeedNonce = null;
                         releaseConsumed(consumedSpeedNonces, speedKey);
+                        speedBackoffUntil = Date.now() + 5000; // 退避：同上
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -1321,11 +1448,16 @@ export function apply(ctx, config) {
         const writeHealthOps = (ops) => enqueueHealthWrite(async () => outsideTransaction(() => settings.mutate(SELF_NS, ops, undefined)));
         // 单叶写入：把 value 精确写到 health.<path...>，不读、不带任何快照
         const writeHealthLeaf = (path, value) => enqueueHealthWrite(async () => outsideTransaction(() => settings.mutate(SELF_NS, [{ op: 'set', path: ['health', ...path], value }], undefined)));
+        // 行级配置写入（groups 等）：也必须切出 HMR 事务——migrateLegacyConfig 可能在
+        // loader 回调链里被调用，事务内直写会抛 "HMR transactions cannot be nested"
+        // 并被空 catch 吞掉，只剩哨兵、旧配置永久不迁（审计 #13）。
+        const writeConfig = (patch) => enqueueHealthWrite(async () => outsideTransaction(() => settings.update(SELF_NS, patch, undefined)));
         bus = {
             settings,
             writeHealth,
             writeHealthOps,
             writeHealthLeaf,
+            writeConfig,
             cfgScope: { get: () => cfgOf() },
             healthScope: { get: () => healthOf() },
         };
@@ -1334,6 +1466,8 @@ export function apply(ctx, config) {
         const fiberAlive = () => ctx.fiber !== undefined && ctx.fiber.uid !== undefined && ctx.fiber.uid === fiberUid;
         // 启动不等待 domain：先用现有 settings 数据把路由与健康页带起来（旧 records 尚在
         // settings 时也能立即显示）；domain 就绪后再以它为权威重载。
+        // 清扫必须在首次消费 testRequest 之前：新进程里已存在的 running 条目都是上次遗留的。
+        sweepStaleTestResults();
         reloadFromConfig(true);
         ctx.on('loader/volatile-update', () => {
             reloadFromConfig(false);
@@ -1341,6 +1475,11 @@ export function apply(ctx, config) {
         });
         boot();
         scheduleDigest(); // 首屏投影：让健康页不用等下一次真实请求
+        // 未消费请求的兜底轮询（审计 R2）：每 5s 看一眼 testRequest 是否被静默丢弃
+        ctx.effect(() => {
+            const timer = setInterval(() => { try { sweepPendingTestRequest(); } catch (_e) { } }, 5000);
+            return () => clearInterval(timer);
+        }, 'model-channel pending-request sweep');
         // storageDomain 是可选服务，必须经响应式 inject 取得「已声明依赖」的上下文：
         // 直接 ctx.get('storageDomain') 只能拿到未注入的裸服务，随后任何属性访问都会被
         // Cordis 代理拒绝（实测 "cannot get property storageDomain without inject"，
@@ -1479,7 +1618,7 @@ export function apply(ctx, config) {
                         return;
                     }
                     if (migrated.groups.length > 0) {
-                        await bus.settings.update(SELF_NS, { groups: migrated.groups });
+                        await bus.writeConfig({ groups: migrated.groups });
                         state.config = { groups: migrated.groups };
                         console.log('[model-channel-manager] migrated legacy config from workspace .channel-manager/config.json');
                     }