@arcaneorion/dsh-model-channel-manager 0.3.8 → 0.3.13

package/README.md

@@ -95,7 +95,12 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 - **降级**：storageDomain 缺席的 profile 退化为纯内存（不持久化流水），不拒绝启动。
 - **client 兼容**：旧 host（无 digest 字段）自动回落原始 records 路径，升级窗口不断供。
 - **已知近似**：30m/24h 视图按「最近活跃渠道」过滤，数值仍是 7 天累计（UI 已标注）；
-  精确分窗口需 host 出多份 digest，后续增强。
+  精确分窗口需 host 出多份 digest，后续增强。健康页默认 7d，避免近 30m 冷窗让用户
+  误以为历史数据丢失。
+- **混部 nonce 兼容**：测试/测速 nonce 使用随机安全整数（host schema 为 number），
+  避免 UUID client 遇到未重启旧 host 时被旧版 `typeof nonce === 'number'` 静默忽略；
+  新 host 同时兼容旧数字与字符串 nonce。使用 `crypto.getRandomValues`，fallback 为
+  时间戳×1000 + 同毫秒计数。
 
 ## 响应信封（重要）
 
@@ -121,11 +126,37 @@ 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 见详情）
 
-> 注意：此通道依赖 host 半新代码。**旧 host（未重启）无 testRequest 处理器**，测试会一直「请求中」——client 现在约 66s 后超时报 `POLL_TIMEOUT` 并提示 host 未处理（不再无限轮询）。
+> 注意：此通道依赖 host 半新代码。**旧 host（未重启）无 testRequest 处理器**，测试会一直「请求中」——client 现在约 66s 后超时，并按现场区分提示：`POLL_TIMEOUT_RUNNING`（host 已收到、仍在执行：渠道慢或上游挂起）或 `POLL_TIMEOUT`（host 未写入结果：多为旧 host 未重启或写入失败）。
+>
+> 0.3.12 起终态判定同时接受 `finishedAt`：即使条目的 `status` 被并发写坏成 `running`，只要带 `finishedAt`/`code`/`error` 就按终态显示真实上游错误，不再误报「host 未处理」。
+
+## 任务通道完整性（0.3.12 重构：去重与写入语义）
+
+## 任务通道完整性（0.3.12 重构：去重与写入语义）
+
+0.3.11 线上症状「等待测试结果超时：host 可能未处理该请求」的两个真实成因，均在 0.3.12 修掉：
+
+- **去重不许做数值推断**：`handleTestRequest` / `reloadFromConfig`（测速）改用纯函数
+  `shouldConsumeNonce()`（导出，可在测试里直接断言判定表）——严格等值 + 已消费集合 +
+  已结算值 + 已有终态结果，四者任一命中即不消费。旧实现 `last = Math.max(lastTestHandledNonce,
+  claimedNonce)` 对随机 53-bit nonce 有 ≈50% 失效率（「上一轮 > 本轮」即失效），
+  于是同一请求在每次 `loader/volatile-update`（含宿主自己每 5s 的 digest 回写）都被重新消费：
+  重复上游请求（真实计费）+ 多次执行结果写进同一条目（线上物证：同 nonce 同时带
+  `code TIMEOUT / 60000ms` 与 `ok:true / text`，单次执行不可能）。
+- **health 子树一律叶写**：`writeHealth` 由「读整树 → 合并 → 整树写回」改为对 patch 命中的
+  顶层键逐个 `set`（path-ops），单键结果用 `writeHealthLeaf(['testResults', nonce], value)`；
+  client 侧 shim 同样不再 `describe` 快照 + 整树回写，直接下推 path-ops。整树回写的 payload 是
+  「调用时刻的快照」，晚于并发的终态落盘时会把 `status` 改回 `running`，而 `update` 的深合并
+  保留后写入的 `finishedAt/code/error` → 僵尸条目 → 客户端永远等不到终态。
+- client 终态判定加 `finishedAt`（写入后不可抹掉），并把 `ok` 归一成 `status` 显示真实错误。
+- 降级 nonce 路径改用安全整数随机数（旧 `Date.now()*1000+counter ≈ 1.8e18` 超出
+  `MAX_SAFE_INTEGER`，同毫秒可撞值；strict consume-once 下撞值 = 测试被静默丢弃）。
+
+回归：`tests/task-dedup.test.cjs`（判定表用真实导出，不复制实现）、`tests/testresult-fallback.test.cjs`（叶写语义 + 事故复现：终态后并发叶写不得改回 running）。
 
 ## 拉取上游（模型选择）
 
@@ -200,6 +231,38 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 - 30m/24h 健康视图是近似口径（按最近活跃过滤，数值为 7 天累计，UI 已标注）；精确分窗口
   需 host 出多份 digest
 
+### 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 已修）
 
 - **per-attempt AbortController**：每次候选尝试独立 signal，用户取消转发（`relayAbort`，
@@ -243,3 +306,16 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 23. **整字段落盘 + 内存态被配置快照覆盖**（0.3.1 已根治）：`settings.update` 是整字段替换；旧实现 `reloadFromConfig()` 每次 volatile-update 都用配置快照整体覆盖 `state.records`，而健康 flush 有 2s 防抖 → **刚记下的一笔在落盘前就被内存覆盖**（症状：面板“测试”成功不入账，失败反被全局拦截器的 catch 记上）。当时的修法是 `pendingRecords` 缓冲补账；0.3.1 起权威数据搬入 storageDomain（见「健康数据存储」），settings 只存 digest 小投影，此竞态从数据模型层消除。
 24. **nonce 落盘时机与启动竞态**：`lastTestHandledNonce` / `lastHandledNonce` 必须在**得出结果之后**写（提前写会让“未就绪”的重试被自己的持久值挡掉）；启动瞬间凭据服务尚未就绪时测试/测速会以 `MISSING_CREDENTIAL` 失败（凭据其实已在 `.credentials.yaml` 里），应识别为「还没就绪」→ 释放认领 + 5s 延时重试（上限 24 次），**不要**写成渠道故障；测速还必须在整组候选都因未就绪失败时**不落盘、不冷却**，否则一次启动重放就把所有渠道误判成故障。
 25. **domain 写入的并发丢失（0.3.1 review 挽救）**：`KvTable.put` 是整 record 覆盖，`get→filter→put` 的读-改-写在 put 的 IO 延迟窗口内并发调用会互相覆盖（后写盖先写，先记的账丢失）——恰好复刻了要消灭的丢账问题。**并发追加必须走原子链**：`update(key, fn)` 的 fn 在写链队列槽位看到当前值；桶不存在时 update 报 `missing-key`，先 put 初始化。另外在 promise 链里 `ctx.effect` 注册 disposer 前必须先验 fiber 活性——对 inactive fiber 注册会抛 `INACTIVE_EFFECT`，若被外层 catch 吞掉则 domain 永不 close，facility 名字被占 → HMR 重载后 `already-open` 静默降级。回归：`tests/health-domain-sync.test.cjs`。
+26. **`ctx.get(name)` 是宽松读，不代表可以访问服务（0.3.10 线上事故）**：Cordis 的服务属性访问经 Proxy 校验 inject——`ctx.get('storageDomain')` 直接查 store 返回裸服务（不校验 state/inject），但拿着这个未声明的 ctx 做 `ctx.storageDomain.open(...)` 会抛 `cannot get property "storageDomain" without inject`；若被 promise 链的 catch 吞掉，表现为「插件启动正常、domain 永远不打开、健康流水静默降级为内存」。**可选服务必须用响应式 inject**：`ctx.inject(['storageDomain'], (dctx) => { ... dctx.storageDomain ... })`——回调只在服务可用（state=2）时触发，缺席时插件照常工作；同时把插件主启动（`reloadFromConfig` + `boot`）放在 inject **之外**先跑，避免服务缺席时路由不注册。回归：`tests/domain-wiring.test.cjs`。
+27. **`settings.update` 的深合并清不掉旧键（0.3.10 修）**：`update` 走 `mergeLayers`，`{records: {}}` 覆盖已有对象是**深合并**——旧键原样保留。0.3.8 的迁移「清空 settings 旧流水」实际没删，`records` 一直留在 profile 里，每次 `describe`（client 5s 轮询全量命名空间）都要带着它。要真删除必须走 path-ops：`settings.mutate(ns, [{op:'unset', path:['health','records']}, ...])`（`isVolatilePath` 对 volatile 子树的后代返回 true，允许操作）。回归：`tests/domain-wiring.test.cjs`。
+28. **schema 类型漂移会静默清空整个 volatile 子树（0.3.11 线上事故，自己埋的）**：0.3.2 把 client nonce 改成 UUID 字符串、host 消费代码也兼容了字符串，**但没同步改 schema**——`lastTestHandledNonce: z.number()`。字符串一落盘，`HEALTH_SCHEMA` 解析时子字段抛错；而它是 `.loose(true)`，宽松兜底把**整个 health 子树换成默认空对象**（实测 `healthOf()` 返回 `{}`，不报错、不告警）。后果：`records`/`digest` 在运行时全部消失 → 存量迁移遍历空对象（什么都不导入）→ 清理逻辑以为「无残留」（旧键删不掉）→ 表现为「健康页没有历史数据」且旧 `records` 永久占据 profile。三条教训：① **写侧放宽类型时，schema 必须同步放宽**（用 `z.union([z.number(), z.string()])` 兼容历史值）；② **`.loose(true)` 的兜底是静默的**，volatile 子树里一个字段失配 = 整树数据不可见；③ **迁移标记不可信**——`migrateFrom` 改为「桶已存在时合并去重」而非整桶跳过，且「有存量必须先导入再清理」，这样即使 marker 被误写也能把旧账救回来。回归：`tests/health-schema-tolerance.test.cjs`。
+
+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`。
+
+## 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.8",
+  "version": "0.3.13",
   "type": "module",
   "main": "src/index.js",
   "scripts": {
@@ -56,7 +56,9 @@
       "patch": "./cordis.patch.yml"
     },
     "client": {
-      "inject": ["slots"],
+      "inject": [
+        "slots"
+      ],
       "platform": "web"
     }
   }

package/src/client.js

@@ -11,6 +11,24 @@ window.__ModuleLoader__.load({
     const { createElement: el, useState, useEffect, useRef, useSyncExternalStore } = require('react')
     let apiRef = null
     const savedKeys = {}
+    // 使用随机安全整数 nonce：host 的 lastTestHandledNonce/lastHandledNonce 是 number。
+    // UUID 字符串虽被新 host 接受，但旧 host（滚动升级/未重启窗口）只校验 number，
+    // 会把请求静默忽略，client 最终提示「host 未处理」。随机 53-bit 整数同时避免
+    // Date.now()%1e9 同毫秒碰撞，并保持与旧 host 的 wire schema 兼容。
+    let nonceFallbackCounter = 0
+    const createNonce = () => {
+      if (typeof crypto !== 'undefined' && crypto && typeof crypto.getRandomValues === 'function') {
+        const words = new Uint32Array(2)
+        crypto.getRandomValues(words)
+        const n = (words[0] & 0x1fffff) * 0x100000000 + words[1]
+        return n === 0 ? 1 : n
+      }
+      // 降级路径：旧写法 Date.now()*1000+counter ≈ 1.8e18 > MAX_SAFE_INTEGER，
+      // 同毫秒内可能撞值（且 strict consume-once 去重下撞值 = 测试被静默丢弃）。
+      nonceFallbackCounter = (nonceFallbackCounter + 1) % 1000
+      const n = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
+      return n === 0 ? nonceFallbackCounter + 1 : n
+    }
 
     // dsh 0.2：客户端远程面由 connection.api 改为 ctx.remote；参数改为位置参数，结果统一为
     // RemoteResult。本适配层把两者还原成 0.1 的调用形状（对象入参 + {result:{ok,value}}）。
@@ -19,11 +37,6 @@ window.__ModuleLoader__.load({
     const NS_MCM = 'model-channel-manager'
     const makeLegacyApi = (remote) => {
       const wrap = (res) => ({ result: res || { ok: false } });
-      const readMcm = async () => {
-        const res = await remote.settings.describe()
-        if (!res || res.ok !== true) return null
-        return ((res.value && res.value.namespaces) || []).find((n) => n && n.ns === NS_MCM) || null
-      }
       return {
         settings: {
           describe: async () => {
@@ -45,45 +58,31 @@ window.__ModuleLoader__.load({
             const patch = (args && args.patch) || {}
             const expected = (args && args.expectedRevision !== undefined) ? args.expectedRevision : undefined
             if (ns === 'model-channels') return wrap(await remote.settings.update(NS_MCM, patch, expected))
-            const row = await readMcm()
-            const health = (row && row.value && row.value.health) || {}
-            return wrap(await remote.settings.update(NS_MCM, { health: Object.assign({}, health, patch) }, expected))
+            // 0.3.12：health 子树改成「叶写」（path-ops），不再 describe 快照 + 整树回写。
+            // 旧写法在 read→write 的两次 RPC 之间有窗口：宿主刚写入的终态会被旧快照覆盖
+            // （线上事故：testResults[nonce].status 被改回 running，finishedAt/code/error 却保留，
+            //  客户端永远等不到终态 → 66s 后误报「host 未处理」）。
+            const ops = Object.entries(patch).map(([k, v]) => ({ op: 'set', path: ['health', k], value: v }))
+            if (ops.length === 0) return { result: { ok: true, value: null } }
+            return wrap(await remote.settings.mutate(NS_MCM, ops, expected))
           },
-          // 旧签名：mutate({ ns, ops })——0.2 只对真实行命名空间提供 path-ops；
-          // 本插件自身的健康子树用合并写实现等价语义。
+          // 旧签名：mutate({ ns, ops })——health 子树现在也走真实 path-ops（不再本地模拟整树写）
           mutate: async (args) => {
             const ns = (args && args.ns) || NS_MCM
             const ops = (args && args.ops) || []
             const expected = (args && args.expectedRevision !== undefined) ? args.expectedRevision : undefined
-            if (ns !== 'model-channels' && ns !== 'model-channel-health' && ns !== NS_MCM) {
-              return wrap(await remote.settings.mutate(ns, ops, expected))
-            }
-            const row = await readMcm()
-            const health = Object.assign({}, (row && row.value && row.value.health) || {})
-            const top = {
-              groups: (row && row.value && row.value.groups) || [],
-              providerOrder: (row && row.value && row.value.providerOrder) || [],
-            }
+            if (ns === NS_MCM) return wrap(await remote.settings.mutate(NS_MCM, ops, expected))
+            const prefix = (ns === 'model-channels') ? [] : ['health']
+            const mapped = []
             for (const op of ops) {
               const path = (op && op.path) || []
-              const root = (ns === 'model-channels') ? (path[0] === 'groups' ? top : (path[0] === 'providerOrder' ? top : health)) : health
               if (path.length === 0) continue
-              const key = path[0]
-              const rest = path.slice(1)
-              if (rest.length === 0) {
-                if (op.op === 'set') root[key] = op.value
-                else delete root[key]
-              } else if (rest.length === 1) {
-                const child = Object.assign({}, root[key] || {})
-                if (op.op === 'set') child[rest[0]] = op.value
-                else delete child[rest[0]]
-                root[key] = child
-              }
-            }
-            if (ns === 'model-channels') {
-              return wrap(await remote.settings.update(NS_MCM, { groups: top.groups, providerOrder: top.providerOrder }, expected))
+              // legacy 混合命名空间：groups/providerOrder 属于行顶层，其余视为 health 子键
+              const p = (ns === 'model-channels' && (path[0] === 'groups' || path[0] === 'providerOrder')) ? path : [...prefix, ...path]
+              mapped.push({ op: (op && op.op) || 'set', path: p, value: op && op.value })
             }
-            return wrap(await remote.settings.update(NS_MCM, { health }, expected))
+            if (mapped.length === 0) return { result: { ok: true, value: null } }
+            return wrap(await remote.settings.mutate(NS_MCM, mapped, expected))
           },
         },
         credentials: {
@@ -567,18 +566,30 @@ window.__ModuleLoader__.load({
       const pollTest = (nonce, provider, model, attempt = 0) => {
         if (!apiRef) return
         const key = provider + '::' + model
-        // host 侧测试超时 60s，约 55 次 × 1.2s ≈ 66s 后放弃，避免结果被覆盖时无限轮询
-        const giveUp = () => setTestStates((s) => Object.assign({}, s, { [key]: { status: 'error', code: 'POLL_TIMEOUT', error: '等待测试结果超时：host 可能未处理该请求（host 半更新后需重启 DSH）' } }))
+        // 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
           const ns = ((d && d.namespaces) || []).find((n) => n && n.ns === 'model-channel-health')
           const tr = (ns && ns.value && ns.value.testResults) || {}
           const e = tr[nonce]
-          if (e && (e.status === 'ok' || e.status === 'error')) {
-            setTestStates((s) => Object.assign({}, s, { [key]: e }))
+          // 终态判定不能只看 status：整树快照回写曾把 status 改回 running 而保留
+          // finishedAt/code/error（0.3.11 事故）。finishedAt 写入后不会被抹掉，把它也当终态，
+          // 并按 ok 归一 status —— 这样「僵尸条目」也能显示真实的上游错误而不是假超时。
+          const terminal = !!(e && (e.status === 'ok' || e.status === 'error' || e.finishedAt))
+          if (terminal) {
+            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()
+            // 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)
           }
@@ -594,7 +605,7 @@ window.__ModuleLoader__.load({
         setTestStates((s) => Object.assign({}, s, { [key]: { status: 'running' } }))
         // F03：Date.now()%1e9 同毫秒可碰撞（碰撞 = 两次测试互相认领/覆盖结果），
         // 换 UUID；host 侧 testRequest.nonce 消费方是 !== 比较，字符串/数字都行
-        const nonce = (crypto.randomUUID && crypto.randomUUID()) || (String(Date.now()) + '-' + Math.random().toString(36).slice(2, 10))
+        const nonce = createNonce()
         const prompt = localStorage.getItem('mcm_test_prompt') || '用一句话介绍你自己'
         const maxTokens = Number(localStorage.getItem('mcm_test_max_tokens')) || 256
         apiRef.settings.update({
@@ -976,7 +987,7 @@ window.__ModuleLoader__.load({
       const speedtest = (gid) => {
         if (!apiRef) return
         // F03/F19 同 fireTest：UUID 防碰撞 + 信封检查（ok:false 不再当「已触发」）
-        const nonce = (crypto.randomUUID && crypto.randomUUID()) || (String(Date.now()) + '-' + Math.random().toString(36).slice(2, 10))
+        const nonce = createNonce()
         setSpeedState((s) => Object.assign({}, s, { [gid]: 'running' }))
         apiRef.settings.update({ ns: 'model-channel-health', patch: { speedRequest: { group: gid, nonce } } }).then((resp) => {
           const r = resp && resp.result ? resp.result : resp
@@ -1076,7 +1087,9 @@ window.__ModuleLoader__.load({
     function HealthPanel(props) {
       const health = props.health
       const providers = props._providers || {}
-      const [windowMode, setWindowMode] = useState('30m') // '30m' | '24h' | '7d'
+      // 默认 7d：digest 是窗口聚合，小窗口在长时间无请求时会合法显示 0，
+      // 用户容易误认为「数据丢了」。先默认展示历史，再可切 30m/24h 看实时/近期。
+      const [windowMode, setWindowMode] = useState('7d') // '30m' | '24h' | '7d'
 
       if (!health) return el('div', { className: 'mcm-empty' }, '健康统计数据准备中…')
 
@@ -1088,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()
 
@@ -1124,6 +1142,11 @@ window.__ModuleLoader__.load({
       let totalTokIn = 0
       let totalTokOut = 0
       let totalTokCache = 0
+      // allEvents 必须在两个分支前声明：旧 host 兼容路径（digest 缺失）会在
+      // else 块里赋值它（供顶部指标卡用）；若在此处之后才 let 声明，
+      // 赋值撞未声明变量 → ReferenceError 白屏（host 重启首次加载、digest
+      // 尚未生成时正是此路径）。这是 0.3.1 引入双路径时的遗漏。
+      let allEvents = []
 
       if (digestRows !== null) {
         // ---------- digest 投影路径 ----------
@@ -1231,8 +1254,7 @@ window.__ModuleLoader__.load({
       }
 
       // 顶部指标卡：digest 路径用聚合值求和，旧路径用原始事件计数
-      // （allEvents 提升到函数级：旧 host 回落路径的 else 块在此作用域外定义它）
-      let allEvents = []
+      // （allEvents 已在上方分支前声明）
       let totalRequests = 0
       let totalSuccess = 0
       let ttftWeightedSum = 0

package/src/health-store.js

@@ -67,6 +67,18 @@ const healthDomainSpec = defineDomain({
   },
 });
 
+/**
+ * 事件去重键：同一笔在 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 读写 + 保留策略 + 聚合。
  * 非 Service（宿主插件自有生命周期），由 apply() 创建并 effect 持有 close。
@@ -95,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;
@@ -102,14 +117,21 @@ export class HealthStore {
     if (domain) await domain.close().catch(() => {});
   }
 
+  /** 把一次事件表写入排入类内写链：并发调用逐个重读当前值，不交错、不互相覆盖。
+   * 返回本次写入的真实结果（失败会 reject，调用方可记录/重试）；链本身用吞错版本续接。
+   */
+  enqueueEvent(run) {
+    const result = this.eventChain.then(run, run);
+    this.eventChain = result.catch(() => { });
+    return result;
+  }
+
   /** 追加一条事件到渠道桶，同时执行窗口过期 + 条数截断。
-   * 并发安全：桶初始化（put）与追加（update）都排队到类内写链，逐个重读当前值，
-   * 并发 appendEvent 不交错、不互相覆盖（等价 KvTable.update 的原子语义；
-   * 桶不存在时 KvTable.update 报 missing-key，故初始化先行）。
+   * 桶不存在时先 put 初始化（KvTable.update 对缺失键报 missing-key）。
    */
   appendEvent(provider, rec) {
     if (this.events === null) return Promise.resolve();
-    this.eventChain = this.eventChain.then(async () => {
+    return this.enqueueEvent(async () => {
       const cutoff = Date.now() - WINDOW_MS;
       const cur = this.events.get(provider);
       if (cur === undefined) {
@@ -119,14 +141,17 @@ export class HealthStore {
       await this.events.update(provider, (c) => ({
         events: [...c.events.filter((e) => e.ts >= cutoff), rec].slice(-PER_KEY_LIMIT),
       }));
-    }).catch(() => { }); // 链不断：失败吞掉（调用方已有 warn），后续追加继续
-    return this.eventChain;
+    });
   }
 
-  /** 整组测速结果替换写入。 */
+  /** 整组测速结果替换写入。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 });
+    });
   }
 
   /** 读全部事件桶（迁移/聚合用）。 */
@@ -146,23 +171,43 @@ export class HealthStore {
   }
 
   /**
-   * 存量迁移：settings health 子树的 records/speedResults 一次性搬入 domain。
-   * 迁移以「桶里有数据即跳过」防重放；完成后由调用方写迁移标记。
-   * 并发安全：逐桶判断改走原子链（迁移进行中 recordHealth 并发创建的新桶不会被旧数据覆盖）。
+   * 存量迁移：把 settings health 子树的 records/speedResults 并入 domain。
+   *
+   * 与早期实现的关键差别：**桶已存在时合并去重，而不是整桶跳过**。
+   * 原因是 0.3.11 修掉的 schema 缺陷（nonce 类型漂移 → health 整树被宽松兜底
+   * 清空）期间，迁移标记可能已被误写、而 settings 里的旧流水从未真正导入；
+   * 此时若沿用「桶已存在即跳过」再清理 settings，旧账会被直接删除。
+   * 合并保证不丢数据，且幂等（同 ts+provider+model 视为同一笔）。
+   * 测速结果是「最新快照」语义，仍以 domain 已有行为准。
    */
   async migrateFrom(records, speedResults) {
     if (this.events === null) return false;
     const cutoff = Date.now() - WINDOW_MS;
     for (const [provider, list] of Object.entries(records || {})) {
-      if (!Array.isArray(list) || list.length === 0) continue;
-      if (this.events.get(provider) !== undefined) continue; // 已有桶：domain 是权威，不回搬
-      const events = list.filter((e) => e && e.ts >= cutoff).slice(-PER_KEY_LIMIT);
-      if (events.length > 0) await this.events.put(provider, { events });
+      const incoming = (Array.isArray(list) ? list : [])
+        .filter((e) => e && Number.isFinite(e.ts) && e.ts >= cutoff);
+      if (incoming.length === 0) continue;
+      await this.enqueueEvent(async () => {
+        const existing = (this.events.get(provider) || {}).events || [];
+        const seen = new Set(existing.map(eventKey));
+        const merged = existing.slice();
+        for (const e of incoming) {
+          const k = eventKey(e);
+          if (seen.has(k)) continue;
+          seen.add(k);
+          merged.push(e);
+        }
+        merged.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+        await this.events.put(provider, { events: merged.slice(-PER_KEY_LIMIT) });
+      });
     }
     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

@@ -18,10 +18,14 @@ const HEALTH_SCHEMA = z.object({
     speedResults: z.dict(z.array(z.any())).default({}),
     runtime: z.dict(z.any()).default({}),
     speedRequest: z.any(),
-    lastHandledNonce: z.number().default(0),
+    // nonce 必须容忍 number 与 string 两种历史形态：0.3.2 的 client 写过 UUID 字符串，
+    // 而 schema 当时声明 z.number() → 字符串一旦落盘，**整个 health 子树校验失败**，
+    // 被 .loose(true) 兜底替换成默认值：records/digest 在运行时全部消失、迁移空转。
+    // （0.3.11 线上事故根因；回归见 tests/health-schema-tolerance.test.cjs）
+    lastHandledNonce: z.union([z.number(), z.string()]).default(0),
     testRequest: z.any(),
     testResults: z.dict(z.any()).default({}),
-    lastTestHandledNonce: z.number().default(0),
+    lastTestHandledNonce: z.union([z.number(), z.string()]).default(0),
     legacyMigrated: z.any(),
     healthMigrated: z.any(),
     // 小投影：host 聚合好的健康摘要（client 渲染用），digestAt 为生成时刻
@@ -34,6 +38,48 @@ export const Config = z.object({
     effortMemory: z.dict(z.string()).default({}).volatile(),
     health: HEALTH_SCHEMA.volatile(),
 }).loose(true);
+// ---------- 任务请求的 consume-once 判定（纯函数，便于回归测试） ----------
+// nonce 规范化为字符串键：number（现行 client 的随机 53-bit 整数）与 string（0.3.2–0.3.8 的 UUID）
+// 都能比较；非法形态返回 null。
+export const nonceKey = (v) => (typeof v === 'number' || typeof v === 'string') ? String(v) : null;
+// schema 默认值 0 表示「从未处理过」，不能当一个真实 nonce 用
+export const settledNonceKey = (v) => {
+    const k = nonceKey(v);
+    return (k === null || k === '0') ? null : k;
+};
+/**
+ * 是否应当消费这个 nonce（唯一入口，测试与测速共用）。
+ * 关键点：只用「严格等值 + 已消费集合」，不做任何数值大小推断——
+ * 旧实现用 Math.max(…) 比较数值大小来判等，而 nonce 是随机 53-bit，
+ * 「上一轮 > 本轮」时（≈50%）guard 失效，同一请求会在每次 volatile-update
+ * 被重新消费（重复上游请求 + 结果条目互相污染）。
+ * hasTerminal 为真（finishedAt / status ok|error）时也视为已消费：结果已落地，
+ * 重放只会得到重复计费与覆盖。
+ */
+export function shouldConsumeNonce({ consumed, key, claimed, settled, hasTerminal }) {
+    if (key === null || key === undefined) return false;
+    if (hasTerminal) return false;
+    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';
@@ -81,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) {
@@ -866,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 });
@@ -944,16 +1003,89 @@ 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 统一为字符串 UUID（0.3.2 起 client 换 randomUUID，防同毫秒碰撞）；
-        // 旧数字 nonce（Date.now()%1e9）仍被接受：typeof 兼容两种，比较用 !==。
+        // nonce 接受 number（现行 client 的随机 53-bit 整数）与 string（0.3.2–0.3.8 的 UUID）
+        // 两种历史形态；去重一律按字符串键严格比较，不再做数值大小推断。
         const nonceOf = (v) => (typeof v === 'number' || typeof v === 'string') ? v : null;
         const reqNonce = nonceOf(req && req.nonce);
-        const lastNum = typeof next.lastTestHandledNonce === 'number' ? next.lastTestHandledNonce : null;
-        const last = lastNum !== null ? Math.max(lastNum, typeof claimedTestNonce === 'number' ? claimedTestNonce : 0) : (claimedTestNonce || null);
-        if (!req || typeof req.provider !== 'string' || typeof req.model !== 'string' || reqNonce === null || reqNonce === last)
+        const reqKey = nonceKey(reqNonce);
+        const claimedKey = nonceKey(claimedTestNonce);
+        const settled = settledNonceKey(next.lastTestHandledNonce);
+        const entry = reqKey !== null ? (next.testResults || {})[reqKey] : null;
+        // 终态判定用 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' || 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。
         // 启动早于凭据服务就绪时会以 MISSING_CREDENTIAL 失败，那要释放认领重试；
@@ -963,23 +1095,28 @@ export function apply(ctx, config) {
                 bus.writeHealth({ lastTestHandledNonce: reqNonce }).catch((e) => console.error('[model-channel-manager] lastTestHandledNonce 写入失败:', e));
             return setResult(entry);
         };
-        // 0.2 的配置写入是「整字段落盘」，不再有 path-ops；结果集按当前值合并后整段写回。
+        // 0.3.12：结果按「单键叶写」落盘（path-ops），不再把整个 testResults 读出来整段写回。
+        // 整段写回的 payload 是调用时刻的快照，落盘晚于并发的终态写时会把该 nonce 的
+        // status 改回 running（深合并保留 finishedAt/code/error）——线上事故的直接成因。
+        // 叶写只动这一个 nonce 的条目，物理上不可能覆盖别人的、也不可能自我回退。
         const setResult = async (entry) => {
             const key = String(reqNonce);
             const value = Object.assign({}, entry, { nonce: reqNonce, provider: req.provider, model: req.model });
-            const cur = healthOf().testResults || {};
             if (bus !== null)
-                await bus.writeHealth({ testResults: Object.assign({}, cur, { [key]: value }) }).catch((e) => console.error('[model-channel-manager] testResults 写入失败:', e));
+                await bus.writeHealthLeaf(['testResults', key], value).catch((e) => console.error('[model-channel-manager] testResults 写入失败:', e));
         };
-        // 修剪低频执行：只在条目数超限时砍到 50（不在每次写入时整包重写）
+        // 修剪低频执行：只在条目数超限时砍到 50。用 unset 叶删（update 的深合并删不掉键）
         const maybePrune = () => {
             const all = healthOf().testResults || {};
             const entries = Object.entries(all);
             if (entries.length <= 50) return;
-            const kept = {};
-            for (const [k, v] of entries.sort((a, b) => ((b[1] && b[1].finishedAt) || 0) - ((a[1] && a[1].finishedAt) || 0)).slice(0, 50)) kept[k] = v;
-            if (bus !== null)
-                bus.writeHealth({ testResults: kept }).catch((e) => console.error('[model-channel-manager] testResults 修剪失败:', e));
+            const removed = entries
+                .sort((a, b) => ((b[1] && b[1].finishedAt) || 0) - ((a[1] && a[1].finishedAt) || 0))
+                .slice(50)
+                .map(([k]) => k);
+            if (removed.length === 0 || bus === null) return;
+            bus.writeHealthOps(removed.map((k) => ({ op: 'unset', path: ['health', 'testResults', k] })))
+                .catch((e) => console.error('[model-channel-manager] testResults 修剪失败:', e));
         };
         const done = async (r) => {
             try {
@@ -996,6 +1133,9 @@ export function apply(ctx, config) {
             if (notReady(e)) {
                 // 凭据服务尚未就绪（典型是启动瞬间的重放）：不写成假 error，释放认领并延后重试
                 claimedTestNonce = null;
+                releaseConsumed(consumedTestNonces, reqKey); // 释放后才能靠重放再消费
+                releaseConsumed(warnedTestNonces, reqKey);
+                testBackoffUntil = Date.now() + 5000;       // 退避窗口：期间任何 volatile-update 都不再消费
                 scheduleReplay('test', () => reloadFromConfig(false));
                 return;
             }
@@ -1096,21 +1236,41 @@ export function apply(ctx, config) {
         flushDigest();
     }, 'model-channel health digest');
     // settings 存量 records/speedResults → domain 一次性迁移（桶已存在即跳过，domain 权威）。
+    // 清空旧键必须走 path-ops：update 是深合并，`records: {}` 清不掉已有键——
+    // 0.3.8 用合并写「清空」实际没删，旧流水一直留在 profile 里（每 5s describe 都要带着它）。
     const migrateHealthToDomain = async () => {
         if (healthStore === null || bus === null) return;
         const health = healthOf();
-        if (health.healthMigrated === true) return;
+        const alreadyMigrated = health.healthMigrated === true;
+        const hasRecords = health.records !== undefined && Object.keys(health.records || {}).length > 0;
+        const hasSpeed = health.speedResults !== undefined && Object.keys(health.speedResults || {}).length > 0;
+        if (!hasRecords && !hasSpeed) {
+            // 无存量：只补哨兵（幂等）
+            if (!alreadyMigrated) {
+                await bus.writeHealthOps([{ op: 'set', path: ['health', 'healthMigrated'], value: true }])
+                    .catch((e) => console.warn('[model-channel-manager] health marker write failed:', e && e.message));
+            }
+            return;
+        }
+        // 有存量就必须导入（合并幂等）——不能只看 marker：schema 缺陷期间 marker 可能已被
+        // 误写而数据从未导入（0.3.11 线上事故），照 marker 跳过再清理 = 直接删掉旧账。
         let ok = false;
         try {
             ok = await healthStore.migrateFrom(health.records || {}, health.speedResults || {});
         }
-        catch (_e) {
-            ok = false; // 下次启动再试
+        catch (e) {
+            console.warn('[model-channel-manager] legacy health import failed (will retry next boot):', e && e.message);
+            return;
         }
-        if (!ok) return; // store 已关闭（卸载竞态）：不写标记，避免标记与数据永久不一致
-        // 同一次合并写：迁移标记 + 清空 settings 里的旧存量（否则 writeHealth 的
-        // Object.assign 会把 records/speedResults 永远带下去，profile 膨胀问题未真正解决）
-        bus.writeHealth({ healthMigrated: true, records: {}, speedResults: {} }).catch(() => { });
+        if (!ok) return; // store 已关闭（卸载竞态）：不清理，避免标记与数据永久不一致
+        // 导入成功才真删除旧键（path-ops；update 的深合并清不掉）+ 落哨兵
+        const ops = [];
+        if (hasRecords) ops.push({ op: 'unset', path: ['health', 'records'] });
+        if (hasSpeed) ops.push({ op: 'unset', path: ['health', 'speedResults'] });
+        if (!alreadyMigrated) ops.push({ op: 'set', path: ['health', 'healthMigrated'], value: true });
+        if (ops.length === 0) return;
+        await bus.writeHealthOps(ops).catch((e) => console.warn('[model-channel-manager] legacy health cleanup failed:', e && e.message));
+        console.log('[model-channel-manager] legacy health imported into domain and cleared from settings');
     };
 
     // ---------- settings 总线接入（响应式：settings 服务异步初始化，apply 时查询太早） ----------
@@ -1118,8 +1278,34 @@ export function apply(ctx, config) {
     let runtimeRestored = false;
     // 非持久去重：回写要等当前 HMR 事务结束才落盘，这中间 volatile-update 可能带着同一个 nonce 再来，
     // 内存里先认领，避免同一请求被重复执行（并顺带消掉重复的回写风暴）。
+    //
+    // 0.3.12：改为严格 consume-once（字符串键集合），不再依赖 nonce 的数值单调性。
+    // 旧实现 last = Math.max(上一轮结算值, 本次认领值)，而两个 nonce 都是随机 53-bit：
+    // 「上一轮 > 本轮」时判等直接失效（≈50%），于是测试在每次 loader/volatile-update
+    // （包括宿主自己每 5s 的 digest 回写）都被重新消费——重复上游请求（真实计费）
+    // 且结果条目互相污染。线上物证：同 nonce 一条记录同时带
+    // `code TIMEOUT / 60000ms` 与 `ok:true / text`（单次执行不可能）。
+    // 回归见 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) {
+            const oldest = set.values().next().value;
+            set.delete(oldest);
+        }
+    };
+    const releaseConsumed = (set, key) => { if (key !== null) set.delete(key); };
     // 启动早于凭据服务就绪：此时重放测试/测速会以 MISSING_CREDENTIAL 失败。
     // 这类错误是「环境还没准备好」而不是「渠道故障」，必须释放认领、延后重试，不能写成假 error。
     const notReady = (e) => {
@@ -1143,6 +1329,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 || {});
@@ -1163,23 +1356,28 @@ export function apply(ctx, config) {
                 runtime.delete(id);
         rewireRoutes();
         const req = health.speedRequest;
-        // nonce 兼容字符串 UUID / 旧数字（与 handleTestRequest 同一策略）
-        const speedNonce = (typeof (req && req.nonce) === 'number' || typeof (req && req.nonce) === 'string') ? req.nonce : null;
-        const lastNum = typeof health.lastHandledNonce === 'number' ? health.lastHandledNonce : null;
-        const last = lastNum !== null ? Math.max(lastNum, typeof claimedSpeedNonce === 'number' ? claimedSpeedNonce : 0) : (claimedSpeedNonce || null);
-        if (req && typeof req.group === 'string' && speedNonce !== null && speedNonce !== last) {
-            claimedSpeedNonce = speedNonce;
+        // 与 handleTestRequest 同一策略：nonce 兼容字符串/数字，去重按字符串键严格等值
+        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);
+            claimedSpeedNonce = req.nonce;
             const cfgRow = pullConfig().groups.find((g) => g.id === req.group);
             // nonce 落盘推迟到本次测速得出结论之后（同 handleTestRequest 的理由）：
             // 提前写会把「没就绪」的重试用自己的持久值挡掉。
             const settleSpeed = () => {
                 if (bus !== null)
-                    bus.writeHealth({ lastHandledNonce: speedNonce }).catch(() => { });
+                    bus.writeHealth({ lastHandledNonce: req.nonce }).catch(() => { });
             };
             if (cfgRow)
                 runSpeedTest(cfgRow).then((r) => {
                     if (r && r.deferred) {
                         claimedSpeedNonce = null;
+                        releaseConsumed(consumedSpeedNonces, speedKey);
+                        speedBackoffUntil = Date.now() + 5000; // 退避：别让 volatile-update 立刻再消费
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -1188,6 +1386,8 @@ export function apply(ctx, config) {
                 }).catch((e) => {
                     if (notReady(e)) {
                         claimedSpeedNonce = null;
+                        releaseConsumed(consumedSpeedNonces, speedKey);
+                        speedBackoffUntil = Date.now() + 5000; // 退避：同上
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -1218,70 +1418,86 @@ export function apply(ctx, config) {
         // 后写的直接覆盖先写的（实测 lastTestHandledNonce 与 records 就这样丢过）。
         // 所以写入串行化：排队后逐个重新读当前值再合并，不让两次写入互相覆写。
         let healthWrites = Promise.resolve();
-        const writeHealth = (patch) => {
-            const run = async () => {
-                const cur = healthOf();
-                const next = Object.assign({}, cur, patch);
-                return outsideTransaction(() => settings.update(SELF_NS, { health: next }));
-            };
+        const enqueueHealthWrite = (run) => {
             const queued = healthWrites.then(run, run);
             healthWrites = queued.catch(() => { });
             return queued;
         };
+        // 0.2 的 health 子树写入曾用「整树读-改-写」（cur = healthOf(); update({health:{...cur, patch}})）。
+        // 只要内存视图落后于已提交的行（volatile 提交与事件之间有窗口），旧快照就会把新值写回去：
+        // 线上物证是终态写入后 status 又被改回 running（同一 nonce 同时有 finishedAt/error 与 running）。
+        // 0.3.12 起一律「叶写」：patch 里出现的每个顶层键单独 set，不再回灌未见过的值。
+        // 需要只动某个子键时用 writeHealthLeaf（如 testResults.<nonce>）。
+        const writeHealth = (patch) => enqueueHealthWrite(async () => {
+            const ops = Object.keys(patch || {}).map((k) => ({ op: 'set', path: ['health', k], value: patch[k] }));
+            if (ops.length === 0) return;
+            return outsideTransaction(() => settings.mutate(SELF_NS, ops, undefined));
+        });
+        // path-ops 写入：update 是深合并，空对象清不掉旧键；需要真删除时走 mutate。
+        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() },
         };
-        // healthStore 可用（dsh-base 的 storage 栈在场）时：开 domain → 迁移存量 →
-        // 用 domain 权威数据重建内存镜像 → boot；否则同步走旧路径。
-        // ctx.inject 回调不是 async 函数，domain 初始化用 promise 链表达。
-        // 卸载竞态防护：then 回调先验 fiber 活性，inactive 时回滚 healthStore 并跳过
-        // effect 注册（对 inactive fiber 注册 effect 会抛 INACTIVE_EFFECT，若被吞掉则
-        // domain 永不 close，facility 名字被占 → HMR 重载后 already-open 静默降级）。
-        // boot 也挪进链尾：domain 路径下 reloadFromConfig(true) 异步排队，若 boot 先跑，
-        // state.speedResults 尚为空 → onFirstUse 组每次启动都重测；且 state.config 为空
-        // 时 rewireRoutes 推迟，启动早期虚拟路由短暂不存在。
-        const domainFacility = ctx.get('storageDomain');
+        // 卸载竞态防护：异步链回到插件时先确认 fiber 仍存活（uid 被清除即已卸载）。
         const fiberUid = ctx.fiber && ctx.fiber.uid;
-        const fiberAlive = () => ctx.fiber !== undefined && ctx.fiber.uid === fiberUid && ctx.fiber.state !== 4 /* disposed */;
-        if (domainFacility !== undefined) {
-            const store = new HealthStore(ctx);
+        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);
+            console.log('[model-channel-manager] config hot-reloaded, routes:', pullConfig().groups.map((g) => g.id).join(', ') || '(none)');
+        });
+        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"，
+        // domain 永远打不开、健康流水静默降级为内存）。inject 回调在服务可用时触发；
+        // profile 没有 storage 栈时它不触发，插件保持内存模式，路由与面板不受影响。
+        ctx.inject(['storageDomain'], (dctx) => {
+            const store = new HealthStore(dctx);
             Promise.resolve()
                 .then(() => store.open())
                 .then(() => {
-                if (!fiberAlive()) {
-                    // 已卸载：回滚赋值，由 closeAll 兜底回收 domain
-                    void store.close().catch(() => { });
-                    return;
-                }
-                healthStore = store;
-                ctx.effect(() => () => { void store.close(); }, 'model-channel health domain close');
-            })
+                    if (!fiberAlive()) {
+                        void store.close().catch(() => { }); // 已卸载：由 facility closeAll 兜底回收
+                        return;
+                    }
+                    healthStore = store;
+                    ctx.effect(() => () => { void store.close(); }, 'model-channel health domain close');
+                    console.log('[model-channel-manager] health domain ready: model_channel_health');
+                })
                 .catch((e) => {
-                console.warn('[model-channel-manager] storageDomain open failed, health records stay in-memory only:', e && e.message);
-            })
+                    console.warn('[model-channel-manager] storageDomain open failed, health records stay in-memory only:', e && e.message);
+                })
                 .then(() => (healthStore !== null ? migrateHealthToDomain().catch(() => { }) : null))
                 .then(() => {
-                if (fiberAlive())
-                    reloadFromConfig(true);
-            })
-                .then(() => {
-                if (fiberAlive())
-                    boot();
-            })
-                .catch(() => { }); // 卸载竞态下 reload/boot 内部可能 throw，链尾兜底防 unhandled rejection
-        }
-        else {
-            reloadFromConfig(true);
-            boot();
-        }
-        ctx.on('loader/volatile-update', () => {
-            reloadFromConfig(false);
-            console.log('[model-channel-manager] config hot-reloaded, routes:', pullConfig().groups.map((g) => g.id).join(', ') || '(none)');
+                    if (!fiberAlive()) return;
+                    reloadFromConfig(true); // domain 权威数据覆盖内存镜像
+                    scheduleDigest();       // 立刻把投影刷新到 settings（健康页首屏可读）
+                })
+                .catch(() => { }); // 卸载竞态下 reload 内部可能 throw，链尾兜底防 unhandled rejection
         });
-        // boot 已在 domain ready 链尾（或降级分支）调用，此处不再调
     });
     // ---------- 全局 LLM 请求健康拦截 (涵盖所有非虚拟路由的真实渠道模型调用) ----------
     ctx.on('llm/stream', async function* (options, next) {
@@ -1391,7 +1607,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');
                     }