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

package/README.md

@@ -31,6 +31,13 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 - `dsh.profile.bundles` 加 `"@arcaneorion/dsh-model-channel-manager"`
 - `pnpm install` 后重启 `dsh --profile web`
 
+> **link: 方式的模块解析坑（0.3.8 实测）**：pnpm 对 link: 包不安装其依赖；且 Node ESM
+> import 会把 symlink **realpath 化**——host 从 profile 路径加载插件时，`import 'zod'`
+> 实际从**工作区真实路径**向上解析，工作区没有 node_modules 就报
+> `Cannot find package 'zod'`。解法：工作区 `node_modules/` 里软链宿主侧已有实体
+> （`zod` ← profile 顶层；`@deepseek-ai/dsh-storage-domain` ← pnpm `.pnpm` 实体；
+> `.gitignore` 已含 `node_modules/`）。npm 安装方式（dependencies 正常解析）无此问题。
+
 验证：
 - host 日志出现 `[model-channel-manager] booted, groups: ...`
 - `llm.providers` 出现 `roundrobin/<组id>`
@@ -134,11 +141,21 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 
 供应商卡片头部「改名」按钮可重命名 Provider ID（约束：小写字母开头，仅小写字母/数字/连字符）：
 
-- 轮询组候选池中引用该 ID 的 candidate 会自动同步为新 ID
+- 轮询组候选池中引用该 ID 的 candidate 会自动同步为新 ID——**主 candidates 与全部 presets 都同步**（0.3.6 修复审计 F17/C05：宿主优先使用 `activePreset.candidates`，漏改它 = 删旧 provider 后组悬空）
 - `apiKeyEnv` 凭据引用**保持不变**——凭据是 write-only 无法搬移，保持引用名原地不动即可让已存储 Key 继续生效
 - 历史健康流水保留在原 ID 名下（历史存档不受影响）
 - 改名后仍需点击右上「保存全部变更」落盘
 
+## 组配置保存校验（0.3.6，审计 F16/H08）
+
+保存前 client 预检，以下问题**直接拒绝提交**并列出：
+
+- 组 ID 非法（仅小写字母/数字/连字符，字母或数字开头）
+- 组 ID 重复
+- 组无可用候选（候选需同时选 Provider 和模型）
+
+host 侧兜底：`rewireRoutes` 发现配置组数 > 实际路由数时 `console.warn` 列出被丢弃的组 ID（此前是静默丢弃——H08：3 组保存、路由只有 1 条，界面仍显示「已保存」）。允许清空全部组（空列表合法）。
+
 ## 密钥写入（凭据引用虚拟化）
 
 - 面板主视图只出现「API Key」输入框：**粘贴或输入后失焦即自动写入** DSH 凭据存储（`~/.dsh/.credentials.yaml`，0600，write-only 读不回），无手动按钮；清空输入框不会删除已存 key。上游 llm-pi-ai 的供应商 profile 只有 `apiKeyEnv` 一个密钥字段（凭据引用名），不存在内联 key 的选项——secrets 不进 settings.yaml、不随 `settings.describe` 下发，是有意的安全设计。
@@ -151,7 +168,8 @@ dsh plugin --profile web add @arcaneorion/dsh-model-channel-manager
 
 - settings 接入用 **`ctx.inject(['settings'], (sctx) => {...})`**（settings 服务异步初始化，apply 时 `ctx.get('settings')` 为 undefined——曾经整个引擎静默失效，命名空间从未注册）
 - 配置 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)`）；测速失败进冷却；请求隔离按组
+- 引擎：sticky/round-robin/primary 三策略；**round-robin 选择时原子预留**（0.3.5：指针选定即推进，并发请求均分；旧实现成功后才推进，并发全打同一候选——审计 F13/H13）；首响应超时 + 流中空闲超时（动态 = max(timeoutMs, min(120s, ttft×2))）；单候选原地重试（指数退避）耗尽才换；全炸清冷却重试一轮；组级总预算 `totalBudgetMs`（默认 10 分钟，0.3.3）；测速 ttft/latency/hybrid/smart 四键（smart = 0.5×ttft_norm + 0.3×(1−reliability) + 0.2×latency_norm，reliability 贝叶斯平滑 `(success+2.5)/(total+5)`）；测速失败进冷却；请求隔离按组
+- 自动测速（0.3.5，审计 F14/H07）：`speedTest.enabled` 且组无测速结果时，**首次真实使用触发一次后台测速**（不阻塞请求）；此前只有 boot 时的 `onFirstUse` 分支，常规路径无入口——开启开关后从未生效
 - 虚拟模型元数据：`reasoning.efforts` 七档（off…max）、**defaultEffort=max**——原生 `/model` 弹窗对新模型的自动填档与展示跟随该声明；会话内显式档位的跨会话恢复由 selector 插件的档位记忆层负责（`modelDirectories` 拦截，存 `model-channels.effortMemory`）
 - 迁移：startup 时从工作区 `.channel-manager/config.json` 一次性迁入 `model-channels`（无遗留则忽略）；完成后写 `legacyMigrated` 哨兵防止「清空组后重启复活」；fs 未就绪时 5s×6 重试
 - 遗留 `.channel-manager/` 目录不再使用
@@ -165,6 +183,11 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 
 ## 已知限制
 
+- **虚拟模型能力声明与候选实际能力无联动（审计 F08，0.3.4 已做最小切片）**：请求含图
+  或带 effort 时，宿主 `resolveModelInfo` 明确声明不支持的候选会被过滤（60s TTL 缓存；
+  `inputModalities` 缺失=未知不过滤，保持 failover；全滤退回原列表报真实错误）——
+  防住 H14（图片静默替换后假成功）与 H06（effort 强塞被拒）。**仍未做**：虚拟模型声明
+  元数据（vision/efforts/窗口）与候选能力的联动聚合，属后续专项
 - 动态超时实现了首响应 + 流中空闲；全炸后「清冷却重试一轮」回溯，未实现「等待最早冷却」的睡眠分支
 - 测速结果不入健康流水（pi 记）；smart 键只统计真实请求
 - **Token 字段只在新记录上出现**：host 升级重启前的存量健康记录无 token 字段，7 天视图对重启前的调用会低估 token（请求数/可用率不受影响）；数据自重启后开始累积
@@ -172,6 +195,26 @@ react 经 `require('react')`；样式用 `ctx.effect` 自管理；`dsh.client: {
 - 轮询渠道/健康统计面板需要 host 新代码（重启后生效）；健康流水的数据在**实际请求过轮询组**后才出现
 - `reasoningEfforts` 缺失（undefined）的 model 正确渲染（`|| {}` 兜底）
 - 会话模型选择器搜索版已拆出为独立插件 `@arcaneorion/dsh-model-selector-search`（原生座位遮蔽、搜索、向上展开菜单、effort 档位未实现等边界见该仓 README）；本插件不再注册任何座位
+- `makeLegacyApi` 0.1 兼容门面仍保留（94 行、11 调用点）：拆除要动 6 个功能路径的双层
+  信封，待 0.3.2 真实环境验证后再决定
+- 30m/24h 健康视图是近似口径（按最近活跃过滤，数值为 7 天累计，UI 已标注）；精确分窗口
+  需 host 出多份 digest
+
+## 引擎超时与生命周期（0.3.3 重构：审计 F01/F02/F15 已修）
+
+- **per-attempt AbortController**：每次候选尝试独立 signal，用户取消转发（`relayAbort`，
+  finally 移除防泄漏）+ 超时 abort（`attemptController.abort(raceErr)`）。pi-ai 适配器把
+  `options.signal` 经 `AbortSignal.any` 融进 watchdog 并传给上游 HTTP——abort 即真正
+  取消网络请求，不再有「return() 排在挂起的 next() 之后拖住 failover」（H02 复现的根因）
+- **统一 finally 有界关闭**：streamAttempt / measureCandidate / runModelTest 三处流消费
+  路径，成功 return / 失败 / 消费者提前退出都走 `closeInner`（closed 防重入 + 3s 关闭
+  预算 race，预算超时补一发 abort）
+- **组级总预算 `totalBudgetMs`**（默认 10 分钟，组配置可调）：超预算不开新尝试，以
+  `CHANNEL_BUDGET_EXCEEDED` 终结——旧实现最坏 `2×N×(R+1)` 次尝试（默认 R=2 → 6N）
+- **测速/测试改总时限**（F15）：旧实现每 chunk 重置 guard（H12：timeoutMs=40 流每
+  20ms 输出，84ms 后仍成功），现在 `deadline` 固定总时限，超时 abort
+- 回归：`tests/timeout-abort.test.cjs`（契约断言 + 挂起流行为级验证——3s 关闭预算内
+  完成，不等满 5s 挂起）
 
 ## 踩坑速记（本项目，按严重程度）
 

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@arcaneorion/dsh-model-channel-manager",
-  "version": "0.3.1",
+  "version": "0.3.8",
   "type": "module",
   "main": "src/index.js",
+  "scripts": {
+    "test": "node --test \"tests/*.test.cjs\""
+  },
   "exports": {
     ".": "./src/index.js",
     "./client": "./src/client.js",
@@ -33,6 +36,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "devDependencies": {
+    "yaml": "^2.9.0"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
     "@deepseek-ai/dsh-llm": "0.2.0-rc.1",

package/src/client.js

@@ -38,22 +38,25 @@ window.__ModuleLoader__.load({
               { ns: 'model-channel-health', value: value.health || {}, user: (user && user.health) || {}, revision: (mcm && mcm.revision) || 0 },
             ] } } }
           },
-          // 旧签名：update({ ns, patch })
+          // 旧签名：update({ ns, patch, expectedRevision })——0.3.2 起透传 revision
+          // （宿主 settings.update 第三参；冲突抛 settings/conflict，由调用方提示重载）
           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 expected = (args && args.expectedRevision !== undefined) ? args.expectedRevision : undefined
+            if (ns === 'model-channels') return wrap(await remote.settings.update(NS_MCM, patch, expected))
             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))
+            return wrap(await remote.settings.update(NS_MCM, { health: Object.assign({}, health, patch) }, expected))
           },
           // 旧签名：mutate({ ns, ops })——0.2 只对真实行命名空间提供 path-ops；
           // 本插件自身的健康子树用合并写实现等价语义。
           mutate: async (args) => {
             const ns = (args && args.ns) || NS_MCM
             const ops = (args && args.ops) || []
+            const expected = (args && args.expectedRevision !== undefined) ? args.expectedRevision : undefined
             if (ns !== 'model-channels' && ns !== 'model-channel-health' && ns !== NS_MCM) {
-              return wrap(await remote.settings.mutate(ns, ops, undefined))
+              return wrap(await remote.settings.mutate(ns, ops, expected))
             }
             const row = await readMcm()
             const health = Object.assign({}, (row && row.value && row.value.health) || {})
@@ -78,9 +81,9 @@ window.__ModuleLoader__.load({
               }
             }
             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, { groups: top.groups, providerOrder: top.providerOrder }, expected))
             }
-            return wrap(await remote.settings.update(NS_MCM, { health }, undefined))
+            return wrap(await remote.settings.update(NS_MCM, { health }, expected))
           },
         },
         credentials: {
@@ -589,13 +592,18 @@ window.__ModuleLoader__.load({
         if (!apiRef) return
         const key = provider + '::' + model
         setTestStates((s) => Object.assign({}, s, { [key]: { status: 'running' } }))
-        const nonce = Date.now() % 1000000000
+        // F03：Date.now()%1e9 同毫秒可碰撞（碰撞 = 两次测试互相认领/覆盖结果），
+        // 换 UUID；host 侧 testRequest.nonce 消费方是 !== 比较，字符串/数字都行
+        const nonce = (crypto.randomUUID && crypto.randomUUID()) || (String(Date.now()) + '-' + Math.random().toString(36).slice(2, 10))
         const prompt = localStorage.getItem('mcm_test_prompt') || '用一句话介绍你自己'
         const maxTokens = Number(localStorage.getItem('mcm_test_max_tokens')) || 256
         apiRef.settings.update({
           ns: 'model-channel-health',
           patch: { testRequest: { nonce, provider, model, prompt, maxTokens } }
-        }).then(() => {
+        }).then((resp) => {
+          // F19：RPC resolve ≠ 业务成功——检查信封（旧实现把 ok:false 当「已触发」）
+          const r = resp && resp.result ? resp.result : resp
+          if (r && r.ok === false) throw new Error((r.error && (r.error.message || r.error)) || 'test request rejected')
           pollTest(nonce, provider, model)
         }).catch((e) => {
           setTestStates((s) => Object.assign({}, s, { [key]: { status: 'error', error: String((e && e.message) || e) } }))
@@ -704,7 +712,7 @@ window.__ModuleLoader__.load({
             el('span', {
               title: '拖动此手柄调整供应商顺序（保存后生效）',
               draggable: true,
-              onDragStart: (e) => { e.stopPropagation(); setDragIdx(idx); try { e.dataTransfer.effectAllowed = 'move'; e.dataTransfer.setData('text/plain', String(idx)) } catch (_e) {} },
+              onDragStart: (e) => { e.stopPropagation(); setDragIdx(realIdx); try { e.dataTransfer.effectAllowed = 'move'; e.dataTransfer.setData('text/plain', String(realIdx)) } catch (_e) {} },
               onDragEnd: () => { setDragIdx(null); setOverIdx(null) },
               onClick: (e) => e.stopPropagation(),
               style: { cursor: 'grab', color: 'var(--dsw-alias-label-tertiary)', fontSize: 14, padding: '0 6px', userSelect: 'none' }
@@ -931,6 +939,8 @@ window.__ModuleLoader__.load({
       const providers = props._providers || {}
       const [speedState, setSpeedState] = useState({})
       const [expanded, setExpanded] = useState({})
+      // 顶层 notice 的写入通道（ModelConfigView 传入；测速失败要上浮显示）
+      const setNotice = props._setNotice || (() => {})
 
       const addGroup = () => props.setChannelsDraft((d) => {
         const base = d || []
@@ -965,12 +975,19 @@ window.__ModuleLoader__.load({
 
       const speedtest = (gid) => {
         if (!apiRef) return
-        const nonce = Date.now() % 1000000000
+        // F03/F19 同 fireTest：UUID 防碰撞 + 信封检查（ok:false 不再当「已触发」）
+        const nonce = (crypto.randomUUID && crypto.randomUUID()) || (String(Date.now()) + '-' + Math.random().toString(36).slice(2, 10))
         setSpeedState((s) => Object.assign({}, s, { [gid]: 'running' }))
-        apiRef.settings.update({ ns: 'model-channel-health', patch: { speedRequest: { group: gid, nonce } } }).then(() => {
+        apiRef.settings.update({ ns: 'model-channel-health', patch: { speedRequest: { group: gid, nonce } } }).then((resp) => {
+          const r = resp && resp.result ? resp.result : resp
+          if (r && r.ok === false) throw new Error((r.error && (r.error.message || r.error)) || 'speed request rejected')
           setSpeedState((s) => Object.assign({}, s, { [gid]: 'sent' }))
           setTimeout(() => setSpeedState((s) => Object.assign({}, s, { [gid]: null })), 3000)
-        }).catch(() => setSpeedState((s) => Object.assign({}, s, { [gid]: 'err' })))
+        }).catch((e) => {
+          setSpeedState((s) => Object.assign({}, s, { [gid]: 'err' }))
+          setNotice('测速触发失败: ' + String((e && e.message) || e))
+          setTimeout(() => setNotice(null), 5000)
+        })
       }
 
       if (groups.length === 0) return el('div', { className: 'mcm-empty' }, '暂无轮询组，点击下方按钮创建', el('div', { style: { marginTop: 12 } }, btn('＋新增轮询组', addGroup, 'primary')))
@@ -1368,11 +1385,23 @@ window.__ModuleLoader__.load({
       const [notice, setNotice] = useState(null)
       const [saving, setSaving] = useState(false)
       const [tab, setTab] = useState('config')
+      // ready 门（审计 F04）：首次 describe 完成前保存不可用——旧实现
+      // channelsDraft || [] 把「还没读到」当「空」，加载前点保存会把轮询组清空
+      const [ready, setReady] = useState(false)
 
       const renameProviderInChannels = (oldId, newId) => {
+        // F17（审计 C05）：改名要同步全部引用——主 candidates + 每个 preset 的
+        // candidates。宿主优先使用 activePreset.candidates，漏改它 = 删旧 provider
+        // 后组仍访问不存在的 ID。
+        const renameCands = (cands) => (cands || []).map((c) => (c && c.provider === oldId) ? Object.assign({}, c, { provider: newId }) : c)
         setChannelsDraft((d) => (d || []).map((g) => {
-          const cands = (g.candidates || []).map((c) => (c && c.provider === oldId) ? Object.assign({}, c, { provider: newId }) : c)
-          return Object.assign({}, g, { candidates: cands })
+          const next = Object.assign({}, g, { candidates: renameCands(g.candidates) })
+          if (Array.isArray(g.presets)) {
+            next.presets = g.presets.map((p) => (p && Array.isArray(p.candidates))
+              ? Object.assign({}, p, { candidates: renameCands(p.candidates) })
+              : p)
+          }
+          return next
         }))
       }
       const [channels, setChannels] = useState(null)
@@ -1412,7 +1441,9 @@ window.__ModuleLoader__.load({
           const providers = applyProviderOrder((ns && ns.value && ns.value.providers) || {}, savedOrder)
           // user 层 = 仅用户手工声明的路由（用于真正删除与重排序的 mutate 依据）
           const userProviders = (ns && ns.user && ns.user.providers) || {}
-          setState({ providers, userProviders, providerOrder: savedOrder || [] })
+          // revision 记录（审计 F05）：保存时作为 expectedRevision 传给宿主，
+          // 别处（另一个标签页/host 侧）改过配置则宿主拒绝，防止旧快照覆盖
+          setState({ providers, userProviders, providerOrder: savedOrder || [], nsRevisions: { piAi: (ns && ns.revision) || 0, channels: (cn && cn.revision) || 0 } })
           setDraft((prev) => prev || clone(providers))
           const ch = (cn && cn.value && cn.value.groups) || []
           setChannels(ch)
@@ -1424,7 +1455,8 @@ window.__ModuleLoader__.load({
           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)))
+          setReady(true) // describe 成功：保存解禁（F04 的门）
+        }).catch((e) => { setNotice('加载失败: ' + String(e)); setReady(false) })
       }
 
       useEffect(() => {
@@ -1453,6 +1485,36 @@ window.__ModuleLoader__.load({
 
       const save = () => {
         if (!apiRef) return
+        // F04 门：describe 未完成时 draft/channelsDraft 都是 null——旧实现
+        // (channelsDraft || []) 把「还没读到」当「空」，这里直接拦截而不是兜底空数组
+        if (!ready) {
+          setNotice('配置尚未加载完成，请稍候再保存')
+          setTimeout(() => setNotice(null), 4000)
+          return
+        }
+        // F16 预检：非法/重复组 ID、空候选直接拒绝提交（旧实现保存后 host 静默丢弃，
+        // 界面仍显示「已保存」——H08：3 组保存实际只注册 1 条路由）
+        const groupsToSave = channelsDraft || []
+        const problems = []
+        const seenIds = new Set()
+        for (const g of groupsToSave) {
+          const gid = (g && g.id) || ''
+          if (!/^[a-z0-9][a-z0-9-]*$/.test(gid)) {
+            problems.push('组「' + (gid || '(未命名)') + '」ID 非法（仅小写字母/数字/连字符，字母或数字开头）')
+          } else if (seenIds.has(gid)) {
+            problems.push('组 ID「' + gid + '」重复')
+          } else {
+            seenIds.add(gid)
+          }
+          const candCount = (g && Array.isArray(g.candidates)) ? g.candidates.filter((c) => c && c.provider && c.model).length : 0
+          if (candCount === 0 && gid)
+            problems.push('组「' + gid + '」没有可用候选（候选需同时选择 Provider 和模型）')
+        }
+        if (problems.length > 0) {
+          setNotice('保存被拒绝：' + problems[0] + (problems.length > 1 ? '（共 ' + problems.length + ' 个问题）' : ''))
+          setTimeout(() => setNotice(null), 8000)
+          return
+        }
         setSaving(true)
         setNotice(null)
         // Compat 全量透传：rc.2 PiAiCompatProfile 的 20 个字段全部真实生效——此前
@@ -1494,6 +1556,10 @@ window.__ModuleLoader__.load({
               if (Array.isArray(cleaned.input) && cleaned.input.length > 0) cleaned.input = cleaned.input.slice()
               else delete cleaned.input
               if (cleaned.reasoningEfforts != null && typeof cleaned.reasoningEfforts === 'object' && Object.keys(cleaned.reasoningEfforts).length > 0) cleaned.reasoningEfforts = Object.assign({}, cleaned.reasoningEfforts)
+              else if (cleaned.reasoningEfforts === false) {
+                // F07（审计 C02）：false = 显式关闭推理（继承 catalog 默认的对立面）。
+                // 删掉它 = 静默恢复继承，语义被改变。原样保留。
+              }
               else delete cleaned.reasoningEfforts
               const mc = cleanCompat(cleaned.compat)
               if (mc) cleaned.compat = mc
@@ -1501,7 +1567,12 @@ window.__ModuleLoader__.load({
               return cleaned
             })
             const pObj = Object.assign({}, pVal)
-            pObj.api = pVal.api || 'openai-completions'
+            // F07（审计 C08）：api 缺省 = 继承 catalog 协议；强塞 openai-completions
+            // 会把「继承」变成「显式指定」，materialize 时显式 api 优先于 catalog——
+            // 协议被静默切换。UI 下拉仍显示默认值（渲染默认与持久化默认分离），
+            // 但保存不写显式值。新增供应商时 addGroup 路径已显式给 api。
+            if (typeof pVal.api === 'string' && pVal.api) pObj.api = pVal.api
+            else delete pObj.api
             pObj.models = cleanModels
             if (!(pVal.baseURL && String(pVal.baseURL).trim())) delete pObj.baseURL
             else pObj.baseURL = String(pVal.baseURL).trim()
@@ -1561,9 +1632,14 @@ window.__ModuleLoader__.load({
           for (const k of allKeys) ops.push({ op: 'unset', path: ['providers', k] })
           for (const k of keys) ops.push({ op: 'set', path: ['providers', k], value: cleanProviders[k] })
           if (ops.length === 0) return Promise.resolve()
-          return apiRef.settings.mutate({ ns: 'llm-pi-ai', ops }).then((resp) => {
+          // F05：带 revision 保存——llm-pi-ai 是独立 settings 行，冲突由宿主以
+          // settings/conflict 拒绝；提示里给「刷新后重试」指引而不是静默覆盖
+          return apiRef.settings.mutate({ ns: 'llm-pi-ai', ops, expectedRevision: (state && state.nsRevisions && state.nsRevisions.piAi) || undefined }).then((resp) => {
             const r = resp && resp.result ? resp.result : resp
-            if (r && r.ok === false) throw new Error((r.error && (r.error.message || r.error)) || 'llm-pi-ai save failed')
+            if (r && r.ok === false) {
+              const conflict = r.error && (r.error.code === 'settings/conflict' || /conflict/i.test(String(r.error.message || '')))
+              throw new Error(conflict ? 'llm-pi-ai 配置已被其他页面修改（版本冲突），请点「刷新」后重试' : ((r.error && (r.error.message || r.error)) || 'llm-pi-ai save failed'))
+            }
             return r
           })
         })() : Promise.resolve()
@@ -1572,22 +1648,46 @@ window.__ModuleLoader__.load({
         const orderPatch = draft ? { providerOrder: Object.keys(cleanProviders) } : {}
         const p2 = apiRef.settings.update({
           ns: 'model-channels',
+          expectedRevision: (state && state.nsRevisions && state.nsRevisions.channels) || undefined,
           // 命名单一身份：写入时统一 virtualModel.name = 组 id——旧的独立呈现名
           // （如遗留的 group-1）在下一次保存时自动归一，无需迁移
           patch: Object.assign({ groups: (channelsDraft || []).map((g) => Object.assign({}, g, { virtualModel: Object.assign({}, g.virtualModel, { name: g.id }) })) }, orderPatch)
         }).then((resp) => {
           const r = resp && resp.result ? resp.result : resp
-          if (r && r.ok === false) throw new Error((r.error && (r.error.message || r.error)) || 'model-channels save failed')
+          if (r && r.ok === false) {
+            const conflict = r.error && (r.error.code === 'settings/conflict' || /conflict/i.test(String(r.error.message || '')))
+            throw new Error(conflict ? '轮询组配置已被其他页面修改（版本冲突），请点「刷新」后重试' : ((r.error && (r.error.message || r.error)) || 'model-channels save failed'))
+          }
           return r
         })
-        Promise.all([p1, p2]).then(() => {
-          setNotice('已全部保存（即时生效）')
-          // 同步草稿与状态为刚保存的清洗版本（含默认请求头合并结果）
-          setDraft(clone(cleanProviders))
-          setState((s) => Object.assign({}, s, { providers: cleanProviders, userProviders: cleanProviders, providerOrder: Object.keys(cleanProviders) }))
-          setTimeout(() => setNotice(null), 3000)
+        // F06（审计 C10，0.3.8）：两域用 allSettled 而非 all——半成功不再「整单失败」
+        // 掩盖已提交的那半。各自报告，失败域给出明确指引；部分成功时提示里列明
+        // 哪域成功哪域失败，用户知道实际落盘了什么（宿主无跨命名空间事务，
+        // 这是审计建议的务实路线：可观察的分域成败 + 冲突重试）。
+        const settleOf = (label, p) => p.then(() => ({ label, ok: true }), (e) => ({ label, ok: false, error: String((e && e.message) || e) }))
+        Promise.allSettled([settleOf('提供商配置', p1), settleOf('轮询组配置', p2)]).then((results) => {
+          const done = results.map((r) => r.value)
+          const failed = done.filter((d) => d && !d.ok)
+          const okCount = done.length - failed.length
+          if (failed.length === 0) {
+            setNotice('已全部保存（即时生效）')
+          }
+          else if (okCount > 0) {
+            // 部分成功：明确告知哪域已落盘、哪域失败（旧实现统一「保存失败」，
+            // 用户不知道 providers 其实已经提交了）
+            setNotice('部分保存：' + done.filter((d) => d && d.ok).map((d) => d.label).join('、') + ' 已生效；' + failed.map((d) => d.label).join('、') + ' 失败——' + failed[0].error)
+          }
+          else {
+            setNotice('保存失败: ' + failed[0].error)
+          }
+          // 两域都成功才同步本地镜像（半成功时以 refresh 拉回真实状态为准）
+          if (failed.length === 0) {
+            setDraft(clone(cleanProviders))
+            setState((s) => Object.assign({}, s, { providers: cleanProviders, userProviders: cleanProviders, providerOrder: Object.keys(cleanProviders) }))
+          }
+          setTimeout(() => setNotice(null), failed.length > 0 ? 8000 : 3000)
           refresh()
-        }).catch((e) => setNotice('保存失败: ' + String((e && e.message) || e))).finally(() => setSaving(false))
+        }).finally(() => setSaving(false))
       }
 
       return el('div', { className: 'mcm-root' },
@@ -1600,12 +1700,18 @@ window.__ModuleLoader__.load({
           el('div', { className: 'mcm-actions' },
             notice ? el('span', { style: { fontSize: 12, color: notice.includes('失败') ? 'var(--dsw-alias-state-error-primary)' : 'var(--dsw-alias-state-success-primary)' } }, notice) : null,
             btn('刷新', refresh),
-            btn(saving ? '保存中…' : '保存全部变更', save, 'primary')
+            el('button', {
+              className: 'mcm-btn primary',
+              // F04：未就绪/保存中禁用；disabled 态样式弱化
+              disabled: !ready || saving,
+              style: (!ready || saving) ? { opacity: 0.55, cursor: 'not-allowed' } : undefined,
+              onClick: save
+            }, !ready ? '加载中…' : saving ? '保存中…' : '保存全部变更')
           )
         ),
         el('div', { className: 'mcm-body' },
           tab === 'config' ? el(ModelConfigPanel, { _state: state, _draft: draft, _setDraft: setDraft, _setNotice: setNotice, _renameProviderInChannels: renameProviderInChannels }) :
-          tab === 'roundrobin' ? el(RoundrobinPanel, { channels, channelsDraft, setChannelsDraft, _providers: (draft || (state ? state.providers : {})) }) :
+          tab === 'roundrobin' ? el(RoundrobinPanel, { channels, channelsDraft, setChannelsDraft, _providers: (draft || (state ? state.providers : {})), _setNotice: setNotice }) :
           el(HealthPanel, { health, _providers: (draft || (state ? state.providers : {})) })
         )
       )

package/src/index.js

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