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

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 见详情）
 
@@ -231,24 +231,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 +313,9 @@ 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`。
+
 ## 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.13",
   "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()
 

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;
             }
@@ -1189,9 +1288,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 +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 || {});
@@ -1247,6 +1360,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 +1377,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 +1387,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 +1437,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 +1455,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 +1464,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 +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');
                     }