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

package/src/index.js

@@ -1,6 +1,9 @@
 import z from "@deepseek-ai/schemastery";
+import { HealthStore } from './health-store.js';
 export const name = 'model-channel-manager';
 export const inject = ['llm', 'timer'];
+// storageDomain 由 dsh-base 组合（json 后端，root=storages/）；不进 inject 硬依赖——
+// 缺栈的 profile 降级为「健康流水不持久化」而不是拒绝启动。
 const ROUTE_PREFIX = 'roundrobin/';
 const GROUP_ID_RE = /^[a-z0-9][a-z0-9-]*$/;
 const NS_CONFIG = 'model-channels';
@@ -9,6 +12,8 @@ const NS_HEALTH = 'model-channel-health';
 // 因此原先的 model-channels / model-channel-health 两个命名空间合并为本插件的 Config
 // （字段 groups / providerOrder / effortMemory / health），命名空间 id 即本行 id。
 const HEALTH_SCHEMA = z.object({
+    // records/speedResults 仅作旧版存量迁移的读取源（迁入 domain 后不再写入）；
+    // 权威数据在 storageDomain 的 model_channel_health 单元。
     records: z.dict(z.array(z.any())).default({}),
     speedResults: z.dict(z.array(z.any())).default({}),
     runtime: z.dict(z.any()).default({}),
@@ -18,6 +23,10 @@ const HEALTH_SCHEMA = z.object({
     testResults: z.dict(z.any()).default({}),
     lastTestHandledNonce: z.number().default(0),
     legacyMigrated: z.any(),
+    healthMigrated: z.any(),
+    // 小投影：host 聚合好的健康摘要（client 渲染用），digestAt 为生成时刻
+    digest: z.array(z.any()).default([]),
+    digestAt: z.number().default(0),
 }).loose(true);
 export const Config = z.object({
     groups: z.array(z.any()).default([]).volatile(),
@@ -116,6 +125,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',
@@ -286,7 +299,6 @@ export function apply(ctx, config) {
     const recordHealth = (gid, cand, entry) => {
         const now = Date.now();
         const key = gid || 'global';
-        const list = state.records[key] || (state.records[key] = []);
         const rec = { ts: now, provider: cand.provider, model: cand.model, ok: entry.ok, ttftMs: entry.ttftMs, latencyMs: entry.latencyMs, code: entry.code || null };
         // 上游真实 token 用量（来自 usage StreamChunk，计费口径与 dsh-token-meter 一致）：
         // 展平写入记录条目；缺失/非法字段不写，旧记录按 0 处理（向后兼容）。
@@ -298,74 +310,81 @@ export function apply(ctx, config) {
             if (Number.isFinite(u.cacheWriteTokens)) rec.cacheWriteTokens = u.cacheWriteTokens;
             if (Number.isFinite(u.reasoningTokens)) rec.reasoningTokens = u.reasoningTokens;
         }
+        // 内存镜像（聚合与 smart 键读内存即可）+ domain 追加（事实持久化）。
+        // domain 写入走 per-record put（写一条只动一个渠道桶文档），
+        // 不再有 2s 防抖与 volatile 快照覆盖的竞态窗口。
+        const list = state.records[key] || (state.records[key] = []);
         list.push(rec);
         const cutoff = now - 7 * 24 * 3600 * 1000;
-        // 每键保留 300 条：健康页签 30m/24h 视图与选择器置顶绰绰有余，同时把
-        // settings.yaml 的体量压到可读（2000 条/键时该文件一度膨胀到 2 万行）
         state.records[key] = list.filter((e) => e.ts >= cutoff).slice(-300);
-        pendingRecords.push({ key, rec });
-        persistHealth();
+        if (healthStore !== null) {
+            healthStore.appendEvent(key, rec).catch((e) => console.warn('[model-channel-manager] health event append failed:', e && e.message));
+        }
+        scheduleDigest();
     };
     const persistSpeedResults = async (r) => {
+        if (healthStore !== null) {
+            await healthStoreSpeed(r).catch(() => { });
+        }
         if (bus === null) return;
-        await bus.writeHealth({ speedResults: clone(r), runtime: await persistRuntime() });
-    };
-    // ---------- 健康持久化节流：合并 2s 窗口内的写入，避免每个请求全量重写 settings ----------
-    let healthFlushHandle = null;
-    let healthDirty = false;
-    // 尚未落盘的流水：reloadFromConfig 每次 volatile-update 都用配置快照整体覆盖 state.records，
-    // 而 flush 有 2s 防抖——不缓冲的话，刚记下的一笔会在落盘前被内存覆盖（实测「测试成功不入账」就是这个）。
-    let pendingRecords = [];
-    const flushHealthNow = async () => {
-        if (bus === null) return;
-        const flushed = pendingRecords.slice();
-        await bus.writeHealth({ records: clone(pullRecords()), speedResults: clone(pullSpeedResults()), runtime: await persistRuntime() });
-        // 写入成功后才清账；失败就留着，等下一次 flush 重试
-        pendingRecords = pendingRecords.filter((p) => !flushed.includes(p));
+        await bus.writeHealth({ runtime: await persistRuntime() });
     };
-    const persistHealth = () => {
-        healthDirty = true;
-        if (healthFlushHandle === null) {
-            healthFlushHandle = ctx.timeout(() => {
-                healthFlushHandle = null;
-                if (!healthDirty) return;
-                healthDirty = false;
-                flushHealthNow().catch(() => { });
-            }, 2000);
+    const healthStoreSpeed = async (r) => {
+        for (const [groupId, rows] of Object.entries(r || {})) {
+            await healthStore.putSpeedRows(groupId, rows);
         }
     };
-    ctx.effect(() => () => {
-        // 插件卸载时尽力冲刷最后一批健康数据（settings 服务仍在，失败静默）
-        if (healthFlushHandle !== null) {
-            healthFlushHandle();
-            healthFlushHandle = null;
-        }
-        if (healthDirty) {
-            healthDirty = false;
-            flushHealthNow().catch(() => { });
-        }
-    }, 'model-channel health flush');
     // ---------- 引擎：单候选尝试 ----------
+    // 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)
@@ -377,6 +396,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();
@@ -431,33 +457,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]);
@@ -480,6 +617,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);
@@ -488,12 +627,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)' });
@@ -547,24 +686,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();
                 }
@@ -582,9 +744,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);
@@ -702,25 +866,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();
                 }
@@ -751,28 +938,35 @@ 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 统一为字符串 UUID（0.3.2 起 client 换 randomUUID，防同毫秒碰撞）；
+        // 旧数字 nonce（Date.now()%1e9）仍被接受：typeof 兼容两种，比较用 !==。
+        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)
             return;
-        claimedTestNonce = req.nonce;
+        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；结果集按当前值合并后整段写回。
         const setResult = async (entry) => {
-            const key = String(req.nonce);
-            const value = Object.assign({}, entry, { nonce: req.nonce, provider: req.provider, model: req.model });
+            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));
@@ -801,7 +995,7 @@ export function apply(ctx, config) {
         }).catch(async (e) => {
             if (notReady(e)) {
                 // 凭据服务尚未就绪（典型是启动瞬间的重放）：不写成假 error，释放认领并延后重试
-                claimedTestNonce = 0;
+                claimedTestNonce = null;
                 scheduleReplay('test', () => reloadFromConfig(false));
                 return;
             }
@@ -810,7 +1004,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 的适配器——推迟首次注册；已注册则清空路由
@@ -823,13 +1030,96 @@ export function apply(ctx, config) {
         else if (JSON.stringify(current) !== JSON.stringify(next))
             adapterHandle.replace(next);
     }
+    // ---------- 健康数据 domain 存储 + 存量迁移 + 小投影 ----------
+    // healthStore：storageDomain 存在时启用（dsh-base 组合了 json 后端）。
+    // 启动序列：先开 domain → 迁移 settings 存量 → reloadFromConfig 从 domain 读权威数据。
+    let healthStore = null;
+    // digest：写进 settings health 子树的小投影（client 健康页渲染用）。
+    // 聚合上移 host，client 不再拉原始流水全量 describe——settings 里不再出现 records。
+    let digestTimer = null;
+    const DIGEST_INTERVAL = 5000;
+    const buildDigest = () => {
+        // 与旧 client HealthPanel 聚合口径一致：total/success/ttft/latency/token（计费口径
+        // = input + cacheRead + cacheWrite + output），外加 lastTs/lastOk/lastCode
+        const by = new Map();
+        for (const list of Object.values(state.records)) {
+            for (const e of list) {
+                const key = e.provider + '::' + e.model;
+                let a = by.get(key);
+                if (a === undefined) {
+                    a = { provider: e.provider, model: e.model, total: 0, success: 0, ttftSum: 0, latSum: 0, tokIn: 0, tokOut: 0, tokCache: 0, lastTs: 0, lastOk: null, lastCode: null };
+                    by.set(key, a);
+                }
+                a.total++;
+                const inTok = e.inputTokens || 0;
+                const outTok = e.outputTokens || 0;
+                const cacheTok = (e.cacheReadTokens || 0) + (e.cacheWriteTokens || 0);
+                a.tokIn += inTok;
+                a.tokOut += outTok;
+                a.tokCache += cacheTok;
+                if (e.ok) {
+                    a.success++;
+                    if (e.ttftMs != null && e.ttftMs >= 0) a.ttftSum += e.ttftMs;
+                    if (e.latencyMs != null && e.latencyMs >= 0) a.latSum += e.latencyMs;
+                }
+                if ((e.ts || 0) > a.lastTs) {
+                    a.lastTs = e.ts || 0;
+                    a.lastOk = e.ok;
+                    a.lastCode = e.ok ? null : (e.code || null); // lastCode 随 lastTs 对齐（不再按遍历序覆盖）
+                }
+            }
+        }
+        return [...by.values()].map((a) => ({
+            provider: a.provider, model: a.model, total: a.total, success: a.success,
+            ttftAvg: a.success > 0 ? Math.round(a.ttftSum / a.success) : null,
+            latAvg: a.success > 0 ? Math.round(a.latSum / a.success) : null,
+            tokIn: a.tokIn, tokOut: a.tokOut, tokCache: a.tokCache,
+            lastTs: a.lastTs, lastOk: a.lastOk, lastCode: a.lastCode,
+        }));
+    };
+    const flushDigest = () => {
+        digestTimer = null;
+        if (bus !== null) {
+            bus.writeHealth({ digest: buildDigest(), digestAt: Date.now() }).catch(() => { });
+        }
+    };
+    const scheduleDigest = () => {
+        if (digestTimer === null) {
+            digestTimer = ctx.timeout(flushDigest, DIGEST_INTERVAL);
+        }
+    };
+    ctx.effect(() => () => {
+        if (digestTimer !== null) {
+            digestTimer();
+            digestTimer = null;
+        }
+        flushDigest();
+    }, 'model-channel health digest');
+    // settings 存量 records/speedResults → domain 一次性迁移（桶已存在即跳过，domain 权威）。
+    const migrateHealthToDomain = async () => {
+        if (healthStore === null || bus === null) return;
+        const health = healthOf();
+        if (health.healthMigrated === true) return;
+        let ok = false;
+        try {
+            ok = await healthStore.migrateFrom(health.records || {}, health.speedResults || {});
+        }
+        catch (_e) {
+            ok = false; // 下次启动再试
+        }
+        if (!ok) return; // store 已关闭（卸载竞态）：不写标记，避免标记与数据永久不一致
+        // 同一次合并写：迁移标记 + 清空 settings 里的旧存量（否则 writeHealth 的
+        // Object.assign 会把 records/speedResults 永远带下去，profile 膨胀问题未真正解决）
+        bus.writeHealth({ healthMigrated: true, records: {}, speedResults: {} }).catch(() => { });
+    };
+
     // ---------- settings 总线接入（响应式：settings 服务异步初始化，apply 时查询太早） ----------
     let bus = null;
     let runtimeRestored = false;
     // 非持久去重：回写要等当前 HMR 事务结束才落盘，这中间 volatile-update 可能带着同一个 nonce 再来，
     // 内存里先认领，避免同一请求被重复执行（并顺带消掉重复的回写风暴）。
-    let claimedTestNonce = 0;
-    let claimedSpeedNonce = 0;
+    let claimedTestNonce = null; // string UUID 或旧数字；null = 未认领
+    let claimedSpeedNonce = null; // string UUID 或旧数字；null = 未认领
     // 启动早于凭据服务就绪：此时重放测试/测速会以 MISSING_CREDENTIAL 失败。
     // 这类错误是「环境还没准备好」而不是「渠道故障」，必须释放认领、延后重试，不能写成假 error。
     const notReady = (e) => {
@@ -846,18 +1136,19 @@ export function apply(ctx, config) {
         ctx.timeout(() => { fn(); }, ms);
     };
     // 从实例配置读取全部状态；volatile 提交后由 loader/volatile-update 触发重载。
+    // 0.3.1 起 records/speedResults 的权威在 storageDomain（healthStore）；
+    // settings health 子树只承载小投影（digest 给 client 渲染）+ 运行态 + 任务哨，
+    // volatile 快照覆盖不再能抹掉任何流水（F11/F23 的根因消除）。
     function reloadFromConfig(initial) {
         const cfg = cfgOf();
         state.config = clone(cfg) || { groups: [] };
         const health = healthOf();
-        state.records = clone(health.records || {});
-        // 配置快照覆盖后，把尚未落盘的流水补回来（ts+provider+model 相同视为同一笔，不重复）
-        for (const p of pendingRecords) {
-            const list = state.records[p.key] || (state.records[p.key] = []);
-            if (!list.some((e) => e.ts === p.rec.ts && e.provider === p.rec.provider && e.model === p.rec.model))
-                list.push(p.rec);
-        }
-        state.speedResults = clone(health.speedResults || {});
+        state.records = healthStore !== null
+            ? clone(healthStore.allEventBuckets())
+            : clone(health.records || {});
+        state.speedResults = healthStore !== null
+            ? clone(healthStore.allSpeedBuckets())
+            : clone(health.speedResults || {});
         state.testResults = clone(health.testResults || {});
         if (initial && !runtimeRestored) {
             restoreRuntime(health.runtime || {});
@@ -872,20 +1163,23 @@ 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) {
-            claimedSpeedNonce = req.nonce;
+        // 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;
             const cfgRow = pullConfig().groups.find((g) => g.id === req.group);
             // nonce 落盘推迟到本次测速得出结论之后（同 handleTestRequest 的理由）：
             // 提前写会把「没就绪」的重试用自己的持久值挡掉。
             const settleSpeed = () => {
                 if (bus !== null)
-                    bus.writeHealth({ lastHandledNonce: req.nonce }).catch(() => { });
+                    bus.writeHealth({ lastHandledNonce: speedNonce }).catch(() => { });
             };
             if (cfgRow)
                 runSpeedTest(cfgRow).then((r) => {
                     if (r && r.deferred) {
-                        claimedSpeedNonce = 0;
+                        claimedSpeedNonce = null;
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -893,7 +1187,7 @@ export function apply(ctx, config) {
                     settleSpeed();
                 }).catch((e) => {
                     if (notReady(e)) {
-                        claimedSpeedNonce = 0;
+                        claimedSpeedNonce = null;
                         scheduleReplay('speed', () => reloadFromConfig(false));
                         return;
                     }
@@ -940,12 +1234,54 @@ export function apply(ctx, config) {
             cfgScope: { get: () => cfgOf() },
             healthScope: { get: () => healthOf() },
         };
-        reloadFromConfig(true);
+        // 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');
+        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);
+            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');
+            })
+                .catch((e) => {
+                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)');
         });
-        boot();
+        // boot 已在 domain ready 链尾（或降级分支）调用，此处不再调
     });
     // ---------- 全局 LLM 请求健康拦截 (涵盖所有非虚拟路由的真实渠道模型调用) ----------
     ctx.on('llm/stream', async function* (options, next) {
@@ -1047,6 +1383,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 };