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

package/README.md

@@ -58,7 +58,7 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 
 ## 数据通道（全走公共 seam，无私有 RPC）
 
-- 读配置/健康/运行态 = `api.settings.describe()` 过滤命名空间
+- 读配置/运行态 = `api.settings.describe()` 过滤命名空间
 - 保存 provider = `api.settings.update({ns:'llm-pi-ai', patch:{providers}})`
 - 保存轮询组 = `api.settings.update({ns:'model-channels', patch:{groups}})`
 - ⚡测速 = `api.settings.update({ns:'model-channel-health', patch:{speedRequest:{group,nonce}}})`（host watcher 消费）
@@ -67,7 +67,28 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 - 上述调用形状仍保留 0.1 的样子：client 半内建门面 `makeLegacyApi` 把 0.2 的**位置参数 + RemoteResult** 适配回旧的**对象入参 + `{result:{ok,value}}`**，并把 `model-channels` / `model-channel-health` 合成回旧命名空间视图（真实承载是本插件行 id `model-channel-manager` 的实例配置）。
 
 > **宿主边界（0.1 历史，0.2 已不适用）**：0.1 的 settings RPC 走 apiproxy 暴露白名单（`exposedNamespaces()` = LLM provider ns + `WEB_/PRODUCT_SETTINGS_NAMESPACES`），当时含该边界的宿主必须放行 `model-channels` / `model-channel-health`（本仓曾在 harness `dsh-host-apiproxy` 打 `PLUGIN_SETTINGS_NAMESPACES` 补丁）。
-> **0.2 的 settings 命名空间就是 profile 行 id**，由 `@deepseek-ai/dsh-api-settings-controller` 的 `describe` 直接投影本行实例配置，没有该白名单环节；对应地，本插件的数据落在 `~/.dsh/profiles/web/cordis.patch.yml` 的 `model-channel-manager` 行 `config` 下。
+> **0.2 的 settings 命名空间就是 profile 行 id**，由 `@deepseek-ai/dsh-api-settings-controller` 的 `describe` 直接投影本行实例配置，没有该白名单环节；对应地，本插件的配置落在 `~/.dsh/profiles/web/cordis.patch.yml` 的 `model-channel-manager` 行 `config` 下。
+
+## 健康数据存储（0.3.1 重构：事实数据归位 storageDomain）
+
+> 背景：0.3.0 及之前，健康流水整字段存在 settings health 子树里，每 2s 防抖整段重写
+> profile patch（实测 6350 行中 health 约占 3000 行），且与 volatile 快照覆盖互相踩——
+> 刚记的账在落盘前被旧快照抹掉（审计 F11/F23，「测试成功不入账」的根因）。
+
+- **权威存储**：`storageDomain` 的 `model_channel_health` 单元（dsh-base 已组合 json 后端，
+  root=`~/.dsh/storages/`），`per-record` 布局——一条渠道一个桶文档，`backup-and-skip`
+  容错。host 侧 `src/health-store.js` 封装：追加走原子写链（并发 `recordHealth` 不丢更新）、
+  7 天窗口过期、每桶 300 条截断。
+- **settings 只存小投影**：`health.digest`（host 聚合好的摘要数组：total/success/ttft/latency/
+  token 三分项/lastTs）+ `digestAt`，client 健康页渲染用；不再下发原始流水。
+- **聚合上移 host**：`buildDigest` 在 host 折叠（口径同旧 client：计费 token = input +
+  cacheRead + cacheWrite + output），client 不再拉全量 describe 做原始事件折叠。
+- **存量迁移**：首次启动自动把 settings 里的 `records`/`speedResults` 搬入 domain（桶已存在
+  即跳过，幂等），同一次合并写里清空 settings 旧存量并落 `healthMigrated` 标记。
+- **降级**：storageDomain 缺席的 profile 退化为纯内存（不持久化流水），不拒绝启动。
+- **client 兼容**：旧 host（无 digest 字段）自动回落原始 records 路径，升级窗口不断供。
+- **已知近似**：30m/24h 视图按「最近活跃渠道」过滤，数值仍是 7 天累计（UI 已标注）；
+  精确分窗口需 host 出多份 digest，后续增强。
 
 ## 响应信封（重要）
 
@@ -129,7 +150,7 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 ## host 半内部接口
 
 - settings 接入用 **`ctx.inject(['settings'], (sctx) => {...})`**（settings 服务异步初始化，apply 时 `ctx.get('settings')` 为 undefined——曾经整个引擎静默失效，命名空间从未注册）
-- 配置 schema（schemastery）：`model-channels` 的虚模型/candidates/strategy/timeoutMs/cooldownMs/maxRetriesPerCandidate/speedTest；`model-channel-health` 的 records 7 天切片（单组 ≤2000 条）/speedResults/runtime/speedRequest+lastHandledNonce/testRequest+testResults+lastTestHandledNonce
+- 配置 schema（schemastery）：`model-channels` 的虚模型/candidates/strategy/timeoutMs/cooldownMs/maxRetriesPerCandidate/speedTest；`model-channel-health` 的 runtime/speedRequest+lastHandledNonce/testRequest+testResults+lastTestHandledNonce/digest 小投影（records/speedResults 仅作 0.3.1 迁移的读取源，权威在 storageDomain）
 - 引擎：sticky/round-robin/primary 三策略；首响应超时 + 流中空闲超时（动态 = max(timeoutMs, min(120s, ttft×2))）；单候选原地重试（指数退避）耗尽才换；全炸清冷却重试一轮；测速 ttft/latency/hybrid/smart 四键（smart = 0.5×ttft_norm + 0.3×(1−reliability) + 0.2×latency_norm，reliability 贝叶斯平滑 `(success+2.5)/(total+5)`）；测速失败进冷却；请求隔离按组
 - 虚拟模型元数据：`reasoning.efforts` 七档（off…max）、**defaultEffort=max**——原生 `/model` 弹窗对新模型的自动填档与展示跟随该声明；会话内显式档位的跨会话恢复由 selector 插件的档位记忆层负责（`modelDirectories` 拦截，存 `model-channels.effortMemory`）
 - 迁移：startup 时从工作区 `.channel-manager/config.json` 一次性迁入 `model-channels`（无遗留则忽略）；完成后写 `legacyMigrated` 哨兵防止「清空组后重启复活」；fs 未就绪时 5s×6 重试
@@ -176,5 +197,6 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 20. **诊断临时实例必须独立 home（`DSH_HOME=/tmp/dsh-diag dsh ...`）**：临时实例与主实例共用 `~/.dsh` 会并发写同一会话日志与 `session_projcache.json`——两进程各自的 seq 计数器交错追加，日志出现重复 seq → `corrupt session log: seq gap in committed region` → 会话 resume 直接拒绝，表现为该会话内模型目录加载失败（选择器「暂无可用模型」）。修复：解压 jsonl 删掉多余事件即可（后续 seq 连续则天然对齐），用 `session-persistence-jsonl` 的 `scanLog` 校验后压缩回写；杀进程前务必备份。
 21. **适配器契约以安装运行时的 d.ts 为准，不能照抄源码仓快照**：源码仓较新、rc.2 运行时的 `LlmAdapter` 多一个必需的 `prepareCall(provider, model, signal) → Promise<{model, stream}>`（主分发路径 llm.stream/llm.prepareCall 都先走它再 `adapterCall.stream(options)`；`adapter.stream` 在 rc.2 服务层从不直调）。缺它的症状极具迷惑性：注册/目录/菜单全正常，**真实发对话**才报 `registration.adapter.prepareCall is not a function`。实现对齐 llm-pi-ai 的快照模式：prepare 时捕获一份配置快照，元数据与 dispatch 都出自同一代。回归：`tests/adapter-contract.test.cjs`（T3 直接解析安装版 d.ts 的 LlmAdapter 方法集做契约同步）。
 22. **0.2 配置写入是 HMR 独占事务**：`settings.update` → `configEditor.edit()` → `hmr.runExclusive()`；在 `loader/volatile-update` 回调里回写会抛 `HMR transactions cannot be nested`（实测一段会话内 15 次，面板“测试”结果永远落不了盘）。事务内创建的**任何**异步资源（`AsyncResource` / `setTimeout` / `setInterval`）都继承事务上下文，**只有 `AsyncLocalStorage.exit()` 能切出**：`ctx.get('hmr').executing.exit(fn)`（仅当 `getStore()` 为真时切）。写入会被 `runExclusive` 排进队列、在本次事务结束后执行；**监听器保持同步、不要在外层事务里 await 它**（队列串行，互等即死锁）。
-23. **整字段落盘 + 内存态被配置快照覆盖**：`settings.update` 是整字段替换；`reloadFromConfig()` 每次 volatile-update 都用配置快照整体覆盖 `state.records`，而健康 flush 有 2s 防抖 → **刚记下的一笔在落盘前就被内存覆盖**（症状：面板“测试”成功不入账，失败反被全局拦截器的 catch 记上）。修法：`pendingRecords` 缓冲，快照覆盖后把未落盘的补回，flush 成功后再清账。
+23. **整字段落盘 + 内存态被配置快照覆盖**（0.3.1 已根治）：`settings.update` 是整字段替换；旧实现 `reloadFromConfig()` 每次 volatile-update 都用配置快照整体覆盖 `state.records`，而健康 flush 有 2s 防抖 → **刚记下的一笔在落盘前就被内存覆盖**（症状：面板“测试”成功不入账，失败反被全局拦截器的 catch 记上）。当时的修法是 `pendingRecords` 缓冲补账；0.3.1 起权威数据搬入 storageDomain（见「健康数据存储」），settings 只存 digest 小投影，此竞态从数据模型层消除。
 24. **nonce 落盘时机与启动竞态**：`lastTestHandledNonce` / `lastHandledNonce` 必须在**得出结果之后**写（提前写会让“未就绪”的重试被自己的持久值挡掉）；启动瞬间凭据服务尚未就绪时测试/测速会以 `MISSING_CREDENTIAL` 失败（凭据其实已在 `.credentials.yaml` 里），应识别为「还没就绪」→ 释放认领 + 5s 延时重试（上限 24 次），**不要**写成渠道故障；测速还必须在整组候选都因未就绪失败时**不落盘、不冷却**，否则一次启动重放就把所有渠道误判成故障。
+25. **domain 写入的并发丢失（0.3.1 review 挽救）**：`KvTable.put` 是整 record 覆盖，`get→filter→put` 的读-改-写在 put 的 IO 延迟窗口内并发调用会互相覆盖（后写盖先写，先记的账丢失）——恰好复刻了要消灭的丢账问题。**并发追加必须走原子链**：`update(key, fn)` 的 fn 在写链队列槽位看到当前值；桶不存在时 update 报 `missing-key`，先 put 初始化。另外在 promise 链里 `ctx.effect` 注册 disposer 前必须先验 fiber 活性——对 inactive fiber 注册会抛 `INACTIVE_EFFECT`，若被外层 catch 吞掉则 domain 永不 close，facility 名字被占 → HMR 重载后 `already-open` 静默降级。回归：`tests/health-domain-sync.test.cjs`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcaneorion/dsh-model-channel-manager",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "src/index.js",
   "exports": {
@@ -40,8 +40,10 @@
     "@deepseek-ai/dsh-client-connection": "0.2.0-rc.1",
     "@deepseek-ai/dsh-client-ui-conversation": "0.2.0-rc.1",
     "@deepseek-ai/dsh-api-remotes": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-storage-domain": "0.2.0-rc.1",
     "@deepseek-ai/schemastery": ">=3.18.4",
-    "react": "^18.3.1"
+    "react": "^18.3.1",
+    "zod": "^4.4.3"
   },
   "dsh": {
     "bundle": {

package/src/client.js

@@ -1065,11 +1065,13 @@ window.__ModuleLoader__.load({
 
       const now = Date.now()
       const windowCutoff = windowMode === '30m' ? now - 30 * 60 * 1000 : windowMode === '24h' ? now - 24 * 3600 * 1000 : 0
-      const recsMap = health.records || {}
-      const rawEvents = Object.values(recsMap).flat()
-      // 时间窗口过滤
-      const allEvents = rawEvents.filter((e) => (e.ts || 0) >= windowCutoff)
 
+      // ---------- 聚合数据源 ----------
+      // 0.3.1 起优先用 host 下发的 digest 小投影（聚合已上移 host，client 不再拉原始流水）。
+      // digest 是 7 天全窗口聚合；30m/24h 视图按 lastTs 近似（lastTs 在窗口内才计入），
+      // 精细窗口统计属后续增强（需要 host 按窗口出多份 digest）。
+      // 旧 host 兼容：无 digest 字段时走原始 records 路径（升级窗口不断供）。
+      const digestRows = Array.isArray(health.digest) ? health.digest : null
       // 按 provider 分组
       const byProvider = new Map()
 
@@ -1092,7 +1094,10 @@ window.__ModuleLoader__.load({
               lastOk: null,
               lastCode: null,
               recentErrors: 0,
-              tokSum: 0
+              tokSum: 0,
+              tokIn: 0,
+              tokOut: 0,
+              tokCache: 0
             })
           }
         }
@@ -1103,57 +1108,134 @@ window.__ModuleLoader__.load({
       let totalTokOut = 0
       let totalTokCache = 0
 
-      // 累加时间窗口内的真实流水记录
-      for (const e of allEvents) {
-        if (!e || !e.provider || !e.model) continue
-        let pMap = byProvider.get(e.provider)
-        if (!pMap) { pMap = new Map(); byProvider.set(e.provider, pMap) }
-        let a = pMap.get(e.model)
-        if (!a) {
-          a = {
-            provider: e.provider,
-            model: e.model,
-            name: e.model,
-            total: 0,
-            success: 0,
-            fail: 0,
-            ttftSum: 0,
-            latSum: 0,
-            lastTs: 0,
-            lastOk: null,
-            lastCode: null,
-            recentErrors: 0,
-            tokSum: 0
+      if (digestRows !== null) {
+        // ---------- digest 投影路径 ----------
+        for (const row of digestRows) {
+          if (!row || !row.provider || !row.model) continue
+          // 窗口过滤：lastTs 不在窗口内的渠道不计入该窗口（近似口径，见上注）
+          if (windowCutoff > 0 && (row.lastTs || 0) < windowCutoff) continue
+          let pMap = byProvider.get(row.provider)
+          if (!pMap) { pMap = new Map(); byProvider.set(row.provider, pMap) }
+          let a = pMap.get(row.model)
+          if (!a) {
+            a = {
+              provider: row.provider,
+              model: row.model,
+              name: row.model,
+              total: 0,
+              success: 0,
+              fail: 0,
+              ttftSum: 0,
+              latSum: 0,
+              lastTs: 0,
+              lastOk: null,
+              lastCode: null,
+              recentErrors: 0,
+              tokSum: 0,
+              tokIn: 0,
+              tokOut: 0,
+              tokCache: 0
+            }
+            pMap.set(row.model, a)
           }
-          pMap.set(e.model, a)
-        }
-        a.total++
-        const tokIn = (e && e.inputTokens) || 0
-        const tokOut = (e && e.outputTokens) || 0
-        const tokCache = ((e && e.cacheReadTokens) || 0) + ((e && e.cacheWriteTokens) || 0)
-        totalTokIn += tokIn
-        totalTokOut += tokOut
-        totalTokCache += tokCache
-        a.tokSum += tokIn + tokOut + tokCache
-        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
-        } else {
-          a.fail++
-          if (e.code) a.lastCode = e.code
+          a.total = row.total || 0
+          a.success = row.success || 0
+          a.fail = a.total - a.success
+          a.ttftSum = (row.ttftAvg || 0) * a.success
+          a.latSum = (row.latAvg || 0) * a.success
+          a.lastTs = row.lastTs || 0
+          a.lastOk = row.lastOk
+          a.lastCode = row.lastCode || null
+          a.tokIn = row.tokIn || 0
+          a.tokOut = row.tokOut || 0
+          a.tokCache = row.tokCache || 0
+          a.tokSum = a.tokIn + a.tokOut + a.tokCache
+          totalTokIn += a.tokIn
+          totalTokOut += a.tokOut
+          totalTokCache += a.tokCache
         }
-        if ((e.ts || 0) > a.lastTs) {
-          a.lastTs = e.ts || 0
-          a.lastOk = e.ok
+      } else {
+        // ---------- 旧 host 原始流水路径（兼容） ----------
+        const recsMap = health.records || {}
+        const rawEvents = Object.values(recsMap).flat()
+        // 时间窗口过滤（赋给函数级 allEvents，供顶部指标卡使用）
+        allEvents = rawEvents.filter((e) => (e.ts || 0) >= windowCutoff)
+        // 累加时间窗口内的真实流水记录
+        for (const e of allEvents) {
+          if (!e || !e.provider || !e.model) continue
+          let pMap = byProvider.get(e.provider)
+          if (!pMap) { pMap = new Map(); byProvider.set(e.provider, pMap) }
+          let a = pMap.get(e.model)
+          if (!a) {
+            a = {
+              provider: e.provider,
+              model: e.model,
+              name: e.model,
+              total: 0,
+              success: 0,
+              fail: 0,
+              ttftSum: 0,
+              latSum: 0,
+              lastTs: 0,
+              lastOk: null,
+              lastCode: null,
+              recentErrors: 0,
+              tokSum: 0,
+              tokIn: 0,
+              tokOut: 0,
+              tokCache: 0
+            }
+            pMap.set(e.model, a)
+          }
+          a.total++
+          const tokIn = (e && e.inputTokens) || 0
+          const tokOut = (e && e.outputTokens) || 0
+          const tokCache = ((e && e.cacheReadTokens) || 0) + ((e && e.cacheWriteTokens) || 0)
+          totalTokIn += tokIn
+          totalTokOut += tokOut
+          totalTokCache += tokCache
+          a.tokIn += tokIn
+          a.tokOut += tokOut
+          a.tokCache += tokCache
+          a.tokSum += tokIn + tokOut + tokCache
+          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
+          } else {
+            a.fail++
+            if (e.code) a.lastCode = e.code
+          }
+          if ((e.ts || 0) > a.lastTs) {
+            a.lastTs = e.ts || 0
+            a.lastOk = e.ok
+          }
         }
       }
 
-      const totalRequests = allEvents.length
-      const totalSuccess = allEvents.filter((x) => x.ok).length
+      // 顶部指标卡：digest 路径用聚合值求和，旧路径用原始事件计数
+      // （allEvents 提升到函数级：旧 host 回落路径的 else 块在此作用域外定义它）
+      let allEvents = []
+      let totalRequests = 0
+      let totalSuccess = 0
+      let ttftWeightedSum = 0
+      if (digestRows !== null) {
+        for (const pMap of byProvider.values()) {
+          for (const a of pMap.values()) {
+            totalRequests += a.total
+            totalSuccess += a.success
+            ttftWeightedSum += a.ttftSum
+          }
+        }
+      } else {
+        totalRequests = allEvents.length
+        totalSuccess = allEvents.filter((x) => x.ok).length
+        for (const pMap of byProvider.values()) {
+          for (const a of pMap.values()) ttftWeightedSum += a.ttftSum
+        }
+      }
       const globalRate = totalRequests > 0 ? ((totalSuccess / totalRequests) * 100).toFixed(1) + '%' : '100%'
-      const validTtfts = allEvents.filter((x) => x.ok && x.ttftMs != null).map((x) => x.ttftMs)
-      const avgGlobalTtft = validTtfts.length > 0 ? (validTtfts.reduce((a, b) => a + b, 0) / validTtfts.length / 1000).toFixed(2) + 's' : '—'
+      const avgGlobalTtft = totalSuccess > 0 ? (ttftWeightedSum / totalSuccess / 1000).toFixed(2) + 's' : '—'
 
       const providerGroups = [...byProvider.entries()].map(([provName, modelMap]) => {
         const models = [...modelMap.values()].map((m) => {
@@ -1212,7 +1294,9 @@ window.__ModuleLoader__.load({
           el('div', { className: 'mcm-metric-card' },
             el('span', { className: 'mcm-metric-label' }, windowMode === '30m' ? '近 30 分钟请求' : windowMode === '24h' ? '近 24 小时请求' : '7 天全周期请求'),
             el('span', { className: 'mcm-metric-value' }, totalRequests),
-            el('span', { style: { fontSize: 11, color: 'var(--dsw-alias-label-tertiary)' } }, '真实上游交互捕获')
+            // digest 聚合是 7 天窗口口径；30m/24h 只按「最近活跃」过滤渠道，数值为该渠道 7 天累计
+            el('span', { style: { fontSize: 11, color: 'var(--dsw-alias-label-tertiary)' } },
+              digestRows !== null && windowMode !== '7d' ? '窗口内活跃渠道的 7 天累计（聚合口径）' : '真实上游交互捕获')
           ),
           el('div', { className: 'mcm-metric-card' },
             el('span', { className: 'mcm-metric-label' }, '总 Token 用量'),
@@ -1334,7 +1418,12 @@ window.__ModuleLoader__.load({
           setChannels(ch)
           setChannelsDraft((prev) => prev || clone(ch))
           const hn = findNs('model-channel-health')
-          setHealth(hn ? { records: (hn.value && hn.value.records) || {}, speedResults: (hn.value && hn.value.speedResults) || {}, runtime: (hn.value && hn.value.runtime) || {} } : null)
+          // 0.3.1：健康权威数据在 host 的 storageDomain；client 只接收小投影 digest。
+          // 兼容旧 host（无 digest 字段）时回落到 records 原始视图，避免升级窗口白屏。
+          const hv = (hn && hn.value) || {}
+          setHealth(hv.digest || (hv.digestAt !== undefined)
+            ? { digest: hv.digest || [], digestAt: hv.digestAt || 0, speedResults: hv.speedResults || {}, runtime: hv.runtime || {} }
+            : (hn ? { records: hv.records || {}, speedResults: hv.speedResults || {}, runtime: hv.runtime || {} } : null))
         }).catch((e) => setNotice('加载失败: ' + String(e)))
       }
 
@@ -1350,11 +1439,10 @@ window.__ModuleLoader__.load({
             const d = unwrap(resp)
             const hn = ((d && d.namespaces) || []).find((n) => n && n.ns === 'model-channel-health')
             if (hn && hn.value) {
-              setHealth({
-                records: hn.value.records || {},
-                speedResults: hn.value.speedResults || {},
-                runtime: hn.value.runtime || {}
-              })
+              const hv = hn.value
+              setHealth(hv.digest || (hv.digestAt !== undefined)
+                ? { digest: hv.digest || [], digestAt: hv.digestAt || 0, speedResults: hv.speedResults || {}, runtime: hv.runtime || {} }
+                : { records: hv.records || {}, speedResults: hv.speedResults || {}, runtime: hv.runtime || {} })
             }
           }).catch(() => {})
         }

package/src/health-store.js

@@ -0,0 +1,169 @@
+/**
+ * 健康数据存储：原始流水（事件/测速）搬入 storageDomain 的 per-record KV 表。
+ *
+ * 动机（审计 F11/F12/F23 的根因）：0.1 时代健康流水整字段存在 settings 命名空间里，
+ * 与配置共用同一条「HMR 独占事务 + 整字段落盘」通道，导致：
+ *  - 2s 防抖 flush 与 volatile-update 快照覆盖互相踩（刚记的账被旧快照抹掉）；
+ *  - profile patch 文件膨胀（实测 6350 行中 health 约占 3000 行）；
+ *  - 任何无关 settings 写入都会整段重写健康数据。
+ *
+ * 现在的归属：事实数据（append-only 事件）进 domain；settings 里只保留
+ * 一份给 client 渲染用的小投影（聚合摘要 + 运行态指针），由 host 定期刷新。
+ *
+ * 组合方式照抄 dsh-session-projection-cache 范本：
+ *  - 依赖方 inject ['storageDomain']（dsh-base 已装 json 后端，root=storages/）；
+ *  - Service.init 里 open(spec)，effect 持有 close；
+ *  - per-record 布局：一条事件一个文档，坏记录 backup-and-skip 不阻塞整体。
+ */
+import { z } from 'zod';
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+
+const WINDOW_MS = 7 * 24 * 3600 * 1000;
+// 每渠道保留上限：30m/24h 视图 + selector 置顶绰绰有余，同时控制 storages/ 目录体量
+const PER_KEY_LIMIT = 300;
+
+/** 单条健康事件记录（zod，domain 落盘边界校验）。向后兼容：token 字段可选。 */
+const eventRecord = z.object({
+  ts: z.number().int().nonnegative(),
+  provider: z.string(),
+  model: z.string(),
+  ok: z.boolean(),
+  ttftMs: z.number().nullable().optional(),
+  latencyMs: z.number().nullable().optional(),
+  code: z.string().nullable().optional(),
+  inputTokens: z.number().optional(),
+  outputTokens: z.number().optional(),
+  cacheReadTokens: z.number().optional(),
+  cacheWriteTokens: z.number().optional(),
+  reasoningTokens: z.number().optional(),
+});
+
+/** 单渠道的事件桶记录：key = provider（与旧 state.records 的键一致，迁移零转换）。 */
+const bucketRecord = z.object({
+  events: z.array(eventRecord),
+});
+
+/** 测速结果桶：key = 组 id（与旧 state.speedResults 的键一致）。 */
+const speedRecord = z.object({
+  rows: z.array(z.object({
+    provider: z.string(),
+    model: z.string(),
+    ok: z.boolean(),
+    ttft: z.number().nullable(),
+    latency: z.number().nullable(),
+    at: z.number(),
+    failure: z.string().nullable().optional(),
+  })),
+});
+
+const healthDomainSpec = defineDomain({
+  name: 'model_channel_health',
+  version: 1,
+  layout: 'per-record',
+  invalidRecords: 'backup-and-skip',
+  tables: {
+    events: domainTable(bucketRecord),
+    speed: domainTable(speedRecord),
+  },
+});
+
+/**
+ * HealthStore：封装 domain 读写 + 保留策略 + 聚合。
+ * 非 Service（宿主插件自有生命周期），由 apply() 创建并 effect 持有 close。
+ */
+export class HealthStore {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.ready = null; // Promise<Domain>
+    this.events = null; // KvTable
+    this.speed = null; // KvTable
+    this.eventChain = Promise.resolve(); // 类内写链：appendEvent 串行化（并发不丢更新）
+  }
+
+  /** 打开 domain（幂等）。dsh-base 未装 storage 栈的 profile 会 reject——调用方降级。 */
+  open() {
+    if (this.ready === null) {
+      this.ready = this.ctx.storageDomain.open(healthDomainSpec).then((domain) => {
+        this.events = domain.table('events');
+        this.speed = domain.table('speed');
+        return domain;
+      });
+    }
+    return this.ready;
+  }
+
+  /** effect 用：domain 关闭（写入队列排干后释放）。 */
+  async close() {
+    if (this.ready === null) return;
+    const domain = await this.ready.catch(() => null);
+    this.ready = null;
+    this.events = null;
+    this.speed = null;
+    if (domain) await domain.close().catch(() => {});
+  }
+
+  /** 追加一条事件到渠道桶，同时执行窗口过期 + 条数截断。
+   * 并发安全：桶初始化（put）与追加（update）都排队到类内写链，逐个重读当前值，
+   * 并发 appendEvent 不交错、不互相覆盖（等价 KvTable.update 的原子语义；
+   * 桶不存在时 KvTable.update 报 missing-key，故初始化先行）。
+   */
+  appendEvent(provider, rec) {
+    if (this.events === null) return Promise.resolve();
+    this.eventChain = this.eventChain.then(async () => {
+      const cutoff = Date.now() - WINDOW_MS;
+      const cur = this.events.get(provider);
+      if (cur === undefined) {
+        await this.events.put(provider, { events: [rec] });
+        return;
+      }
+      await this.events.update(provider, (c) => ({
+        events: [...c.events.filter((e) => e.ts >= cutoff), rec].slice(-PER_KEY_LIMIT),
+      }));
+    }).catch(() => { }); // 链不断：失败吞掉（调用方已有 warn），后续追加继续
+    return this.eventChain;
+  }
+
+  /** 整组测速结果替换写入。 */
+  async putSpeedRows(groupId, rows) {
+    if (this.speed === null) return;
+    await this.speed.put(groupId, { rows });
+  }
+
+  /** 读全部事件桶（迁移/聚合用）。 */
+  allEventBuckets() {
+    const out = {};
+    if (this.events === null) return out;
+    for (const [provider, bucket] of this.events.entries()) out[provider] = bucket.events;
+    return out;
+  }
+
+  /** 读全部测速桶。 */
+  allSpeedBuckets() {
+    const out = {};
+    if (this.speed === null) return out;
+    for (const [groupId, bucket] of this.speed.entries()) out[groupId] = bucket.rows;
+    return out;
+  }
+
+  /**
+   * 存量迁移：settings health 子树的 records/speedResults 一次性搬入 domain。
+   * 迁移以「桶里有数据即跳过」防重放；完成后由调用方写迁移标记。
+   * 并发安全：逐桶判断改走原子链（迁移进行中 recordHealth 并发创建的新桶不会被旧数据覆盖）。
+   */
+  async migrateFrom(records, speedResults) {
+    if (this.events === null) return false;
+    const cutoff = Date.now() - WINDOW_MS;
+    for (const [provider, list] of Object.entries(records || {})) {
+      if (!Array.isArray(list) || list.length === 0) continue;
+      if (this.events.get(provider) !== undefined) continue; // 已有桶：domain 是权威，不回搬
+      const events = list.filter((e) => e && e.ts >= cutoff).slice(-PER_KEY_LIMIT);
+      if (events.length > 0) await this.events.put(provider, { events });
+    }
+    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 });
+    }
+    return true;
+  }
+}

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(),
@@ -286,7 +295,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,53 +306,30 @@ 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');
     // ---------- 引擎：单候选尝试 ----------
     async function* streamAttempt(cfg, cand, options, attemptStart) {
         if (cand.provider.startsWith(ROUTE_PREFIX))
@@ -823,6 +808,89 @@ 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;
@@ -846,18 +914,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 || {});
@@ -940,12 +1009,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) {