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

package/README.md

@@ -38,7 +38,11 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 
 ## 兼容性（DSH 版本）
 
-本包在 **DSH `0.1.1-rc.2`**（`dsh --version`）上开发与实测，宿主侧依赖按该版本**精确钉住**：
+> **当前工作树已移植到 DSH `0.2.0-rc.1`**（peer 按 `0.2.0-rc.1` 声明；settings 寻址从「自建命名空间」改为「本行实例配置」——
+> 原先的 `model-channels` + `model-channel-health` 两个命名空间合并为本行 Config 的
+> `groups` / `providerOrder` / `effortMemory` / `health`）。下面这段 `0.1.1-rc.2` 的记录仅作历史基线参考。
+
+本包原在 **DSH `0.1.1-rc.2`**（`dsh --version`）上开发与实测，宿主侧依赖按该版本**精确钉住**：
 
 | 宿主包 | 声明 | 用途 |
 |---|---|---|
@@ -54,18 +58,43 @@ 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 消费）
 - 单模型测试 = `settings.update({ns:'model-channel-health', patch:{testRequest:{nonce,provider,model,prompt,maxTokens}}})`；host 执行真实 `llm.stream` 后把结果写回 `testResults[nonce]`；client 轮询 describe 直到 ok/error
-- `apiRef` 获取：`ctx.get('connection').api`（static client 必须在 `inject` 里声明 `connection`，apply 时捕获进闭包）
-
-> **宿主边界（重要）**：DSH apiproxy 对 settings RPC 有暴露白名单（`exposedNamespaces()` = LLM provider ns + `WEB_/PRODUCT_SETTINGS_NAMESPACES`，2026-07 起生效）。含该边界的宿主必须放行 `model-channels` / `model-channel-health`（本仓已在 harness `dsh-host-apiproxy` 打 `PLUGIN_SETTINGS_NAMESPACES` 补丁），否则 describe 会过滤掉这两个命名空间、写入报 `settings-not-exposed`——轮询组保存/健康面板/测速/测试全链路静默失效。
+- `apiRef` 获取：**0.2 为 `ctx.remote`**（插件级 `inject` 声明 `remote` / `remote.settings` / `remote.credentials` / `remote.llm`，apply 时经 `ctx.inject(['remote'])` 捕获）；0.1 的 `ctx.get('connection').api` 已不存在。
+- 上述调用形状仍保留 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.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，后续增强。
 
 ## 响应信封（重要）
 
-所有 `connection.api.*` 调用返回 `{result: {ok, value}}` 包裹（`dsh-client-connection` 的 `callUnary` + zod 校验）。
+0.1 的 `connection.api.*` 返回 `{result: {ok, value}}` 包裹（`dsh-client-connection` 的 `callUnary` + zod 校验）。
+**0.2 的原生远程调用直接返回 `RemoteResult`（`{ok, value} | {ok:false, error}`）**，不再有 `result` 外层；
+本插件 client 的门面把它重新包回旧形状，因此下面这层解包逻辑在 0.2 上依然成立：
 - 成功：`resp.result.value.{...}`
 - 失败：`resp.result.ok === false`，错误在 `resp.result.error.message`
 - `settings.describe` 的 value = `{writable, hasDocument, namespaces:[{ns, value, base, user, revision, ...}]}`
@@ -121,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 重试
@@ -167,3 +196,7 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 19. **single slot 换占必须传负 priority**：`conversation.input.model` 是单占位 seat，cell = slot 本身；原生无 priority（= 0），插件同名注册同不传 → **exact-priority 撞格直接抛错**（「already has a registration at priority 0」→ apply 失败 → 整个插件含模型配置页签加载失败，面板全白）。规则：同 cell 多 entry 按 priority **升序、数值最小者渲染**，遮蔽原生传 `priority: -1`。注意 slot-catalog 的「Do NOT pass priority」只适用于**动态包**（guard 自动分配）；静态 bundle 必须自己传。另：mock 验证 slots.register 不会暴露 occupancy 检查（mock 不抛）——验证座位替换必须复刻真实 SlotCore 撞格语义。选择器拆出后，回归测试随代码迁至 `../model-selector-search/tests/slot-priority.test.cjs`。
 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. **整字段落盘 + 内存态被配置快照覆盖**（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.2.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "src/index.js",
   "exports": {
@@ -34,20 +34,23 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-settings": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-connection": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "0.1.1-rc.2",
-    "@deepseek-ai/schemastery": ">=3.18.2",
-    "react": "^18.3.1"
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-settings": "0.2.0-rc.1",
+    "@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",
+    "zod": "^4.4.3"
   },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
     },
     "client": {
-      "inject": ["slots", "connection"],
+      "inject": ["slots"],
       "platform": "web"
     }
   }

package/src/client.js

@@ -12,6 +12,103 @@ window.__ModuleLoader__.load({
     let apiRef = null
     const savedKeys = {}
 
+    // dsh 0.2：客户端远程面由 connection.api 改为 ctx.remote；参数改为位置参数，结果统一为
+    // RemoteResult。本适配层把两者还原成 0.1 的调用形状（对象入参 + {result:{ok,value}}）。
+    // 另：0.2 的 settings 命名空间恒等于「插件行 id」，本插件的两套旧命名空间
+    // （model-channels / model-channel-health）现由其实例配置的字段承载，在此合成回旧视图。
+    const NS_MCM = 'model-channel-manager'
+    const makeLegacyApi = (remote) => {
+      const wrap = (res) => ({ result: res || { ok: false } });
+      const readMcm = async () => {
+        const res = await remote.settings.describe()
+        if (!res || res.ok !== true) return null
+        return ((res.value && res.value.namespaces) || []).find((n) => n && n.ns === NS_MCM) || null
+      }
+      return {
+        settings: {
+          describe: async () => {
+            const res = await remote.settings.describe()
+            if (!res || res.ok !== true) return wrap(res)
+            const namespaces = (res.value && res.value.namespaces) || []
+            const mcm = namespaces.find((n) => n && n.ns === NS_MCM)
+            const value = (mcm && mcm.value) || {}
+            const user = (mcm && mcm.user) || {}
+            return { result: { ok: true, value: { namespaces: [...namespaces,
+              { ns: 'model-channels', value: { groups: value.groups || [], providerOrder: value.providerOrder || [], effortMemory: value.effortMemory || {} }, user: { groups: user.groups, providerOrder: user.providerOrder }, revision: (mcm && mcm.revision) || 0 },
+              { ns: 'model-channel-health', value: value.health || {}, user: (user && user.health) || {}, revision: (mcm && mcm.revision) || 0 },
+            ] } } }
+          },
+          // 旧签名：update({ ns, patch })
+          update: async (args) => {
+            const ns = (args && args.ns) || NS_MCM
+            const patch = (args && args.patch) || {}
+            if (ns === 'model-channels') return wrap(await remote.settings.update(NS_MCM, patch, undefined))
+            const row = await readMcm()
+            const health = (row && row.value && row.value.health) || {}
+            return wrap(await remote.settings.update(NS_MCM, { health: Object.assign({}, health, patch) }, undefined))
+          },
+          // 旧签名：mutate({ ns, ops })——0.2 只对真实行命名空间提供 path-ops；
+          // 本插件自身的健康子树用合并写实现等价语义。
+          mutate: async (args) => {
+            const ns = (args && args.ns) || NS_MCM
+            const ops = (args && args.ops) || []
+            if (ns !== 'model-channels' && ns !== 'model-channel-health' && ns !== NS_MCM) {
+              return wrap(await remote.settings.mutate(ns, ops, undefined))
+            }
+            const row = await readMcm()
+            const health = Object.assign({}, (row && row.value && row.value.health) || {})
+            const top = {
+              groups: (row && row.value && row.value.groups) || [],
+              providerOrder: (row && row.value && row.value.providerOrder) || [],
+            }
+            for (const op of ops) {
+              const path = (op && op.path) || []
+              const root = (ns === 'model-channels') ? (path[0] === 'groups' ? top : (path[0] === 'providerOrder' ? top : health)) : health
+              if (path.length === 0) continue
+              const key = path[0]
+              const rest = path.slice(1)
+              if (rest.length === 0) {
+                if (op.op === 'set') root[key] = op.value
+                else delete root[key]
+              } else if (rest.length === 1) {
+                const child = Object.assign({}, root[key] || {})
+                if (op.op === 'set') child[rest[0]] = op.value
+                else delete child[rest[0]]
+                root[key] = child
+              }
+            }
+            if (ns === 'model-channels') {
+              return wrap(await remote.settings.update(NS_MCM, { groups: top.groups, providerOrder: top.providerOrder }, undefined))
+            }
+            return wrap(await remote.settings.update(NS_MCM, { health }, undefined))
+          },
+        },
+        credentials: {
+          // 旧签名：set({ ref, value })
+          set: async (args) => wrap(await remote.credentials.set((args && args.ref) || '', (args && args.value) || '')),
+          // 旧签名：describe({ refs: [...] }) → value.credentials[ref]
+          describe: async (args) => {
+            const refs = (args && args.refs) || []
+            const res = await remote.credentials.describe(refs)
+            if (!res || res.ok !== true) return wrap(res)
+            return { result: { ok: true, value: { credentials: res.value || {} } } }
+          },
+        },
+        llm: {
+          // 旧签名：discoverModels({ settingsNs, ...request }) → value.models
+          discoverModels: async (args) => {
+            const settingsNs = (args && args.settingsNs) || 'llm-pi-ai'
+            const request = Object.assign({}, args)
+            delete request.settingsNs
+            const res = await remote.llm.discoverModels(settingsNs, request)
+            if (!res || res.ok !== true) return wrap(res)
+            const value = res.value
+            return { result: { ok: true, value: Array.isArray(value) ? { models: value } : value } }
+          },
+        },
+      }
+    }
+
     const CSS = `
 .mcm-root { display:flex; flex-direction:column; height:100%; overflow:hidden; font-size:13px; color:var(--dsw-alias-label-primary); background:var(--dsw-alias-bg-base); }
 .mcm-header { display:flex; align-items:center; justify-content:space-between; padding:12px 24px; border-bottom:1px solid var(--dsw-alias-border-l1); background:var(--dsw-alias-bg-layer-1); flex-shrink:0; }
@@ -968,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()
 
@@ -995,7 +1094,10 @@ window.__ModuleLoader__.load({
               lastOk: null,
               lastCode: null,
               recentErrors: 0,
-              tokSum: 0
+              tokSum: 0,
+              tokIn: 0,
+              tokOut: 0,
+              tokCache: 0
             })
           }
         }
@@ -1006,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) => {
@@ -1115,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 用量'),
@@ -1237,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)))
       }
 
@@ -1253,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(() => {})
         }
@@ -1428,8 +1613,9 @@ window.__ModuleLoader__.load({
 
 
     function apply(ctx) {
-      const connection = ctx.get('connection')
-      apiRef = connection && connection.api ? connection.api : null
+      // dsh 0.2：远程调用面为 ctx.remote（connection.api 已移除）。保留 0.1 的调用形状，
+      // 由下面的适配层把位置参数/RemoteResult 还原成旧的 {result:{ok,value}} 与对象入参。
+      ctx.inject(['remote'], (scope) => { apiRef = makeLegacyApi(scope.remote) })
       ctx.effect(() => {
         const tag = document.createElement('style')
         tag.dataset.mcmStyle = ''
@@ -1448,6 +1634,6 @@ window.__ModuleLoader__.load({
       ))
     }
 
-    return { name: 'model-channel-manager', inject: ['slots', 'connection'], apply }
+    return { name: 'model-channel-manager', inject: ['slots', 'remote', 'remote.settings', 'remote.credentials', 'remote.llm'], apply }
   },
 })

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,20 +1,19 @@
 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';
 const NS_HEALTH = 'model-channel-health';
-const CONFIG_SCHEMA = z.object({
-    groups: z.array(z.object({
-        id: z.string(),
-    }).loose(true)).default([]),
-    // 面板供应商顺序的持久化载体：settings-file 的 patchNode 对 map 键序是盲的
-    // （纯重排 = 零 diff），但数组是 deepEqual 不等即整值 setIn（原位、保序）。
-    // 顺序存成数组数据而不是对象键序元数据，重启后从文件真实还原。引擎不消费它。
-    providerOrder: z.array(z.string()).default([]),
-}).loose(true);
+// dsh 0.2：settings 不再是可动态注册的命名空间总线，而是「插件行实例配置」的表单投影。
+// 因此原先的 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({}),
@@ -24,8 +23,39 @@ 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(),
+    providerOrder: z.array(z.string()).default([]).volatile(),
+    effortMemory: z.dict(z.string()).default({}).volatile(),
+    health: HEALTH_SCHEMA.volatile(),
 }).loose(true);
-export function apply(ctx) {
+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';
+    const refOf = (key, fallback) => {
+        const field = config && config[key];
+        if (field && typeof field.get === 'function') {
+            try {
+                return field.get();
+            }
+            catch (_e) {
+                return fallback;
+            }
+        }
+        return fallback;
+    };
+    const healthOf = () => refOf('health', null) || {};
+    const cfgOf = () => ({
+        groups: refOf('groups', []) || [],
+        providerOrder: refOf('providerOrder', []) || [],
+        effortMemory: refOf('effortMemory', {}) || {},
+    });
+
     const isContentChunk = (c) => {
         if (!c) return false;
         if (c.type === 'text-delta' || c.type === 'reasoning-delta') return c.text !== '';
@@ -265,7 +295,6 @@ export function apply(ctx) {
     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 处理（向后兼容）。
@@ -277,46 +306,30 @@ export function apply(ctx) {
             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);
-        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.settings.update(NS_HEALTH, { speedResults: clone(r), runtime: await persistRuntime() });
-    };
-    // ---------- 健康持久化节流：合并 2s 窗口内的写入，避免每个请求全量重写 settings ----------
-    let healthFlushHandle = null;
-    let healthDirty = false;
-    const flushHealthNow = async () => {
-        if (bus === null) return;
-        await bus.settings.update(NS_HEALTH, { records: clone(pullRecords()), speedResults: clone(pullSpeedResults()), runtime: await persistRuntime() });
+        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))
@@ -585,11 +598,15 @@ export function apply(ctx) {
                                 await ctx.timeout(1500);
                         }
                     }
-                    return { provider: cand.provider, model: cand.model, ok: false, ttft: null, latency: null, failure: (lastErr && lastErr.message) || 'speedtest failed' };
+                    return { provider: cand.provider, model: cand.model, ok: false, ttft: null, latency: null, failure: (lastErr && lastErr.message) || 'speedtest failed', code: (lastErr && lastErr.code) || null };
                 }));
                 results.push(...measured);
             }
             const rows = results.map((r) => ({ provider: r.provider, model: r.model, ok: r.ok, ttft: r.ttft, latency: r.latency, at: Date.now(), failure: r.failure || null }));
+            // 整组候选都因「环境未就绪」（凭据服务尚未加载等）失败时，不落盘 speedResults、不冷却候选，
+            // 交给调用方延后重试——否则启动瞬间的一次重放会把所有渠道误判成故障并冷却。
+            if (rows.length > 0 && rows.every((r, i) => !r.ok && notReady({ code: results[i] && results[i].code, message: r.failure })))
+                return { ok: false, deferred: true };
             state.speedResults[cfg.id] = rows;
             await persistSpeedResults(state.speedResults);
             const now = Date.now();
@@ -675,6 +692,7 @@ export function apply(ctx) {
         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)
@@ -697,6 +715,8 @@ export function apply(ctx) {
                 if (ttft === null && isContentChunk(chunk)) {
                     ttft = Date.now() - start;
                 }
+                if (chunk && chunk.type === 'usage' && chunk.usage && typeof chunk.usage === 'object')
+                    lastUsage = chunk.usage;
                 if (chunk && chunk.type === 'text-delta' && typeof chunk.text === 'string') {
                     text += chunk.text;
                 }
@@ -705,8 +725,12 @@ export function apply(ctx) {
                 }
                 if (isTerminalChunk(chunk)) {
                     const reason = chunk.reason || {};
-                    if (isSuccessReason(reason))
+                    if (isSuccessReason(reason)) {
+                        // 命中 finish 就 return，内层流不会被全局拦截器完整排干，成功这一笔要自己补记
+                        // （失败那笔由拦截器的 catch 分支记，所以此前只有失败会进健康流水）
+                        recordHealth(provider, { provider, model }, { ok: true, ttftMs: ttft, latencyMs: Date.now() - start, code: null, usage: lastUsage });
                         return { ok: true, ttftMs: ttft, latencyMs: Date.now() - start, text: text.slice(0, 2000), reasoning: reasoning.slice(0, 2000) };
+                    }
                     throw { code: (reason.failure && reason.failure.code) || 'STREAM_ERROR', message: (reason.failure && reason.failure.message) || 'model test failed' };
                 }
             }
@@ -716,61 +740,56 @@ export function apply(ctx) {
             throw err;
         }
     }
-    function handleTestRequest(settings, next) {
+    function handleTestRequest(next) {
         const req = next.testRequest;
-        const last = next.lastTestHandledNonce || 0;
+        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)
             return;
-        settings.update(NS_HEALTH, { lastTestHandledNonce: req.nonce }).catch((e) => console.error('[model-channel-manager] lastTestHandledNonce 写入失败:', e));
-        // 结果写入：首选 mutate path-ops 原子设置单 nonce（并发测试互不覆盖）。
-        // 实测踩坑（#21 同源）：部分运行时（rc.2 file provider）会静默拒绝 mutate——
-        // promise 正常 resolve 但条目未落盘。故写后回读校验，未落上则回退 update
-        // 合并写（现势整段 + 本条目），保证结果必然可被 client 轮询读到。
-        let mutateWorks = null;
+        claimedTestNonce = req.nonce;
+        // 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));
+            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 cur = (bus && bus.healthScope ? bus.healthScope.get().testResults : null) || {};
-            if (mutateWorks !== false) {
-                try {
-                    await settings.mutate(NS_HEALTH, [{ op: 'set', path: ['testResults', key], value }]);
-                    const landed = ((bus && bus.healthScope ? bus.healthScope.get().testResults : null) || {})[key];
-                    if (landed) { mutateWorks = true; return; }
-                    mutateWorks = false;
-                    console.error('[model-channel-manager] testResults mutate 未生效，回退 update 合并写');
-                } catch (e) {
-                    mutateWorks = false;
-                    console.error('[model-channel-manager] testResults mutate 失败，回退 update 合并写:', e);
-                }
-            }
-            await settings.update(NS_HEALTH, { testResults: Object.assign({}, cur, { [key]: value }) }).catch((e) => console.error('[model-channel-manager] testResults update 兜底写入失败:', e));
+            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));
         };
         // 修剪低频执行：只在条目数超限时砍到 50（不在每次写入时整包重写）
         const maybePrune = () => {
-            const all = (bus && bus.healthScope ? bus.healthScope.get().testResults : null) || {};
+            const all = healthOf().testResults || {};
             const entries = Object.entries(all);
             if (entries.length <= 50) return;
-            const drop = entries.sort((a, b) => ((b[1] && b[1].finishedAt) || 0) - ((a[1] && a[1].finishedAt) || 0)).slice(50).map(([k]) => ({ op: 'unset', path: ['testResults', String(k)] }));
-            if (drop.length === 0) return;
-            if (mutateWorks === false) {
-                const kept = {};
-                for (const [k, v] of entries.slice(0, 50)) kept[k] = v;
-                settings.update(NS_HEALTH, { testResults: kept }).catch((e) => console.error('[model-channel-manager] testResults 修剪 update 失败:', e));
-                return;
-            }
-            settings.mutate(NS_HEALTH, drop).catch((e) => console.error('[model-channel-manager] testResults 修剪失败:', e));
+            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 done = async (r) => {
             try {
-                await setResult(Object.assign({}, r, { finishedAt: Date.now() }));
+                await settle(Object.assign({}, r, { finishedAt: Date.now() }));
                 maybePrune();
             }
             catch (_e) { }
         };
         void setResult({ status: 'running', startedAt: Date.now() });
         runModelTest(req.provider, req.model, req.prompt, req.maxTokens).then(async (r) => {
+            replayAttempts.delete('test');
             await done(Object.assign({ status: 'ok' }, r));
         }).catch(async (e) => {
+            if (notReady(e)) {
+                // 凭据服务尚未就绪（典型是启动瞬间的重放）：不写成假 error，释放认领并延后重试
+                claimedTestNonce = 0;
+                scheduleReplay('test', () => reloadFromConfig(false));
+                return;
+            }
             await done({ status: 'error', code: (e && e.code) || 'STREAM_ERROR', error: (e && e.message) || String(e) });
         });
     }
@@ -789,47 +808,255 @@ export function apply(ctx) {
         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;
+    // 启动早于凭据服务就绪：此时重放测试/测速会以 MISSING_CREDENTIAL 失败。
+    // 这类错误是「环境还没准备好」而不是「渠道故障」，必须释放认领、延后重试，不能写成假 error。
+    const notReady = (e) => {
+        const code = (e && e.code) || '';
+        const msg = String((e && (e.message || e.error)) || '');
+        return code === 'MISSING_CREDENTIAL' || code === 'INVALID_CREDENTIAL' || /no credential|credential .*not set|is not set — store/i.test(msg);
+    };
+    const replayAttempts = new Map();
+    const scheduleReplay = (key, fn, ms = 5000) => {
+        const n = (replayAttempts.get(key) || 0) + 1;
+        if (n > 24)
+            return;
+        replayAttempts.set(key, n);
+        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 = 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 || {});
+            runtimeRestored = true;
+        }
+        const live = pullConfig().groups;
+        for (const g of live)
+            groupRuntime(g.id);
+        // 清理已删除组的运行时残留，避免 runtime 持久化无限累积
+        for (const id of Array.from(runtime.keys()))
+            if (!live.some((g) => g.id === id))
+                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;
+            const cfgRow = pullConfig().groups.find((g) => g.id === req.group);
+            // nonce 落盘推迟到本次测速得出结论之后（同 handleTestRequest 的理由）：
+            // 提前写会把「没就绪」的重试用自己的持久值挡掉。
+            const settleSpeed = () => {
+                if (bus !== null)
+                    bus.writeHealth({ lastHandledNonce: req.nonce }).catch(() => { });
+            };
+            if (cfgRow)
+                runSpeedTest(cfgRow).then((r) => {
+                    if (r && r.deferred) {
+                        claimedSpeedNonce = 0;
+                        scheduleReplay('speed', () => reloadFromConfig(false));
+                        return;
+                    }
+                    replayAttempts.delete('speed');
+                    settleSpeed();
+                }).catch((e) => {
+                    if (notReady(e)) {
+                        claimedSpeedNonce = 0;
+                        scheduleReplay('speed', () => reloadFromConfig(false));
+                        return;
+                    }
+                    settleSpeed();
+                    console.error('[model-channel-manager] speedtest error:', e);
+                });
+            else
+                settleSpeed();
+        }
+        handleTestRequest(health);
+    }
     ctx.inject(['settings'], (sctx) => {
         const settings = sctx.settings;
-        bus = { settings };
-        const cfgScope = settings.register(NS_CONFIG, CONFIG_SCHEMA, { base: {} });
-        const healthScope = settings.register(NS_HEALTH, HEALTH_SCHEMA, { base: {} });
-        bus.cfgScope = cfgScope;
-        bus.healthScope = healthScope;
-        state.config = clone(cfgScope.get() || { groups: [] });
-        state.records = clone(healthScope.get().records || {});
-        state.speedResults = clone(healthScope.get().speedResults || {});
-        state.testResults = clone(healthScope.get().testResults || {});
-        restoreRuntime(healthScope.get().runtime || {});
-        cfgScope.watch(() => {
-            state.config = clone(cfgScope.get() || { groups: [] });
-            const live = pullConfig().groups;
-            for (const g of live)
-                groupRuntime(g.id);
-            // 清理已删除组的运行时残留，避免 runtime 持久化无限累积
-            for (const id of Array.from(runtime.keys()))
-                if (!live.some((g) => g.id === id))
-                    runtime.delete(id);
-            rewireRoutes();
+        // 0.2 只暴露「按行 id 定位的实例配置」；健康字段是同一 Config 里的 health 子树，
+        // 写入为整字段合并写（旧的 path-ops mutate 在 0.2 不存在）。
+        // 0.2 的配置写入走 configEditor.edit() → hmr.runExclusive()，而 runExclusive 一旦发现已在
+        // 事务内就直接拒绝（"HMR transactions cannot be nested"）。loader/volatile-update 回调本身
+        // 就运行在该事务里，所以回写必须先切出事务上下文：事务内创建的异步资源（AsyncResource、
+        // setTimeout）都会继承事务上下文，只有 AsyncLocalStorage.exit() 能干净地切出去，
+        // 写入再由 runExclusive 排进队列、在本次事务结束后执行。
+        const outsideTransaction = (fn) => {
+            const hmr = ctx.get('hmr');
+            const als = hmr && hmr.executing;
+            if (als && typeof als.exit === 'function' && als.getStore()) return als.exit(fn);
+            return fn();
+        };
+        // 0.2 是「整字段落盘」，并发调用会各自基于同一份旧快照做 read-modify-write，
+        // 后写的直接覆盖先写的（实测 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 queued = healthWrites.then(run, run);
+            healthWrites = queued.catch(() => { });
+            return queued;
+        };
+        bus = {
+            settings,
+            writeHealth,
+            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');
+        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)');
         });
-        healthScope.watch((next) => {
-            state.records = clone(next.records || {});
-            state.speedResults = clone(next.speedResults || {});
-            state.testResults = clone(next.testResults || {});
-            const req = next.speedRequest;
-            const last = next.lastHandledNonce || 0;
-            if (req && typeof req.group === 'string' && typeof req.nonce === 'number' && req.nonce !== last) {
-                settings.update(NS_HEALTH, { lastHandledNonce: req.nonce }).catch(() => { });
-                const cfg = pullConfig().groups.find((g) => g.id === req.group);
-                if (cfg)
-                    runSpeedTest(cfg).catch((e) => console.error('[model-channel-manager] speedtest error:', e));
-            }
-            handleTestRequest(settings, next);
-        });
-        boot();
+        // boot 已在 domain ready 链尾（或降级分支）调用，此处不再调
     });
     // ---------- 全局 LLM 请求健康拦截 (涵盖所有非虚拟路由的真实渠道模型调用) ----------
     ctx.on('llm/stream', async function* (options, next) {
@@ -913,14 +1140,13 @@ export function apply(ctx) {
         }
         console.log('[model-channel-manager] booted, groups:', pullConfig().groups.map((g) => g.id).join(', ') || '(none)');
     }
-    // 工作区 .channel-manager/config.json -> settings 命名空间（一次性）。
+    // 工作区 .channel-manager/config.json -> 本行实例配置（一次性）。
     // 完成后写 legacyMigrated 哨兵，防止「用户清空全部组 → 重启 → 旧配置复活」；
     // fs/sandboxPolicy 未就绪时短暂重试，而不是静默放弃直到下次重启。
     async function migrateLegacyConfig() {
-        const settings = bus && bus.settings;
-        if (settings === undefined || pullConfig().groups.length !== 0)
+        if (bus === null || pullConfig().groups.length !== 0)
             return;
-        if ((bus && bus.healthScope ? bus.healthScope.get().legacyMigrated : false) === true)
+        if (healthOf().legacyMigrated === true)
             return;
         for (let attempt = 0; attempt < 6; attempt++) {
             const fsSvc = ctx.get('fs');
@@ -933,13 +1159,13 @@ export function apply(ctx) {
                     const legacy = JSON.parse(text);
                     const migrated = normalizeConfig(legacy);
                     if (migrated.groups.length > 0) {
-                        await settings.replace(NS_CONFIG, { groups: migrated.groups });
+                        await bus.settings.update(SELF_NS, { groups: migrated.groups });
                         state.config = { groups: migrated.groups };
                         console.log('[model-channel-manager] migrated legacy config from workspace .channel-manager/config.json');
                     }
                 }
                 catch (_e) { /* 无遗留配置，忽略 */ }
-                settings.update(NS_HEALTH, { legacyMigrated: true }).catch(() => { });
+                bus.writeHealth({ legacyMigrated: true }).catch(() => { });
                 return;
             }
             try {