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

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,30 @@ 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);
+}
 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';
@@ -125,6 +153,10 @@ export function apply(ctx, config) {
                 timeoutMs: Number.isFinite(rg.timeoutMs) && rg.timeoutMs > 0 ? rg.timeoutMs : 30000,
                 cooldownMs: Number.isFinite(rg.cooldownMs) && rg.cooldownMs >= 0 ? rg.cooldownMs : 60000,
                 maxRetriesPerCandidate: Number.isSafeInteger(rg.maxRetriesPerCandidate) && rg.maxRetriesPerCandidate >= 0 ? rg.maxRetriesPerCandidate : 2,
+                // F01 配套（审计 §5.3）：整次请求的总预算。旧实现最坏 2×N×(R+1) 次尝试
+                // （默认 R=2 → 6N 次），4 候选组可拖数分钟。默认 10 分钟；超预算
+                // 后不再开新尝试，直接 CHANNEL_FULL_FAIL 终结。
+                totalBudgetMs: Number.isFinite(rg.totalBudgetMs) && rg.totalBudgetMs > 0 ? rg.totalBudgetMs : 600000,
                 speedTest: {
                     enabled: st.enabled !== false,
                     sortKey: ['ttft', 'latency', 'hybrid', 'smart'].includes(st.sortKey) ? st.sortKey : 'ttft',
@@ -331,26 +363,56 @@ export function apply(ctx, config) {
         }
     };
     // ---------- 引擎：单候选尝试 ----------
+    // F01/F02（审计）：超时必须能真正结束一次尝试。
+    //  - 旧行为：Promise.race 超时后 await inner.return()，但 return() 排在挂起的
+    //    next() 之后——上游挂着时 failover 被拖住（H02：15ms 超时 80ms 后仍未切换）。
+    //  - 新行为：每次尝试独立 AbortController。pi-ai 适配器把 options.signal 经
+    //    AbortSignal.any 融进 watchdog 并传给上游 HTTP（signal: watchdog.signal），
+    //    abort 即真正取消网络请求。超时路径：先 abort → 有界等待（3s）排干 → 放弃
+    //    等待继续 failover（放弃的迭代器由适配器的 finally 自行清理）。
+    //  - 生命周期（F02）：成功 return / 失败 / 消费者提前退出统一走 finally 的
+    //    有界 closeInner，不再只在 catch 里清理。
+    const ATTEMPT_CLOSE_BUDGET_MS = 3000;
     async function* streamAttempt(cfg, cand, options, attemptStart) {
         if (cand.provider.startsWith(ROUTE_PREFIX))
             throw { code: 'INVALID_CANDIDATE', message: 'candidate provider must not be a virtual route' };
         const llm = ctx.llm;
-        const inner = llm.stream(Object.assign({}, options, { provider: cand.provider, model: cand.model }));
+        // 用户取消信号透传 + 尝试自身的超时中止，二者融合为本次尝试的 signal
+        const attemptController = new AbortController();
+        const outerSignal = options.signal;
+        const relayAbort = () => { try { attemptController.abort(outerSignal.reason); } catch (_e) { } };
+        if (outerSignal) {
+            if (outerSignal.aborted)
+                relayAbort();
+            else
+                outerSignal.addEventListener('abort', relayAbort, { once: true });
+        }
+        const inner = llm.stream(Object.assign({}, options, { provider: cand.provider, model: cand.model, signal: attemptController.signal }));
         const timeoutMs = dynamicTimeoutMs(cfg, candKey(cand));
         let buffer = [];
         let started = false;
         let ttftMs = null;
         let lastAt = Date.now();
         let lastUsage = null;
-        const closeInner = async () => { try {
-            const c = inner.return ? inner.return() : null;
-            if (c && c.then)
-                await c;
-        }
-        catch (_e) { } };
+        let closed = false;
+        const closeInner = async () => {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                const c = inner.return ? inner.return() : null;
+                if (c && c.then) {
+                    await Promise.race([
+                        c,
+                        ctx.timeout(ATTEMPT_CLOSE_BUDGET_MS).then(() => { attemptController.abort({ code: 'TIMEOUT', message: 'attempt close budget exceeded' }); }, () => { }),
+                    ]);
+                }
+            }
+            catch (_e) { }
+        };
         try {
             while (true) {
-                if (options.signal && options.signal.aborted)
+                if (outerSignal && outerSignal.aborted)
                     throw { code: 'ABORTED', message: 'request aborted' };
                 const remaining = Math.max(0, timeoutMs - (Date.now() - (started ? lastAt : attemptStart)));
                 if (remaining <= 0)
@@ -362,6 +424,13 @@ export function apply(ctx, config) {
                 try {
                     next = await Promise.race([inner.next(), guard.promise]);
                 }
+                catch (raceErr) {
+                    // 超时（或任何 next 失败）：先中止本次尝试的上游请求再上抛——
+                    // 这是 F01 的核心：abort 信号会穿透 pi-ai 取消真实 HTTP 请求
+                    if (raceErr && raceErr.code === 'TIMEOUT')
+                        attemptController.abort(raceErr);
+                    throw raceErr;
+                }
                 finally {
                     // 超时路径同样要 dispose：ctx.effect 的注册表条目只有显式调用 disposer 才会移除
                     guard.dispose();
@@ -416,33 +485,144 @@ export function apply(ctx, config) {
             }
         }
         catch (err) {
-            await closeInner();
             if (started && err && typeof err === 'object')
                 err.emitted = true;
             if (err && err.code === 'TIMEOUT')
                 recordHealth(cand.provider, cand, { ok: false, ttftMs, latencyMs: null, code: 'TIMEOUT', usage: lastUsage });
             throw err;
         }
+        finally {
+            // F02：所有出口（成功 return / 失败 / 消费者提前 return）统一有界关闭；
+            // relayAbort 监听器随本次尝试终结移除（防泄漏：outerSignal 可能长命）
+            if (outerSignal)
+                outerSignal.removeEventListener('abort', relayAbort);
+            await closeInner();
+        }
     }
+    // ---------- F08 最小切片：候选能力过滤（防「成功路径改变用户输入」） ----------
+    // 审计 H14：虚拟模型声明 image，候选只支持 text——宿主把图片静默替换为
+    //   "[image omitted...]" 后仍返回 stop 成功（用户输入被改变却报成功）。
+    // 审计 H06：非推理候选被强塞 effort → dispatch 前被拒 → CHANNEL_FULL_FAIL。
+    // 策略：请求含图/带 effort 时，过滤「明确声明不支持」的候选；能力未知
+    // （inputModalities 缺失 = 未知，只有显式排除才是负能力——宿主契约）不过滤，
+    // 保持原 failover 行为。解析失败不阻塞（同样视作未知）。
+    // 缓存 60s TTL：pi-ai 的 resolveModel 是内存快照解析（已核安装版源码），
+    // 但 async 接口 + 每次请求都调不划算；能力基本静态，TTL 足够。
+    const capabilityCache = new Map(); // key: provider::model → { at, info }
+    const CAPABILITY_TTL_MS = 60000;
+    const resolveCapability = async (cand) => {
+        const key = candKey(cand);
+        const hit = capabilityCache.get(key);
+        if (hit && Date.now() - hit.at < CAPABILITY_TTL_MS)
+            return hit.info;
+        try {
+            const info = await ctx.llm.resolveModelInfo(cand.provider, cand.model);
+            const entry = { at: Date.now(), info };
+            capabilityCache.set(key, entry);
+            return info;
+        }
+        catch (_e) {
+            return null; // 解析失败 = 未知，不过滤
+        }
+    };
+    /** 请求是否包含图片输入（粗判：消息 content 里有 image 块）。 */
+    const requestHasImage = (options) => {
+        try {
+            return (options.messages || []).some((m) => Array.isArray(m === null || m === void 0 ? void 0 : m.content) && m.content.some((p) => p && p.type === 'image'));
+        }
+        catch (_e) {
+            return false;
+        }
+    };
+    /** 过滤掉明确不支持本次请求能力的候选；全部被滤或未知时退回原列表（不因过滤而失去候选）。 */
+    const filterByCapability = async (cands, options) => {
+        const needImage = requestHasImage(options);
+        const needReasoning = typeof options.reasoningEffort === 'string' && options.reasoningEffort.length > 0 && options.reasoningEffort !== 'off';
+        if (!needImage && !needReasoning)
+            return cands;
+        const skipped = [];
+        const kept = [];
+        for (const cand of cands) {
+            const info = await resolveCapability(cand);
+            if (info === null) {
+                kept.push(cand); // 未知：不过滤
+                continue;
+            }
+            if (needImage) {
+                const mods = info.inputModalities;
+                if (Array.isArray(mods) && mods.length > 0 && !mods.includes('image')) {
+                    skipped.push({ candidate: candKey(cand), reason: 'image input not supported' });
+                    continue; // 明确排除 image
+                }
+            }
+            if (needReasoning && info.reasoning === undefined) {
+                skipped.push({ candidate: candKey(cand), reason: 'reasoning not supported' });
+                continue; // 明确无 reasoning 档位
+            }
+            kept.push(cand);
+        }
+        // 全被滤掉 = 声明与所有候选冲突：退回原列表（让请求去撞，报真实错误）
+        // 而不是直接 NO_CANDIDATES 假装没有渠道
+        if (skipped.length > 0 && kept.length > 0) {
+            // 记录到组事件（cfg 此时未知，用 provider 维度的 console 代替；组事件在
+            // streamGroup 拿到 cfg 后会补记 capability-filter）
+            console.log('[model-channel-manager] capability filter:', skipped.map((s) => s.candidate + ' (' + s.reason + ')').join(', '));
+        }
+        return kept.length > 0 ? kept : cands;
+    };
+
     // ---------- 引擎：组级故障转移循环 ----------
     async function* streamGroup(cfg, options) {
         const rt = groupRuntime(cfg.id);
-        const order = orderedCandidates(cfg);
+        let order = orderedCandidates(cfg);
         if (order.length === 0) {
             pushEvent(cfg, 'no-candidates', {});
             yield failChunk('channel group "' + cfg.id + '" has no candidates', 'NO_CANDIDATES');
             return;
         }
+        // F14（审计 H07）：enabled=true 但从未测过速的组，首次真实使用时后台触发一次
+        // 自动测速（不阻塞、不 await 当前请求）。旧实现只有 boot 时的 onFirstUse 分支，
+        // 常规请求路径完全没有自动测速入口——开启开关后从未生效。
+        if (cfg.speedTest.enabled && (state.speedResults[cfg.id] || []).length === 0 && !rt.speedTestRunning) {
+            rt.speedTestRunning = true; // 先占位防重入（runSpeedTest 内部还会再查）
+            rt.speedTestRunning = false;
+            runSpeedTest(cfg).catch(() => { });
+        }
+        // F08：按本次请求能力过滤（含图/带 effort 时）。过滤发生在测速排序之后，
+        // 保序不改变相对优先级。
+        const before = order.length;
+        order = await filterByCapability(order, options);
+        if (order.length < before)
+            pushEvent(cfg, 'capability-filter', { skipped: before - order.length, kept: order.length });
         const strategy = cfg.strategy || 'sticky';
-        let cursor = strategy === 'primary' ? 0 : rt.currentIndex % order.length;
+        // F13（审计 H13）：round-robin 的指针改为「选择时原子预留」——旧实现成功后才
+        // 推进 rt.currentIndex，两个并发请求都从 first 开始（并发不均分）。
+        // 现在：选定时立即占位推进（同步读改写，JS 单线程内原子），失败不回滚
+        // （失败反馈走冷却，指针保持前进语义——轮询分布比严格顺序更重要）。
+        if (strategy === 'round-robin') {
+            cursor = rt.currentIndex % order.length;
+            rt.currentIndex = (cursor + 1) % order.length; // 本次请求已占用 cursor 槽位
+        }
+        else {
+            cursor = strategy === 'primary' ? 0 : rt.currentIndex % order.length;
+        }
         let fullRounds = 0;
         let lastFail = null;
         const failedKeys = [];
+        // 总请求预算（F01 配套）：组级起点。超预算不再开新尝试。
+        const groupStart = Date.now();
+        const budgetMs = cfg.totalBudgetMs || 600000;
+        const budgetLeft = () => budgetMs - (Date.now() - groupStart);
         while (true) {
             if (options.signal && options.signal.aborted) {
                 yield abortedChunk('request aborted');
                 return;
             }
+            if (budgetLeft() <= 0) {
+                pushEvent(cfg, 'budget-exhausted', { budgetMs, failures: failedKeys.slice() });
+                yield failChunk('channel group "' + cfg.id + '" exhausted its total budget of ' + budgetMs + 'ms: ' + (lastFail || 'multiple failures'), 'CHANNEL_BUDGET_EXCEEDED');
+                return;
+            }
             const round = [];
             for (let i = 0; i < order.length; i++)
                 round.push(order[(cursor + i) % order.length]);
@@ -465,6 +645,8 @@ export function apply(ctx, config) {
                         yield abortedChunk('request aborted');
                         return;
                     }
+                    if (budgetLeft() <= 0)
+                        break; // 预算耗尽：不开新尝试，交给组层终结
                     const attemptStart = Date.now();
                     try {
                         const attempt = streamAttempt(cfg, cand, options, attemptStart);
@@ -473,12 +655,12 @@ export function apply(ctx, config) {
                         succeeded = true;
                         candidateOk = true;
                         rt.cooldowns.delete(key);
+                        // F13：round-robin 的推进已移到选定时（见上方原子预留）；
+                        // 成功路径只维护 sticky/primary 的语义。
                         const pos = order.findIndex((c) => candKey(c) === key);
-                        if (strategy === 'round-robin')
-                            rt.currentIndex = (pos + 1) % order.length;
-                        else if (strategy === 'sticky')
+                        if (strategy === 'sticky')
                             rt.currentIndex = pos;
-                        else
+                        else if (strategy === 'primary')
                             rt.currentIndex = 0;
                         if (failedKeys.length > 0)
                             pushEvent(cfg, 'failover', { from: failedKeys[failedKeys.length - 1], to: key, reason: 'candidate change after ' + failedKeys.length + ' failure(s)' });
@@ -532,24 +714,47 @@ export function apply(ctx, config) {
         }
     }
     // ---------- 测速 ----------
+    // F15 修复：旧行为每 chunk 重置 guard（单次等待上限而非总时限，H12：timeoutMs=40
+    // 流每 20ms 输出，84ms 后仍成功）+ 超时不中止上游。现在：总时限 deadline +
+    // 超时 abort 上游（与 streamAttempt 同一模式）+ 统一 finally 关闭。
     async function measureCandidate(cfg, cand, st) {
         const llm = ctx.llm;
-        const inner = llm.stream({ provider: cand.provider, model: cand.model, messages: [{ role: 'user', content: [{ type: 'text', text: st.prompt }] }], maxTokens: st.maxTokens, sessionId: 'mcm-speedtest-' + (st.nonce ?? Date.now()) });
+        const controller = new AbortController();
+        const deadline = Date.now() + (st.timeoutMs || 60000);
+        const inner = llm.stream({ provider: cand.provider, model: cand.model, messages: [{ role: 'user', content: [{ type: 'text', text: st.prompt }] }], maxTokens: st.maxTokens, sessionId: 'mcm-speedtest-' + (st.nonce ?? Date.now()), signal: controller.signal });
         const start = Date.now();
         let ttft = null;
-        const closeInner = async () => { try {
-            const c = inner.return ? inner.return() : null;
-            if (c && c.then)
-                await c;
-        }
-        catch (_e) { } };
+        let closed = false;
+        const closeInner = async () => {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                const c = inner.return ? inner.return() : null;
+                if (c && c.then) {
+                    await Promise.race([
+                        c,
+                        ctx.timeout(ATTEMPT_CLOSE_BUDGET_MS).then(() => { try { controller.abort({ code: 'TIMEOUT', message: 'speedtest close budget exceeded' }); } catch (_e) { } }, () => { }),
+                    ]);
+                }
+            }
+            catch (_e) { }
+        };
         try {
             while (true) {
-                const guard = timed(Math.max(1, st.timeoutMs), () => ({ code: 'TIMEOUT', message: 'speedtest timed out after ' + st.timeoutMs + 'ms' }));
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    throw { code: 'TIMEOUT', message: 'speedtest timed out after ' + st.timeoutMs + 'ms (total)' };
+                const guard = timed(Math.max(1, remaining), () => ({ code: 'TIMEOUT', message: 'speedtest timed out after ' + st.timeoutMs + 'ms (total)' }));
                 let next;
                 try {
                     next = await Promise.race([inner.next(), guard.promise]);
                 }
+                catch (raceErr) {
+                    if (raceErr && raceErr.code === 'TIMEOUT')
+                        try { controller.abort(raceErr); } catch (_e) { }
+                    throw raceErr;
+                }
                 finally {
                     guard.dispose();
                 }
@@ -567,9 +772,11 @@ export function apply(ctx, config) {
             }
         }
         catch (err) {
-            await closeInner();
             throw { code: (err && err.code) || 'STREAM_ERROR', message: (err && err.message) || 'speedtest failed' };
         }
+        finally {
+            await closeInner();
+        }
     }
     async function runSpeedTest(cfg) {
         const rt = groupRuntime(cfg.id);
@@ -687,25 +894,48 @@ export function apply(ctx, config) {
     // ---------- 单模型真实请求测试（client 经 settings 总线下发，走 DSH 真实 llm.stream 链路） ----------
     async function runModelTest(provider, model, prompt, maxTokens) {
         const llm = ctx.llm;
-        const inner = llm.stream({ provider, model, messages: [{ role: 'user', content: [{ type: 'text', text: prompt || '你好' }] }], maxTokens: maxTokens || 512, sessionId: 'mcm-modeltest-' + Date.now() });
+        // F15（与 measureCandidate 同一模式）：总时限 60s（旧行为每 chunk 重置 guard，
+        // 持续输出的请求永不超时而 client 已放弃）+ 超时 abort 上游 + 统一 finally 关闭。
+        const MODEL_TEST_TOTAL_MS = 60000;
+        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 });
         const start = Date.now();
         let ttft = null;
         let text = '';
         let reasoning = '';
         let lastUsage = null;
-        const closeInner = async () => { try {
-            const c = inner.return ? inner.return() : null;
-            if (c && c.then)
-                await c;
-        }
-        catch (_e) { } };
+        let closed = false;
+        const closeInner = async () => {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                const c = inner.return ? inner.return() : null;
+                if (c && c.then) {
+                    await Promise.race([
+                        c,
+                        ctx.timeout(ATTEMPT_CLOSE_BUDGET_MS).then(() => { try { controller.abort({ code: 'TIMEOUT', message: 'model test close budget exceeded' }); } catch (_e) { } }, () => { }),
+                    ]);
+                }
+            }
+            catch (_e) { }
+        };
         try {
             while (true) {
-                const guard = timed(60000, () => ({ code: 'TIMEOUT', message: 'model test timed out after 60000ms' }));
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    throw { code: 'TIMEOUT', message: 'model test timed out after ' + MODEL_TEST_TOTAL_MS + 'ms (total)' };
+                const guard = timed(Math.max(1, remaining), () => ({ code: 'TIMEOUT', message: 'model test timed out after ' + MODEL_TEST_TOTAL_MS + 'ms (total)' }));
                 let next;
                 try {
                     next = await Promise.race([inner.next(), guard.promise]);
                 }
+                catch (raceErr) {
+                    if (raceErr && raceErr.code === 'TIMEOUT')
+                        try { controller.abort(raceErr); } catch (_e) { }
+                    throw raceErr;
+                }
                 finally {
                     guard.dispose();
                 }
@@ -736,41 +966,60 @@ export function apply(ctx, config) {
             }
         }
         catch (err) {
-            await closeInner();
             throw err;
         }
+        finally {
+            await closeInner();
+        }
     }
     function handleTestRequest(next) {
         const req = next.testRequest;
-        const last = Math.max(next.lastTestHandledNonce || 0, claimedTestNonce);
-        if (!req || typeof req.provider !== 'string' || typeof req.model !== 'string' || typeof req.nonce !== 'number' || req.nonce === last)
+        // 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 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'
+            || !shouldConsumeNonce({ consumed: consumedTestNonces, key: reqKey, claimed: claimedKey, settled, hasTerminal }))
             return;
-        claimedTestNonce = req.nonce;
+        markConsumed(consumedTestNonces, reqKey);
+        claimedTestNonce = reqNonce;
         // nonce 的落盘推迟到本次测试得出结论之后：只有「真跑过」才算 handled。
         // 启动早于凭据服务就绪时会以 MISSING_CREDENTIAL 失败，那要释放认领重试；
         // 若提前写了 nonce，重试会被自己的持久值挡掉。
         const settle = (entry) => {
             if (bus !== null)
-                bus.writeHealth({ lastTestHandledNonce: req.nonce }).catch((e) => console.error('[model-channel-manager] lastTestHandledNonce 写入失败:', e));
+                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(req.nonce);
-            const value = Object.assign({}, entry, { nonce: req.nonce, provider: req.provider, model: req.model });
-            const cur = healthOf().testResults || {};
+            const key = String(reqNonce);
+            const value = Object.assign({}, entry, { nonce: reqNonce, provider: req.provider, model: req.model });
             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 {
@@ -786,7 +1035,8 @@ export function apply(ctx, config) {
         }).catch(async (e) => {
             if (notReady(e)) {
                 // 凭据服务尚未就绪（典型是启动瞬间的重放）：不写成假 error，释放认领并延后重试
-                claimedTestNonce = 0;
+                claimedTestNonce = null;
+                releaseConsumed(consumedTestNonces, reqKey); // 释放后才能靠重放再消费
                 scheduleReplay('test', () => reloadFromConfig(false));
                 return;
             }
@@ -795,7 +1045,20 @@ export function apply(ctx, config) {
     }
     function rewireRoutes() {
         const llm = ctx.llm;
-        const next = pullConfig().groups.map((g) => routeOfGroup(g.id));
+        // F16（审计 H08）：normalizeConfig 对非法/重复 ID 是静默 continue——保存 3 组
+        // 实际只注册 1 条路由，界面仍显示「已保存」。这里把被丢弃的组大声报出来：
+        // 配置里有 N 组但只有 M 组成为路由时，用户能从日志看到哪组、为什么被丢。
+        const rawGroups = Array.isArray(state.config && state.config.groups) ? state.config.groups : [];
+        const normalized = pullConfig().groups;
+        if (rawGroups.length > normalized.length) {
+            const keptIds = new Set(normalized.map((g) => g.id));
+            const dropped = rawGroups
+                .map((g) => g && g.id)
+                .filter((id) => typeof id === 'string' && !keptIds.has(id));
+            if (dropped.length > 0)
+                console.warn('[model-channel-manager] 以下轮询组未通过校验，已被丢弃（不会成为路由）:', dropped.join(', '), '——组 ID 规则：小写字母/数字/连字符，且不重复');
+        }
+        const next = normalized.map((g) => routeOfGroup(g.id));
         const current = llm.listProviders().map((p) => p.id).filter((id) => id.startsWith(ROUTE_PREFIX));
         if (next.length === 0) {
             // 空配置：LLM 服务拒绝注册零 provider 的适配器——推迟首次注册；已注册则清空路由
@@ -874,21 +1137,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 时查询太早） ----------
@@ -896,8 +1179,27 @@ export function apply(ctx, config) {
     let runtimeRestored = false;
     // 非持久去重：回写要等当前 HMR 事务结束才落盘，这中间 volatile-update 可能带着同一个 nonce 再来，
     // 内存里先认领，避免同一请求被重复执行（并顺带消掉重复的回写风暴）。
-    let claimedTestNonce = 0;
-    let claimedSpeedNonce = 0;
+    //
+    // 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 = 未认领
+    const consumedTestNonces = new Set();  // 已消费过的 nonce 字符串键（含本次）
+    const consumedSpeedNonces = new Set();
+    const CONSUMED_NONCE_CAP = 256; // 上限：只用于防重复消费，不需要无限历史
+    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) => {
@@ -941,8 +1243,13 @@ export function apply(ctx, config) {
                 runtime.delete(id);
         rewireRoutes();
         const req = health.speedRequest;
-        const last = Math.max(health.lastHandledNonce || 0, claimedSpeedNonce);
-        if (req && typeof req.group === 'string' && typeof req.nonce === 'number' && req.nonce !== last) {
+        // 与 handleTestRequest 同一策略：nonce 兼容字符串/数字，去重按字符串键严格等值
+        const speedKey = nonceKey(req && req.nonce);
+        const speedClaimed = nonceKey(claimedSpeedNonce);
+        const speedSettled = settledNonceKey(health.lastHandledNonce);
+        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 的理由）：
@@ -954,7 +1261,8 @@ export function apply(ctx, config) {
             if (cfgRow)
                 runSpeedTest(cfgRow).then((r) => {
                     if (r && r.deferred) {
-                        claimedSpeedNonce = 0;
+                        claimedSpeedNonce = null;
+                        releaseConsumed(consumedSpeedNonces, speedKey);
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -962,7 +1270,8 @@ export function apply(ctx, config) {
                     settleSpeed();
                 }).catch((e) => {
                     if (notReady(e)) {
-                        claimedSpeedNonce = 0;
+                        claimedSpeedNonce = null;
+                        releaseConsumed(consumedSpeedNonces, speedKey);
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -993,70 +1302,74 @@ 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)));
         bus = {
             settings,
             writeHealth,
+            writeHealthOps,
+            writeHealthLeaf,
             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 就绪后再以它为权威重载。
+        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(); // 首屏投影：让健康页不用等下一次真实请求
+        // 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) {
@@ -1158,6 +1471,13 @@ export function apply(ctx, config) {
                     const text = await fsSvc.readText(target);
                     const legacy = JSON.parse(text);
                     const migrated = normalizeConfig(legacy);
+                    // F10（审计 H15）：读取是 await 的——这个窗口里用户可能已经保存了
+                    // 新组。写前重检：现在有组了就不迁（用户的新配置优先于旧文件复活）。
+                    if (pullConfig().groups.length !== 0) {
+                        console.log('[model-channel-manager] legacy migration skipped: user config arrived during read');
+                        bus.writeHealth({ legacyMigrated: true }).catch(() => { });
+                        return;
+                    }
                     if (migrated.groups.length > 0) {
                         await bus.settings.update(SELF_NS, { groups: migrated.groups });
                         state.config = { groups: migrated.groups };