dsh-agentic-router 1.4.2 → 1.6.0

package/README.md

@@ -14,6 +14,18 @@ DeepSeek Harness（DSH）插件：**学习型智能路由（agentic router）+
 向会话日志追加 `request/header` 事件（reason: `router`），走 DSH 官方模型选择优先级链
 （本进程选择 → 会话日志最新 header → 默认模型）真实切换。
 
+**v1.5.0 步骤级路由**：在回合级基线之上，`agent/pre-step` 按**上一步的工具调用**做
+步骤级调整——重型工具（写代码/执行/子 agent 等，见 `HEAVY_TOOLS`）→ 下一步升级 strong
+（pro）；轻量/纯文本 → 回到回合基线档。实现"简单步骤 flash、复杂步骤 pro"的近似形态
+（步骤切换对下一步生效，一阶延迟）。步骤级决策落盘 `steps.jsonl`，`agentic_router_stats`
+可见 `stepSwitches` 与 `stepLog`。
+
+**v1.6.0 跨 provider 与修复**：`resolveTier` 支持跨 provider 解析——优先当前 provider 同档候选，
+无候选时按 providers 顺序取其它 provider 同档模型（mid 档再回退 strong/fast），`request/header`
+同时写入目标 `provider` 与 `model`；每个会话首回合（尚无 header/provider）延迟到首个请求拿到真实
+provider 后再决策应用；`agentic_router_force` 钉死模型、步骤级路由不再覆盖；内置价表补齐
+`deepseek-account`，并在加载时与旧 `policy.json` 价格合并。可用配置 `crossProvider: false` 关闭跨 provider。
+
 ## 架构
 
 ```

package/docs/DESIGN.md

@@ -226,3 +226,46 @@ dsh-agentic-router/
 - 离线回放：拿历史 session 日志重放，对比 shadow 路由与实际路由的评分分布
 - 影子期 A/B：shadow 评分 vs 默认路由评分，达标才切 active
 - 集成冒烟：mock ctx 注入 agent/request payload，验证 LlmCallConfig 替换与 next() 透传
+
+---
+
+## 13. v1.5.0 步骤级路由设计（已实现）
+
+### 13.1 动机
+
+回合级路由（v1.4.x）每回合决策一次、整回合同一模型。用户期望"单任务内简单步骤用 flash、复杂步骤用 pro"。步骤级路由在回合级基线之上做**按步骤升降档**。
+
+### 13.2 时序依据（为什么对下一步生效）
+
+loop 每步顺序：`inbox.claim()`（发 `agent/inbox/claimed`）→ `systemPrompt.assemble()`（快照模型）→ `agent/pre-step` waterfall → `buildRequest`。因此：
+
+- **inbox 决策**在组装之前 → 回合第一步即生效（零延迟，v1.4.x 主路径）
+- **pre-step 决策**在组装之后 → 追加 header 对**下一步**生效（一阶延迟，设计如此）
+
+### 13.3 信号：上一步的工具调用
+
+`session.deriveMessages()` 取最后一条 assistant 消息的 `tool-call` 块（只读叶子字段）：
+
+| 上一步工具 | 下一步档位 |
+|---|---|
+| 重型：bash/pwsh/write/edit/batch_edit/run_code/workflow/subagent/subagent_fork/terminal/pty/mcp | **strong（pro）** |
+| 轻量：read/glob/grep 等 | 回合基线档 |
+| 无工具（纯文本，通常回合收尾） | 保持现状 |
+
+### 13.4 决策与落盘
+
+- 步骤档位 → `resolveTier` → 目标模型 ≠ 当前模型 → 追加 `request/header`（reason: `router-step`）
+- 每步一条 `steps.jsonl`：`{turn, step, lastTools, stepTier, target, current, applied}`
+- stats 暴露 `stepSwitches` 与 `stepLog`（最近 20 条）
+
+### 13.5 边界与后续
+
+- 奖励飞轮仍按回合结算（回合基线的策略选择），步骤级是确定性规则；未来可把步骤级升降档纳入学习（如按工具调用频率学阈值）
+- 重型集合 `HEAVY_TOOLS` 是静态清单，可配置化
+- 降级方向：重型步骤后的轻量步骤会回到基线（简单任务场景：写代码阶段 pro、前后问答 flash）
+
+### 13.6 v1.6.0：跨 provider 解析、首回合延迟与 force 钉死
+
+- `resolveTier` 解析顺序：同 provider 同档 → 其它 provider 同档（`crossProvider`，默认开）→ mid 回退（同 provider strong/fast → 跨 provider strong/fast）；`appendRouterHeader` 同步写 `config.provider` 与 `config.model`
+- 首回合（`currentProvider` 为空）在 inbox 只挂起，等首个 `agent/request` 拿到真实 provider 后解析并落盘，再于 `llm/stream` 延迟应用
+- `agentic_router_force` 期间跳过步骤级升降档（force 钉死模型）；force 支持 `model` 或 `provider/model`

package/dsh/index.js

@@ -22,10 +22,10 @@
 
 import { classify, featuresOf } from './classify.js'
 import {
-  tierOf, tierTarget, resolveTier,
+  tierOf, tierTarget, tierHasAny, resolveTier,
   recommendRule, recommendUcb, recommendLin, recommendKnn,
   rewardOf, applyReward, correctReward,
-  DEFAULT_PRICES, turnCostYuan, resolvePrice,
+  DEFAULT_PRICES, turnCostYuan, resolvePrice, mergePrices,
 } from './strategies.js'
 import { metaPick, DEFAULT_WEIGHTS } from './meta.js'
 import { Store, defaultHome } from './store.js'
@@ -56,10 +56,15 @@ function fallbackTiers() {
 
 // 当前 provider 有候选模型的档位列表（UCB/LinUCB/k-NN 只在这些档位间探索）。
 // provider 缺失或档位表不可用时回退到全部档位（保持专家函数原有行为）。
-function availableTiersFor(provider, modelTiers) {
+function availableTiersFor(provider, modelTiers, crossProvider) {
   const all = ['fast', 'mid', 'strong']
-  if (!modelTiers || !provider) return all
-  const has = all.filter((t) => tierTarget(t, provider, modelTiers))
+  if (!modelTiers) return all
+  if (provider && !crossProvider) {
+    const has = all.filter((t) => tierTarget(t, provider, modelTiers))
+    return has.length ? has : all
+  }
+  // 跨 provider（或无 provider）：只看档位是否有候选（跨所有 provider），避免探索"幽灵档"
+  const has = all.filter((t) => tierHasAny(t, modelTiers))
   return has.length ? has : all
 }
 
@@ -69,6 +74,7 @@ function freshState() {
     seq: 0,
     decisions: [],
     forced: null,
+    crossProvider: true,
     pending: new Map(),
     modelTiers: fallbackTiers(),
     turnDecision: {},
@@ -77,6 +83,8 @@ function freshState() {
     recByTurn: new Map(),
     headerAppends: 0,
     lastActual: null,
+    stepLog: [],
+    counters: { stepSwitches: 0 },
     ucb: { total: 0, arms: {} },
     lin: {
       total: 0,
@@ -188,10 +196,10 @@ function currentProvider(session) {
   return c && typeof c.provider === 'string' ? c.provider : ''
 }
 
-// 核心切换：向会话日志追加 request/header（reason: 'router'），
+// 核心切换：向会话日志追加 request/header（reason: 'router' / 'router-step'），
 // 下一轮 prompt 组装即读到新模型。fast/mid 档去掉 reasoningEffort，
 // 让目标模型走自身默认 effort（避免 flash 不支持 max 而整步失败）。
-function appendRouterHeader(session, targetModel) {
+function appendRouterHeader(session, targetModel, reason = 'router', targetProvider = null) {
   try {
     const last = session.requestHeader()
     const header = {}
@@ -202,15 +210,51 @@ function appendRouterHeader(session, targetModel) {
     const config = {}
     for (const k of Object.keys(prevConfig)) config[k] = prevConfig[k]
     config.model = targetModel
+    if (targetProvider && config.provider !== targetProvider) config.provider = targetProvider
     if (tierOf(targetModel) !== 'strong') delete config.reasoningEffort
     header.config = config
-    session.append('request/header', { header, reason: 'router' })
+    session.append('request/header', { header, reason })
     return true
   } catch (e) {
     return false
   }
 }
 
+// 解析强制模型：支持 'model' 或 'provider/model'（跨厂商强制时需指定 provider）
+function parseForced(forced) {
+  if (typeof forced !== 'string' || !forced) return { provider: null, model: forced || null }
+  const i = forced.indexOf('/')
+  if (i > 0) return { provider: forced.slice(0, i), model: forced.slice(i + 1) }
+  return { provider: null, model: forced }
+}
+
+// 步骤级路由（v1.5.0）：视为"重型工作"的工具调用——上一步出现它们时，
+// 下一步升级到 strong（pro）处理其结果/继续执行；轻量工具保持回合基线。
+const HEAVY_TOOLS = new Set([
+  'bash', 'pwsh', 'write', 'edit', 'batch_edit', 'run_code', 'workflow',
+  'subagent', 'subagent_fork', 'terminal', 'pty', 'mcp',
+])
+
+// 读取会话里最后一条 assistant 消息的工具调用名（只取叶子字段，不碰活数据）。
+function lastToolCalls(session) {
+  try {
+    const msgs = typeof session.deriveMessages === 'function' ? session.deriveMessages() : null
+    if (!Array.isArray(msgs)) return []
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      const m = msgs[i]
+      if (!m || typeof m !== 'object' || m.role !== 'assistant') continue
+      const blocks = m.content
+      if (!Array.isArray(blocks)) return []
+      const out = []
+      for (const b of blocks) {
+        if (b && typeof b === 'object' && b.type === 'tool-call' && typeof b.name === 'string') out.push(b.name)
+      }
+      return out
+    }
+  } catch (e) { /* read-only observation */ }
+  return []
+}
+
 async function refreshModelTiers(llm) {
   if (!llm || typeof llm.listProviders !== 'function') return null
   const providers = await llm.listProviders()
@@ -235,12 +279,15 @@ export function apply(ctx, config = {}) {
   const store = new Store(config.home || defaultHome())
   const settleDelayMs = typeof config.settleDelayMs === 'number' ? config.settleDelayMs : SETTLE_DELAY_MS
   const policy = store.loadPolicy()
-  let prices = (policy.prices && Object.keys(policy.prices).length) ? policy.prices : (config.prices || DEFAULT_PRICES)
+  const overlay = (policy.prices && Object.keys(policy.prices).length) ? policy.prices : (config.prices || {})
+  let prices = mergePrices(DEFAULT_PRICES, overlay)
   const costWeight = typeof config.costWeight === 'number' ? config.costWeight : 20
   const costCap = typeof config.costCap === 'number' ? config.costCap : 0.5
+  const crossProvider = config.crossProvider !== false
 
   const state = freshState()
   state.mode = policy.mode || config.mode || 'shadow'
+  state.crossProvider = crossProvider
   if (typeof policy.forced === 'string') state.forced = policy.forced
 
   // 飞轮恢复：重放 rewards.jsonl 重建 UCB/LinUCB/k-NN/EXP3；
@@ -321,7 +368,7 @@ export function apply(ctx, config = {}) {
     const f = featuresOf(cls, text)
     // 只探索当前 provider 有候选模型的档位（跳过无候选的"幽灵档"，
     // 如 mid 无模型时探索 mid 只会白费并回退到最贵的 strong）
-    const available = availableTiersFor(provider, state.modelTiers)
+    const available = availableTiersFor(provider, state.modelTiers, state.crossProvider)
     const recs = {
       rule: recommendRule(cls),
       ucb: recommendUcb(cls, state.ucb, available),
@@ -336,17 +383,24 @@ export function apply(ctx, config = {}) {
     }
     const meta = metaPick(recs, exp3)
     const chosenRec = meta.byName[meta.chosen] || recs.rule
-    const resolved = state.forced
-      ? { target: state.forced, used: 'forced', note: 'forced' }
-      : resolveTier(chosenRec.tier, provider, state.modelTiers)
+    let resolved = state.forced
+      ? (() => { const pf = parseForced(state.forced); return { target: pf.model, provider: pf.provider, used: 'forced', note: 'forced' } })()
+      : resolveTier(chosenRec.tier, provider, state.modelTiers, { crossProvider: state.crossProvider })
+    // 首回合/无 provider：active 模式下等首个 request 拿到真实 provider 后再解析、应用与落盘
+    const defer = state.mode === 'active' && !provider && !state.forced
+    if (defer) resolved = { target: null, provider: null, used: 'pending', note: 'provider-unknown' }
     const target = resolved.target
+    const targetProvider = resolved.provider || null
     state.seq += 1
     const td = {
       clsType: cls.type, f, recs, meta, chosen: meta.chosen,
       finalized: false, t0: now(), toolErrors: 0, retries: 0,
       currentModel: current, provider, costWeight, costCap,
       estInputTokens: Math.ceil(text.length / 1.5),
-      target, applied: false, needsApply: false, actualModel: current,
+      target, targetProvider, applied: false, needsApply: false, actualModel: current,
+      awaitProvider: defer, recordCommitted: false,
+      // 回合级基线（供步骤级路由 v1.5.0 参考：无重型工具时保持该档）
+      turnTier: target ? tierOf(target) : null, turnTarget: target,
     }
     const record = {
       seq: state.seq,
@@ -367,6 +421,8 @@ export function apply(ctx, config = {}) {
       metaPool: meta.pool,
       resolvedTier: resolved.used + (resolved.note ? ' [' + resolved.note + ']' : ''),
       targetModel: state.mode === 'active' ? target : null,
+      targetProvider: state.mode === 'active' ? targetProvider : null,
+      deferred: defer,
       applied: false,
       appliedAt: source,
       swapped: false,
@@ -378,10 +434,11 @@ export function apply(ctx, config = {}) {
   }
 
   // 决策记录落盘（在 applyDecision 之后调用，保证 applied/swapped 已是最终值）
-  function commitRecord(record) {
+  function commitRecord(record, td) {
     store.appendJsonl('decisions.jsonl', record)
     state.decisions.push(record)
     if (state.decisions.length > 200) state.decisions.shift()
+    if (td) td.recordCommitted = true
   }
 
   // 应用切换：active 模式且目标与当前不同 → 追加 request/header。
@@ -390,7 +447,7 @@ export function apply(ctx, config = {}) {
     if (state.mode !== 'active' || !target) return false
     const base = td.actualModel || td.currentModel
     if (base && target === base) return false
-    const ok = session ? appendRouterHeader(session, target) : false
+    const ok = session ? appendRouterHeader(session, target, 'router', td.targetProvider || null) : false
     td.applied = ok
     if (record) { record.applied = ok; record.swapped = ok }
     if (ok) {
@@ -413,7 +470,7 @@ export function apply(ctx, config = {}) {
       const r = decideAndRecord(payload, text, current, provider, 'inbox')
       if (!r) return
       applyDecision(session, r.key, r.td, r.record, r.target)
-      commitRecord(r.record)
+      if (!r.td.awaitProvider) commitRecord(r.record, r.td)
       log('decision #' + state.seq + ' type=' + r.td.clsType + ' c=' + r.td.f[1] +
         ' meta=' + r.td.chosen + ' tier=' + r.record.resolvedTier +
         ' applied=' + r.td.applied + ' target=' + (r.target || '-'))
@@ -429,6 +486,40 @@ export function apply(ctx, config = {}) {
     } catch (e) {
       log('pre-step capture failed: ' + String(e))
     }
+    // ---- 步骤级路由（v1.5.0）----
+    // pre-step 在组装之后触发 → 此处追加 header 对下一步生效（一阶延迟，设计如此）。
+    // 信号：上一步 assistant 消息的工具调用。重型工具（写代码/执行/子agent）→ 下一步
+    // 升级 strong（pro）；轻量/无工具 → 回到回合基线档。
+    try {
+      const session = sessionOf(payload)
+      if (!session) return next()
+      const key = fullKey(payload)
+      const td = state.turnDecision[key]
+      if (!td || td.finalized) return next()
+      if (state.forced) return next() // 强制模型时跳过步骤级升降档（force 钉死模型）
+      const tools = lastToolCalls(session)
+      if (!tools.length) return next() // 上一步是纯文本（通常回合收尾），保持现状
+      const heavy = tools.some((n) => HEAVY_TOOLS.has(n))
+      const stepTier = heavy ? 'strong' : (td.turnTier || null)
+      if (!stepTier) return next()
+      const provider = td.provider || currentProvider(session) || ''
+      const resolved = resolveTier(stepTier, provider, state.modelTiers, { crossProvider: state.crossProvider })
+      const target = resolved.target
+      const targetProvider = resolved.provider || null
+      const cur = currentModel(session)
+      const changed = target && target !== cur
+      // 注意：pre-step 在组装之后、buildRequest（loop 追加自己的 header）之前触发。
+      // 这里直接追加会被本步 buildRequest 的 change(旧模型) 覆盖（与 v1.4.0 冷启动同款竞态）。
+      // 因此只决策并挂起，真正追加推迟到 llm/stream 收尾（此时 loop 的 header 已落盘）。
+      if (changed) { td.stepTarget = target; td.stepTargetProvider = targetProvider }
+      const stepRec = { turn: key, step: payload.step, lastTools: tools.slice(0, 5), stepTier, target, provider: targetProvider, current: cur, applied: false, pending: changed, ts: Date.now() }
+      if (changed) td.stepRec = stepRec
+      state.stepLog.push(stepRec)
+      if (state.stepLog.length > 30) state.stepLog.shift()
+      try { store.appendJsonl('steps.jsonl', stepRec) } catch (e) { /* 落盘尽力而为 */ }
+    } catch (e) {
+      log('step routing failed: ' + String(e))
+    }
     return next()
   })
 
@@ -442,22 +533,43 @@ export function apply(ctx, config = {}) {
       if (!timer || typeof timer.interval !== 'function') settleFeedback().catch(() => {})
       const key = fullKey(payload)
       const model = typeof cfg.model === 'string' ? cfg.model : null
+      const provider = typeof cfg.provider === 'string' ? cfg.provider : ''
       const td = state.turnDecision[key]
       if (td) {
         if (model) {
           td.actualModel = model
           state.lastActual = { model, turn: payload.turn, step: payload.step, key }
         }
+        if (provider) td.provider = provider
+        if (td.awaitProvider && !td.finalized) {
+          const chosenRec = (td.recs && td.recs[td.chosen]) || td.recs.rule
+          let resolved = state.forced
+            ? (() => { const pf = parseForced(state.forced); return { target: pf.model, provider: pf.provider, used: 'forced', note: 'forced' } })()
+            : resolveTier(chosenRec.tier, provider, state.modelTiers, { crossProvider: state.crossProvider })
+          td.target = resolved.target
+          td.targetProvider = resolved.provider || null
+          td.turnTier = td.target ? tierOf(td.target) : null
+          td.turnTarget = td.target
+          td.awaitProvider = false
+          if (td.rec) {
+            td.rec.resolvedTier = resolved.used + (resolved.note ? ' [' + resolved.note + ']' : '')
+            td.rec.targetModel = state.mode === 'active' ? td.target : null
+            td.rec.targetProvider = state.mode === 'active' ? td.targetProvider : null
+            td.rec.currentModel = model
+          }
+          if (!td.recordCommitted) commitRecord(td.rec, td)
+          td.needsApply = state.mode === 'active' && td.target && td.target !== model
+          log('decision #' + state.seq + ' resolved@request tier=' + td.rec.resolvedTier + ' target=' + (td.target || '-') + ' needsApply=' + td.needsApply)
+        }
         return cfg
       }
       const pkey = agentKey(payload) + ':' + payload.turn
       const text = state.pending.get(pkey) || ''
       state.pending.delete(pkey)
-      const provider = typeof cfg.provider === 'string' ? cfg.provider : ''
       const r = decideAndRecord(payload, text, model, provider, 'request')
       if (r) {
         r.td.needsApply = state.mode === 'active' && r.target && r.target !== r.td.currentModel
-        commitRecord(r.record)
+        if (!r.td.awaitProvider) commitRecord(r.record, r.td)
         if (r.td.needsApply) log('decision #' + state.seq + ' -> apply deferred to llm/stream')
         else log('decision #' + state.seq + ' type=' + r.td.clsType + ' meta=' + r.td.chosen + ' tier=' + r.record.resolvedTier)
       }
@@ -499,14 +611,26 @@ export function apply(ctx, config = {}) {
           const key = sid ? state.openTurns.get(sid) : null
           const td = key ? state.turnDecision[key] : null
           if (td && !td.finalized) {
-            // 兜底应用：request 路径决策未应用时，在 header 落盘后补切换
-            if (td.needsApply && !td.applied) {
-              let session = null
-              try {
-                const sessions = ctx.get('sessions')
-                if (sessions && typeof sessions.get === 'function') session = sessions.get(sid) || null
-              } catch (e) { session = null }
-              if (session) applyDecision(session, key, td, td.rec, td.target)
+            // 延迟应用（此时循环自身 header 已落盘，追加无竞态）：
+            // 1) 步骤级路由挂起的升降档（router-step）
+            // 2) request 路径兜底决策（needsApply）
+            let session = null
+            try {
+              const sessions = ctx.get('sessions')
+              if (sessions && typeof sessions.get === 'function') session = sessions.get(sid) || null
+            } catch (e) { session = null }
+            if (session) {
+              if (td.stepTarget && !state.forced && (td.stepTarget !== currentModel(session) || (td.stepTargetProvider && td.stepTargetProvider !== currentProvider(session)))) {
+                const ok = appendRouterHeader(session, td.stepTarget, 'router-step', td.stepTargetProvider || null)
+                if (ok) {
+                  state.counters.stepSwitches++
+                  if (td.stepRec) { td.stepRec.applied = true }
+                  log('STEP-SWAP -> ' + td.stepTarget + (td.stepTargetProvider ? ' (' + td.stepTargetProvider + ')' : '') + (td.stepRec ? ' [tools: ' + td.stepRec.lastTools.join(',') + ']' : ''))
+                }
+              }
+              td.stepTarget = null
+              td.stepTargetProvider = null
+              if (td.needsApply && !td.applied) applyDecision(session, key, td, td.rec, td.target)
             }
             const u = td.usage || { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, reasoningTokens: 0, estimated: false }
             const model = (options && typeof options.model === 'string' && options.model) || td.currentModel || ''
@@ -559,6 +683,7 @@ export function apply(ctx, config = {}) {
       const td = state.turnDecision[key]
       if (!td || td.finalized) return
       td.finalized = true
+      if (!td.recordCommitted && td.rec) commitRecord(td.rec, td)
       const t1 = now()
       const dtMs = t1 != null && td.t0 != null ? t1 - td.t0 : null
       const r = rewardOf(td, tag, dtMs)
@@ -629,12 +754,15 @@ export function apply(ctx, config = {}) {
       return {
         mode: state.mode,
         forcedModel: state.forced,
+        crossProvider: state.crossProvider,
         totalDecisions: state.seq,
         modelTiers: state.modelTiers,
         prices,
-        mechanism: 'request/header append (agent/inbox/claimed)',
+        mechanism: 'request/header append (inbox turn-level + pre-step step-level v1.5.0)',
         lastActual: state.lastActual,
         headerAppends: state.headerAppends,
+        stepSwitches: state.counters.stepSwitches,
+        stepLog: state.stepLog.slice(-20),
         flywheel: {
           ucb: state.ucb,
           lin: { total: state.lin.total, tierN: state.lin.tierN, tierW: state.lin.tierW },
@@ -645,7 +773,7 @@ export function apply(ctx, config = {}) {
           recentRewards: store.loadJsonl('rewards.jsonl').slice(-20),
         },
         recent: state.decisions.slice(-20),
-        note: '切换真实性验证：headerAppends 为本进程追加的 request/header 次数；lastActual 为最近一步真实出网模型；decisions[].applied=true 且 swapped=true 即真实切换成功',
+        note: '切换真实性验证：headerAppends 为本进程追加的 request/header 次数；stepSwitches 为步骤级升级/降级次数（stepLog 有明细）；lastActual 为最近一步真实出网模型',
       }
     },
   })
@@ -667,7 +795,7 @@ export function apply(ctx, config = {}) {
   })
   register({
     name: 'agentic_router_force',
-    description: '强制后续请求使用指定模型 id（仅 active 模式生效）；clear=true 清除强制，恢复规则路由。',
+    description: '强制后续请求使用指定模型 id（仅 active 模式生效，支持 model 或 provider/model）；clear=true 清除强制，恢复规则路由。',
     parameters: {
       type: 'object',
       properties: {
@@ -688,14 +816,15 @@ export function apply(ctx, config = {}) {
         store.savePolicy({ mode: state.mode, forced: args.model, prices })
         // 立即对存活会话应用（下一请求生效）
         if (state.mode === 'active') {
+          const pf = parseForced(args.model)
           try {
             const agents = ctx.get('agents')
             if (agents && typeof agents.list === 'function') {
               for (const agent of agents.list()) {
                 try {
                   const session = sessionOf({ agent })
-                  if (session && currentModel(session) !== args.model) {
-                    const ok = appendRouterHeader(session, args.model)
+                  if (session && currentModel(session) !== pf.model) {
+                    const ok = appendRouterHeader(session, pf.model, 'router', pf.provider)
                     if (ok) state.headerAppends++
                   }
                 } catch (e) { /* per-agent best effort */ }

package/dsh/strategies.js

@@ -21,18 +21,45 @@ export function tierTarget(tier, provider, modelTiers) {
   return null
 }
 
-// 档位 → 模型 id 的解析；mid 档无候选时向上取 strong（保质量），再取 fast
-export function resolveTier(tier, provider, modelTiers) {
-  if (!modelTiers) return { target: null, used: tier, note: 'tiers-not-ready' }
-  const target = tierTarget(tier, provider, modelTiers)
-  if (target) return { target, used: tier, note: '' }
+// 档位是否有候选（跨所有 provider）——供 availableTiersFor 判断该档是否值得探索
+export function tierHasAny(tier, modelTiers) {
+  const list = modelTiers && modelTiers.tiers && modelTiers.tiers[tier]
+  return Array.isArray(list) && list.length > 0
+}
+
+// 档位 → 模型 id 的解析（v1.6.0 支持跨 provider）：
+//   1) 优先当前 provider 的候选（保持会话 provider 稳定，避免无谓跨厂商）
+//   2) 无候选时，若 crossProvider（默认开），按 providers 顺序取其它 provider 的同档候选
+//   3) mid 档仍无候选时：先同 provider 的 strong/fast，再跨 provider 的 strong/fast
+// 返回 { target, provider, used, note }；provider 为最终选定的 provider id。
+export function resolveTier(tier, provider, modelTiers, opts = {}) {
+  if (!modelTiers) return { target: null, provider: null, used: tier, note: 'tiers-not-ready' }
+  const cross = opts.crossProvider !== false
+  const same = (t) => {
+    const m = tierTarget(t, provider, modelTiers)
+    return m ? { provider, model: m } : null
+  }
+  const crossPick = (t) => {
+    if (!cross) return null
+    for (const p of modelTiers.providers || []) {
+      const pid = p && (p.provider || p.id || p.name)
+      if (!pid || pid === provider) continue
+      const m = tierTarget(t, pid, modelTiers)
+      if (m) return { provider: pid, model: m }
+    }
+    return null
+  }
+  const isCross = (r) => !!(r && provider && r.provider !== provider)
+
+  const direct = same(tier) || crossPick(tier)
+  if (direct) return { target: direct.model, provider: direct.provider, used: tier, note: isCross(direct) ? 'cross-provider' : '' }
   if (tier === 'mid') {
-    const strong = tierTarget('strong', provider, modelTiers)
-    if (strong) return { target: strong, used: 'strong', note: 'mid->strong fallback' }
-    const fast = tierTarget('fast', provider, modelTiers)
-    if (fast) return { target: fast, used: 'fast', note: 'mid->fast fallback' }
+    const strong = same('strong') || crossPick('strong')
+    if (strong) return { target: strong.model, provider: strong.provider, used: 'strong', note: 'mid->strong fallback' + (isCross(strong) ? ' [cross-provider]' : '') }
+    const fast = same('fast') || crossPick('fast')
+    if (fast) return { target: fast.model, provider: fast.provider, used: 'fast', note: 'mid->fast fallback' + (isCross(fast) ? ' [cross-provider]' : '') }
   }
-  return { target: null, used: tier, note: 'no-candidate' }
+  return { target: null, provider: null, used: tier, note: 'no-candidate' }
 }
 
 export function recommendRule(cls) {
@@ -117,6 +144,12 @@ export function recommendKnn(cls, f, knnState, availableTiers = ['fast', 'mid',
 //   4) CONSERVATIVE                     保守值 + 标记 unknown，提醒用户补价格
 export const DEFAULT_PRICES = {
   'deepseek-official': {
+    'deepseek-flash': { in: 0.2, out: 2 },
+    'deepseek-v4-flash': { in: 0.2, out: 2 },
+    'deepseek-v4-pro': { in: 1, out: 12 },
+  },
+  'deepseek-account': {
+    'deepseek-flash': { in: 0.2, out: 2 },
     'deepseek-v4-flash': { in: 0.2, out: 2 },
     'deepseek-v4-pro': { in: 1, out: 12 },
   },
@@ -127,6 +160,25 @@ export const DEFAULT_PRICES = {
   },
 }
 
+// 价格表合并：以 base（内置默认价）为底，over（policy/config 的用户覆盖）为准。
+// 这样新增内置价（如 deepseek-account）能对既有安装生效，同时不覆盖用户自定义价格。
+export function mergePrices(base, over) {
+  const out = {}
+  for (const [k, v] of Object.entries(base || {})) {
+    out[k] = {}
+    for (const [k2, v2] of Object.entries(v || {})) out[k][k2] = { ...v2 }
+  }
+  for (const [k, v] of Object.entries(over || {})) {
+    if (!out[k]) out[k] = {}
+    for (const [k2, v2] of Object.entries(v || {})) {
+      if (v2 && typeof v2 === 'object' && typeof v2.in === 'number' && typeof v2.out === 'number') {
+        out[k][k2] = { in: v2.in, out: v2.out }
+      }
+    }
+  }
+  return out
+}
+
 const CONSERVATIVE = { in: 3, out: 16 }
 
 // 解析价格并返回来源（透明标注：价格到底从哪来的）

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agentic-router",
-  "version": "1.4.2",
-  "description": "DeepSeek Harness plugin: learning agentic router — rule + UCB + LinUCB + k-NN experts under an EXP3 meta-selector, with a durable quality-reward flywheel and REAL model switching via the session request-header precedence chain (v1.4.2)",
+  "version": "1.6.0",
+  "description": "DeepSeek Harness plugin: learning agentic router — rule + UCB + LinUCB + k-NN experts under an EXP3 meta-selector, with a durable quality-reward flywheel, REAL model switching via the session request-header precedence chain, and STEP-LEVEL routing (v1.5.0)",
   "type": "module",
   "license": "MIT",
   "author": "lhl",

package/dsh/package.json

@@ -1,43 +0,0 @@
-{
-  "name": "dsh-agentic-router",
-  "version": "1.4.2",
-  "description": "DeepSeek Harness plugin: learning agentic router — rule + UCB + LinUCB + k-NN experts under an EXP3 meta-selector, with a durable quality-reward flywheel and REAL model switching via the session request-header precedence chain (v1.4.2)",
-  "type": "module",
-  "license": "MIT",
-  "author": "lhl",
-  "engines": {
-    "node": ">=22.19"
-  },
-  "keywords": [
-    "deepseek-harness",
-    "dsh",
-    "dsh-plugin",
-    "agentic-router",
-    "model-routing",
-    "bandit",
-    "exp3",
-    "flywheel",
-    "llm"
-  ],
-  "exports": {
-    ".": "./dsh/index.js",
-    "./dsh": "./dsh/index.js",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dsh",
-    "cordis.patch.yml",
-    "README.md",
-    "README.en.md",
-    "docs",
-    "LICENSE"
-  ],
-  "scripts": {
-    "test": "node --test"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  }
-}

package/dsh/plugin.test.js

@@ -1,405 +0,0 @@
-// 插件端到端测试（v1.4.0 机制）：inbox 决策 + request/header 追加真实切换；
-// agent/request 只读透传；llm/stream 提供 request 路径的兜底应用。
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { apply, name, inject } from '../dsh/index.js'
-import { Store } from '../dsh/store.js'
-
-// 会话 mock：requestHeader 反映最近追加的 header（模拟真实 fold 行为）
-function mockSession(id, startModel = 'deepseek-v4-pro') {
-  let model = startModel
-  const events = []
-  return {
-    id,
-    events,
-    append(type, data) {
-      events.push({ type, data })
-      if (type === 'request/header' && data && data.header && data.header.config && typeof data.header.config.model === 'string') {
-        model = data.header.config.model
-      }
-    },
-    requestHeader() {
-      return { config: { provider: 'deepseek-official', model }, adapterDefaults: {} }
-    },
-  }
-}
-
-function mockCtx(opts = {}) {
-  const listeners = {}
-  const registered = []
-  return {
-    listeners,
-    registered,
-    get(k) {
-      if (k === 'tools') {
-        return { register: (def) => { registered.push(def); return () => {} } }
-      }
-      if (k === 'llm') {
-        return {
-          async listProviders() { return [{ id: 'deepseek-official' }] },
-          async listModels() {
-            if (opts.slowModels) return new Promise(() => {}) // 永不 resolve：模拟档位表加载未完成
-            return [{ id: 'deepseek-v4-flash' }, { id: 'deepseek-v4-pro' }]
-          },
-        }
-      }
-      if (k === 'messageFeedback') return opts.mf
-      if (k === 'timer') return opts.timer
-      if (k === 'sessions') return opts.sessions
-      if (k === 'agents') return opts.agents
-      return undefined
-    },
-    on(ev, fn) { listeners[ev] = fn; return () => {} },
-  }
-}
-
-function payload(sessionId, turn, session) {
-  return { agent: { sessionId, session: session || mockSession(sessionId) }, turn, step: 1, signal: {} }
-}
-
-const CODE_TASK = '重构下面这段 Python 代码，使其支持多线程并发执行并安全处理异常：\n\n```python\nimport time\ndef fetch(url):\n    time.sleep(1)\n```'
-const QA_TASK = '请只用一句话回答：地球的天然卫星叫什么？'
-
-test('插件声明', () => {
-  assert.equal(name, 'agentic-router')
-  assert.ok(inject.includes('tools'))
-})
-
-test('v1.4.0 机制：inbox 决策并追加 request/header 真实切换（shadow 不动、active 切换、request 只读透传）', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-'))
-  const ctx = mockCtx()
-  apply(ctx, { home })
-  const inbox = ctx.listeners['agent/inbox/claimed']
-  const req = ctx.listeners['agent/request']
-  const stop = ctx.listeners['agent/turn-stopping']
-  assert.ok(inbox && req && stop, '事件监听应全部挂载')
-  assert.equal(ctx.registered.length, 5, '应注册 5 个工具')
-
-  const session = mockSession('s1')
-  const P = (t, text) => ({ agent: { sessionId: 's1', session }, turn: t, step: 1, signal: {}, message: { role: 'user', content: [{ type: 'text', text }] } })
-  const headers = () => session.events.filter((e) => e.type === 'request/header')
-
-  // shadow 模式（默认）：复杂代码任务 → 记录决策，但不追加 header
-  await inbox(P(1, CODE_TASK))
-  assert.equal(headers().length, 0, 'shadow 模式不得切换')
-
-  // 切 active
-  const setMode = ctx.registered.find((t) => t.name === 'agentic_router_set_mode')
-  await setMode.execute({ mode: 'active' }, {})
-
-  // 简单问答 → 追加 flash header
-  await inbox(P(2, QA_TASK))
-  const appends = headers()
-  assert.equal(appends.length, 1, 'active 模式应追加一次 request/header')
-  assert.equal(appends[0].data.header.config.model, 'deepseek-v4-flash', '简单任务应切 flash')
-  assert.equal(appends[0].data.reason, 'router')
-
-  // agent/request 必须只读透传（不再替换配置）
-  const cfg = await req(payload('s1', 2, session), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  assert.equal(cfg.model, 'deepseek-v4-pro', 'agent/request 必须透传原配置')
-
-  // 收尾 → 奖励落盘且元数据完整
-  await stop(payload('s1', 2, session))
-  const store = new Store(home)
-  const rewards = store.loadJsonl('rewards.jsonl')
-  assert.equal(rewards.length, 1)
-  assert.ok(rewards[0].reward > 0)
-  assert.equal(rewards[0].turn, 's1/2')
-  assert.ok(Array.isArray(rewards[0].f) && rewards[0].f.length === 9, '奖励记录需含特征向量（供 replay）')
-
-  const decisions = store.loadJsonl('decisions.jsonl')
-  assert.equal(decisions.length, 2)
-  assert.equal(decisions[1].targetModel, 'deepseek-v4-flash')
-  assert.equal(decisions[1].applied, true, 'header 追加成功应标记 applied')
-  assert.equal(decisions[1].swapped, true, '真实切换应标记 swapped')
-
-  const stats = await ctx.registered.find((t) => t.name === 'agentic_router_stats').execute({}, {})
-  assert.equal(stats.totalDecisions, 2)
-  assert.equal(stats.mode, 'active')
-  assert.equal(stats.headerAppends, 1, 'stats 应统计追加次数')
-  assert.equal(stats.lastActual.model, 'deepseek-v4-pro')
-})
-
-test('冷启动：档位表异步加载未完成时，inbox 仍用兜底档位立即切换（v1.4.1 修复）', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-coldstart-'))
-  const ctx = mockCtx({ slowModels: true }) // listModels 永不 resolve，模拟冷启动
-  apply(ctx, { home, mode: 'active' })
-  const inbox = ctx.listeners['agent/inbox/claimed']
-  assert.ok(inbox)
-
-  const session = mockSession('s1') // 当前 pro
-  const P = (t, text) => ({ agent: { sessionId: 's1', session }, turn: t, step: 1, signal: {}, message: { role: 'user', content: [{ type: 'text', text }] } })
-
-  // inbox 是同步的：调用后立即断言，不等待任何异步档位表加载
-  inbox(P(1, QA_TASK))
-  const appends = session.events.filter((e) => e.type === 'request/header')
-  assert.equal(appends.length, 1, '冷启动下也应立即追加 header')
-  assert.equal(appends[0].data.header.config.model, 'deepseek-v4-flash', '兜底档位表应把简单问答切到 flash')
-  assert.equal(appends[0].data.reason, 'router')
-})
-
-test('v1.4.2：UCB 不探索无候选的 mid 档——简单任务决策里 recs.ucb 不得为 mid', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-notier-'))
-  const ctx = mockCtx() // 档位表只有 flash/pro（fast/strong），mid 无候选
-  apply(ctx, { home, mode: 'active' })
-  const inbox = ctx.listeners['agent/inbox/claimed']
-  const session = mockSession('s1')
-  const P = (t, text) => ({ agent: { sessionId: 's1', session }, turn: t, step: 1, signal: {}, message: { role: 'user', content: [{ type: 'text', text }] } })
-
-  // 连发 6 个简单问答，覆盖 UCB 冷启动轮转
-  for (let i = 1; i <= 6; i++) inbox(P(i, QA_TASK + '（第' + i + '问）'))
-
-  const store = new Store(home)
-  const decisions = store.loadJsonl('decisions.jsonl')
-  assert.equal(decisions.length, 6)
-  for (const d of decisions) {
-    assert.ok(!String(d.recs.ucb).startsWith('mid'), 'UCB 不得推荐 mid，实际 ' + d.recs.ucb)
-    assert.ok(!String(d.recs.lin).startsWith('mid'), 'LinUCB 不得推荐 mid，实际 ' + d.recs.lin)
-  }
-})
-
-test('兜底路径：request 决策 + llm/stream 延迟应用（中途热加载场景）', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-fallback-'))
-  const session = mockSession('s1')
-  const sessions = new Map([['s1', session]])
-  const ctx = mockCtx({ sessions })
-  apply(ctx, { home, mode: 'active' })
-  const pre = ctx.listeners['agent/pre-step']
-  const req = ctx.listeners['agent/request']
-  const stream = ctx.listeners['llm/stream']
-  assert.ok(pre && req && stream)
-
-  await pre({ ...payload('s1', 1, session), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  const cfg = await req(payload('s1', 1, session), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  assert.equal(cfg.model, 'deepseek-v4-pro', 'request 路径也透传')
-
-  // 流式调用结束 → 补应用切换
-  const wrapped = stream({ sessionId: 's1', provider: 'deepseek-official' }, async function* () {
-    yield { type: 'finish', reason: 'stop' }
-  })
-  for await (const c of wrapped) { /* drain */ }
-
-  const appends = session.events.filter((e) => e.type === 'request/header')
-  assert.equal(appends.length, 1, 'llm/stream 后应补应用一次 header')
-  assert.equal(appends[0].data.header.config.model, 'deepseek-v4-flash')
-})
-
-test('飞轮重放：新实例从 rewards.jsonl 恢复学习状态', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-replay-'))
-  const ctx1 = mockCtx()
-  apply(ctx1, { home })
-  const stop = ctx1.listeners['agent/turn-stopping']
-  const req = ctx1.listeners['agent/request']
-  const pre = ctx1.listeners['agent/pre-step']
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  await stop(payload('s1', 1))
-
-  // 第二个实例（模拟重启）：应重放出 1 条奖励
-  const ctx2 = mockCtx()
-  apply(ctx2, { home })
-  const stats = await ctx2.registered.find((t) => t.name === 'agentic_router_stats').execute({}, {})
-  assert.equal(stats.flywheel.ucb.total, 1, '重启后 UCB 应恢复 1 次拉动')
-  assert.equal(stats.flywheel.knnPoolSize, 1)
-})
-
-test('工具失败代理：tools/result 错误 → 奖励降分', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-toolerr-'))
-  const ctx = mockCtx()
-  apply(ctx, { home })
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  const toolResult = ctx.listeners['tools/result']
-  assert.ok(toolResult)
-
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  toolResult({ agent: { sessionId: 's1' }, name: 'read' }, { status: 'error', error: 'not found' })
-  await stop(payload('s1', 1))
-
-  const store = new Store(home)
-  const rewards = store.loadJsonl('rewards.jsonl')
-  assert.equal(rewards.length, 1)
-  assert.equal(rewards[0].breakdown.toolErrors, 1)
-  assert.equal(rewards[0].reward, 0.8)
-})
-
-test('reset 工具清空飞轮', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-reset-'))
-  const ctx = mockCtx()
-  apply(ctx, { home })
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  await stop(payload('s1', 1))
-  await ctx.registered.find((t) => t.name === 'agentic_router_reset').execute({}, {})
-  const stats = await ctx.registered.find((t) => t.name === 'agentic_router_stats').execute({}, {})
-  assert.equal(stats.flywheel.ucb.total, 0)
-  assert.equal(stats.totalDecisions, 0)
-})
-
-test('messageFeedback 结算：回合结束 45s 后按人类点踩修正奖励', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-mf-'))
-  const negativeItem = { messageId: 'm1', rating: 'negative', createdAt: Date.now() + 60000 }
-  const mf = { async list() { return { ok: true, value: { items: [negativeItem] } } } }
-  let sweepFn = null
-  const timer = { interval(fn) { sweepFn = fn; return () => {} } }
-  const ctx = mockCtx({ mf, timer })
-  apply(ctx, { home, settleDelayMs: 0 })
-
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  await stop(payload('s1', 1))
-
-  // 结算前：奖励 1，UCB mean 1
-  const store = new Store(home)
-  assert.equal(store.loadJsonl('rewards.jsonl')[0].reward, 1)
-
-  // 触发结算轮询（settleDelayMs=0 立即到期）
-  assert.ok(sweepFn, '应注册结算轮询')
-  await sweepFn()
-
-  const rewards = store.loadJsonl('rewards.jsonl')
-  const settle = rewards.find((r) => r.type === 'feedback-settle')
-  assert.ok(settle, '应产生 feedback-settle 记录')
-  assert.equal(settle.negative, 1)
-  assert.equal(settle.applied, 1)
-  assert.equal(settle.newReward, 0.5)
-
-  const stats = await ctx.registered.find((t) => t.name === 'agentic_router_stats').execute({}, {})
-  assert.equal(stats.flywheel.ucb.arms['qa:fast'].mean, 0.5, '飞轮均值应被修正')
-  assert.equal(stats.flywheel.pendingFeedback, 0, '结算后 pending 清空')
-})
-
-test('messageFeedback 缺失时优雅降级（不报错、不结算）', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-mfnone-'))
-  const ctx = mockCtx({})
-  apply(ctx, { home, settleDelayMs: 0 })
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  await stop(payload('s1', 1))
-  const store = new Store(home)
-  assert.ok(store.loadJsonl('rewards.jsonl').every((r) => r.type !== 'feedback-settle'))
-})
-
-test('成本信号：llm/stream 透传并累加 usage，奖励按成本扣分', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-cost-'))
-  const ctx = mockCtx({})
-  apply(ctx, { home })
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  const stream = ctx.listeners['llm/stream']
-  assert.ok(stream, '应挂载 llm/stream 监听')
-
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-
-  // 模拟一次流式调用：文本 + usage chunk（strong 档 100k 输入 100k 输出）
-  const chunks = []
-  const wrapped = stream({ sessionId: 's1', provider: 'deepseek-official' }, async function* () {
-    yield { type: 'text-delta', text: '月球' }
-    yield { type: 'usage', usage: { inputTokens: 100000, outputTokens: 100000 } }
-  })
-  for await (const c of wrapped) chunks.push(c)
-  assert.equal(chunks.length, 2, '所有 chunk 必须透传')
-  assert.equal(chunks[0].text, '月球')
-
-  await stop(payload('s1', 1))
-  const store = new Store(home)
-  const rewards = store.loadJsonl('rewards.jsonl')
-  // strong 档成本 = (100000×1 + 100000×12)/1e6 = 1.3 元 → 惩罚封顶 0.5
-  assert.equal(rewards[0].breakdown.costYuan, 1.3)
-  assert.equal(rewards[0].breakdown.costPenalty, 0.5)
-  assert.equal(rewards[0].reward, 0.5)
-})
-
-test('成本信号：无 usage 的 provider 走估算兜底（estimated 标记）', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-costest-'))
-  const ctx = mockCtx({})
-  apply(ctx, { home })
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  const stream = ctx.listeners['llm/stream']
-
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'deepseek-official', model: 'deepseek-v4-pro' }))
-  const wrapped = stream({ sessionId: 's1', provider: 'deepseek-official' }, async function* () {
-    yield { type: 'text-delta', text: 'H2O' }
-    yield { type: 'finish', reason: 'stop' }
-  })
-  for await (const c of wrapped) { /* 透传 */ }
-  await stop(payload('s1', 1))
-  const rewards = new Store(home).loadJsonl('rewards.jsonl')
-  assert.ok(rewards[0].breakdown.costYuan > 0, '估算成本应 > 0')
-  assert.ok(rewards[0].breakdown.costYuan < 0.01, '小回合成本应很小')
-})
-
-test('set_prices：接入新 provider 后配置价格，成本按新价计算', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-price-'))
-  const ctx = mockCtx({})
-  apply(ctx, { home })
-  const setPrices = ctx.registered.find((t) => t.name === 'agentic_router_set_prices')
-  const stats = ctx.registered.find((t) => t.name === 'agentic_router_stats')
-
-  // 默认无 openai 精确价 → 查询显示 prices 表
-  const view = await setPrices.execute({ provider: 'openai' }, {})
-  assert.ok(view.prices['*'], '默认含通用档位兜底')
-
-  // 配置 openai/gpt-x-pro 价格
-  const r = await setPrices.execute({ provider: 'openai', model: 'gpt-x-pro', priceIn: 15, priceOut: 60 }, {})
-  assert.equal(r.updated, 'gpt-x-pro')
-  const after = await stats.execute({}, {})
-  assert.equal(after.prices.openai['gpt-x-pro'].out, 60, '价格表热更新')
-
-  // 新 provider 决策 + 流式 usage → 成本按 15/60 计
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  const stream = ctx.listeners['llm/stream']
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: CODE_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'openai', model: 'gpt-x-pro' }))
-  const wrapped = stream({ sessionId: 's1', provider: 'openai' }, async function* () {
-    yield { type: 'usage', usage: { inputTokens: 1000, outputTokens: 1000 } }
-  })
-  for await (const c of wrapped) { /* 透传 */ }
-  await stop(payload('s1', 1))
-  const rewards = new Store(home).loadJsonl('rewards.jsonl')
-  // (1000×15 + 1000×60)/1e6 = 0.075 元；来源 provider-model
-  assert.ok(Math.abs(rewards[0].breakdown.costYuan - 0.075) < 1e-9)
-  assert.equal(rewards[0].breakdown.pricingSource, 'provider-model')
-})
-
-test('未知 provider 不套用 DeepSeek 价格：用通用档位并标记来源', async () => {
-  const home = mkdtempSync(join(tmpdir(), 'dsh-router-unknown-'))
-  const ctx = mockCtx({})
-  apply(ctx, { home })
-  const req = ctx.listeners['agent/request']
-  const pre = ctx.listeners['agent/pre-step']
-  const stop = ctx.listeners['agent/turn-stopping']
-  const stream = ctx.listeners['llm/stream']
-  await pre({ ...payload('s1', 1), messages: [{ content: [{ type: 'text', text: QA_TASK }] }] }, async () => ({}))
-  await req(payload('s1', 1), async () => ({ provider: 'mystery-vendor', model: 'mystery-fast' }))
-  const wrapped = stream({ sessionId: 's1', provider: 'mystery-vendor' }, async function* () {
-    yield { type: 'usage', usage: { inputTokens: 1000, outputTokens: 1000 } }
-  })
-  for await (const c of wrapped) { /* 透传 */ }
-  await stop(payload('s1', 1))
-  const rewards = new Store(home).loadJsonl('rewards.jsonl')
-  // '*' fast = (1000×1 + 1000×4)/1e6 = 0.005
-  assert.ok(Math.abs(rewards[0].breakdown.costYuan - 0.005) < 1e-9)
-  assert.equal(rewards[0].breakdown.pricingSource, 'generic-tier')
-})

package/dsh/strategies.test.js

@@ -1,218 +0,0 @@
-// 策略与飞轮测试：UCB 冷启动轮转 / mid 回退 / 奖励公式 / applyReward 更新
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  tierOf, tierTarget, resolveTier,
-  recommendRule, recommendUcb, recommendLin, recommendKnn,
-  rewardOf, applyReward, correctReward,
-  DEFAULT_PRICES, turnCostYuan, resolvePrice,
-} from '../dsh/strategies.js'
-import { metaPick, DEFAULT_WEIGHTS } from '../dsh/meta.js'
-
-const MODEL_TIERS = {
-  providers: [{ provider: 'deepseek-official', models: ['deepseek-v4-flash', 'deepseek-v4-pro'] }],
-  tiers: { fast: ['deepseek-official/deepseek-v4-flash'], mid: [], strong: ['deepseek-official/deepseek-v4-pro'] },
-}
-
-test('tierOf 按 id 关键词分档', () => {
-  assert.equal(tierOf('deepseek-v4-flash'), 'fast')
-  assert.equal(tierOf('deepseek-v4-pro'), 'strong')
-  assert.equal(tierOf('some-model-x'), 'mid')
-})
-
-test('UCB 冷启动：三个未探索臂∞平局时轮转，不会永远选 fast（实测修复）', () => {
-  const st = { total: 0, arms: {} }
-  const t0 = recommendUcb({ type: 'qa' }, st).tier
-  st.total = 1
-  const t1 = recommendUcb({ type: 'qa' }, st).tier
-  st.total = 2
-  const t2 = recommendUcb({ type: 'qa' }, st).tier
-  assert.deepEqual([t0, t1, t2].sort(), ['fast', 'mid', 'strong'])
-})
-
-test('UCB 利用：三臂都有样本时高均值臂胜出（未探索臂上界∞是合法探索）', () => {
-  const st = {
-    total: 30,
-    arms: {
-      'qa:fast': { n: 10, mean: 0.2 },
-      'qa:mid': { n: 10, mean: 0.1 },
-      'qa:strong': { n: 10, mean: 1 },
-    },
-  }
-  assert.equal(recommendUcb({ type: 'qa' }, st).tier, 'strong')
-  // 反之：strong 未探索时，UCB 应合法地选择探索它
-  const st2 = {
-    total: 20,
-    arms: { 'qa:fast': { n: 10, mean: 0.9 }, 'qa:mid': { n: 10, mean: 0.8 } },
-  }
-  assert.equal(recommendUcb({ type: 'qa' }, st2).tier, 'strong')
-})
-
-test('v1.4.2：availableTiers 过滤后 UCB/LinUCB 只推荐可用档位（不探索无候选的 mid）', () => {
-  const st = { total: 0, arms: {} }
-  const lin = { total: 0, tierN: { fast: 0, mid: 0, strong: 0 }, tierW: { fast: new Array(9).fill(0), mid: new Array(9).fill(0), strong: new Array(9).fill(0) } }
-  const f = [1, 0, 0.01, 0, 0, 0, 0, 0, 0]
-  for (let i = 0; i < 8; i++) {
-    const u = recommendUcb({ type: 'qa' }, st, ['fast', 'strong'])
-    const l = recommendLin({ type: 'qa' }, f, lin, ['fast', 'strong'])
-    st.total += 1
-    assert.ok(['fast', 'strong'].includes(u.tier), 'UCB 不得推荐 mid，实际 ' + u.tier)
-    assert.ok(['fast', 'strong'].includes(l.tier), 'LinUCB 不得推荐 mid，实际 ' + l.tier)
-  }
-  // k-NN：经验池里有 mid 邻居时，也不得推荐 mid
-  const pool = [
-    { f, tier: 'fast', r: 0.9 },
-    { f, tier: 'fast', r: 0.8 },
-    { f, tier: 'mid', r: 0.7 },
-    { f, tier: 'mid', r: 0.6 },
-    { f, tier: 'strong', r: 0.4 },
-  ]
-  const knn = recommendKnn({ type: 'qa' }, f, { pool }, ['fast', 'strong'])
-  assert.ok(['fast', 'strong'].includes(knn.tier), 'k-NN 不得推荐 mid，实际 ' + knn.tier)
-})
-
-test('resolveTier：mid 档无候选时向上取 strong（实测修复）', () => {
-  assert.deepEqual(resolveTier('mid', 'deepseek-official', MODEL_TIERS),
-    { target: 'deepseek-v4-pro', used: 'strong', note: 'mid->strong fallback' })
-  assert.equal(resolveTier('fast', 'deepseek-official', MODEL_TIERS).target, 'deepseek-v4-flash')
-  assert.equal(resolveTier('strong', 'deepseek-official', MODEL_TIERS).target, 'deepseek-v4-pro')
-})
-
-test('规则表阈值：低→fast，中→mid，高→strong', () => {
-  assert.equal(recommendRule({ complexity: 0.1 }).tier, 'fast')
-  assert.equal(recommendRule({ complexity: 0.5 }).tier, 'mid')
-  assert.equal(recommendRule({ complexity: 0.8 }).tier, 'strong')
-})
-
-test('质量代理奖励：工具失败 −0.2/次（封顶 0.6），重试 −0.2/次（封顶 0.4），延迟分档', () => {
-  assert.equal(rewardOf({ toolErrors: 1, retries: 0 }, 'clean-close', 1000).reward, 0.8)
-  assert.equal(rewardOf({ toolErrors: 5, retries: 0 }, 'clean-close', 1000).reward, 0.4)
-  assert.equal(rewardOf({ toolErrors: 0, retries: 4 }, 'clean-close', 1000).reward, 0.6)
-  assert.equal(rewardOf({ toolErrors: 0, retries: 0 }, 'clean-close', 40000).reward, 0.9)
-  assert.equal(rewardOf({ toolErrors: 0, retries: 0 }, 'error', 1000).reward, 0)
-})
-
-test('applyReward：更新 UCB/LinUCB/k-NN/EXP3 四个学习器', () => {
-  const state = {
-    ucb: { total: 0, arms: {} },
-    lin: { total: 0, tierN: { fast: 0, mid: 0, strong: 0 }, tierW: { fast: new Array(9).fill(0), mid: new Array(9).fill(0), strong: new Array(9).fill(0) } },
-    knn: { pool: [] },
-    exp3: { total: 0, weights: { ...DEFAULT_WEIGHTS } },
-  }
-  const rec = {
-    reward: 0.8, clsType: 'qa', ucbTier: 'fast', linTier: 'fast',
-    f: [1, 0.1, 0.01, 0, 0, 0, 0, 0, 1],
-    chosen: 'rule', pChosen: 0.7, pool: ['ucb', 'rule'],
-  }
-  applyReward(state, rec)
-  assert.equal(state.ucb.arms['qa:fast'].n, 1)
-  assert.equal(state.ucb.arms['qa:fast'].mean, 0.8)
-  assert.equal(state.lin.tierN.fast, 1)
-  assert.equal(state.knn.pool.length, 1)
-  assert.ok(state.exp3.weights.rule > DEFAULT_WEIGHTS.rule, '被选策略权重应上升')
-})
-
-test('metaPick：冷启动只有 ucb+rule 入池，rule 初始权重 2.5 占优', () => {
-  const recs = {
-    rule: { tier: 'fast', conf: 0.5 },
-    ucb: { tier: 'fast', conf: 0.2 },
-    lin: { tier: 'fast', conf: 0.1 },
-    knn: { tier: null, conf: 0 },
-  }
-  const exp3 = { weights: { ...DEFAULT_WEIGHTS }, linGraduated: false, knnGraduated: false }
-  const m = metaPick(recs, exp3)
-  assert.deepEqual(m.pool.sort(), ['rule', 'ucb'])
-  assert.ok(Math.abs(m.ps.rule - 2.5 / 3.5) < 1e-9)
-  assert.ok(m.byName[m.chosen])
-})
-
-test('k-NN 冷启动：经验不足时给 null 档', () => {
-  const r = recommendKnn({ type: 'qa' }, [1, 0.1, 0.01, 0, 0, 0, 0, 0, 1], { pool: [] })
-  assert.equal(r.tier, null)
-  assert.equal(r.conf, 0)
-})
-
-test('k-NN 推荐：邻居经验按均值选档', () => {
-  const pool = []
-  const f = [1, 0.1, 0.01, 0, 0, 0, 0, 0, 1]
-  for (let i = 0; i < 10; i++) {
-    pool.push({ f: [1, 0.11, 0.01, 0, 0, 0, 0, 0, 1], tier: 'strong', r: 1 })
-    pool.push({ f: [1, 0.12, 0.01, 0, 0, 0, 0, 0, 1], tier: 'fast', r: 0.3 })
-  }
-  const r = recommendKnn({ type: 'qa' }, f, { pool })
-  assert.equal(r.tier, 'strong')
-  assert.ok(r.conf > 0)
-})
-
-test('correctReward：反馈修正精确回退 UCB 均值与 EXP3 权重', () => {
-  const state = {
-    ucb: { total: 1, arms: {} },
-    lin: { total: 1, tierN: { fast: 1, mid: 0, strong: 0 }, tierW: { fast: new Array(9).fill(0), mid: new Array(9).fill(0), strong: new Array(9).fill(0) } },
-    knn: { pool: [] },
-    exp3: { total: 1, weights: { ...DEFAULT_WEIGHTS } },
-  }
-  const rec = {
-    reward: 1, clsType: 'qa', ucbTier: 'fast', linTier: 'fast',
-    f: [1, 0.1, 0.01, 0, 0, 0, 0, 0, 1],
-    chosen: 'rule', pChosen: 0.7, pool: ['ucb', 'rule'],
-  }
-  applyReward(state, rec)
-  assert.equal(state.ucb.arms['qa:fast'].mean, 1)
-  const wBefore = state.exp3.weights.rule
-
-  correctReward(state, rec, 0.5)
-  assert.equal(state.ucb.arms['qa:fast'].n, 1, 'n 不变')
-  assert.equal(state.ucb.arms['qa:fast'].mean, 0.5, '均值修正为 0.5')
-  assert.ok(state.exp3.weights.rule < wBefore, 'EXP3 权重应乘性回退')
-  assert.ok(Math.abs(state.exp3.weights.rule - DEFAULT_WEIGHTS.rule * Math.exp(0.3 * (0.5 / 0.7) / 2)) < 1e-9, 'EXP3 回退为精确逆运算')
-  assert.equal(rec.reward, 0.5, '记录同步更新')
-})
-
-test('correctReward：无变化时不修正', () => {
-  const state = {
-    ucb: { total: 1, arms: {} },
-    lin: { total: 1, tierN: { fast: 1, mid: 0, strong: 0 }, tierW: { fast: new Array(9).fill(0), mid: new Array(9).fill(0), strong: new Array(9).fill(0) } },
-    knn: { pool: [] },
-    exp3: { total: 1, weights: { ...DEFAULT_WEIGHTS } },
-  }
-  const rec = { reward: 0.8, clsType: 'qa', ucbTier: 'fast', linTier: 'fast', f: [1, 0, 0, 0, 0, 0, 0, 0, 1], chosen: 'rule', pChosen: 0.7, pool: ['ucb', 'rule'] }
-  applyReward(state, rec)
-  const snapshot = JSON.stringify(state.ucb)
-  correctReward(state, rec, 0.8)
-  assert.equal(JSON.stringify(state.ucb), snapshot)
-})
-
-test('turnCostYuan：三级价格解析（缓存读计入输入、推理计入输出）', () => {
-  const usage = { inputTokens: 1000, outputTokens: 100, cacheReadTokens: 500, reasoningTokens: 50 }
-  // 1) 精确模型价：deepseek-v4-pro = (1500×1 + 150×12)/1e6 = 0.0033
-  assert.ok(Math.abs(turnCostYuan(usage, 'deepseek-official', 'deepseek-v4-pro', 'strong', DEFAULT_PRICES) - 0.0033) < 1e-9)
-  // 2) provider 档位价：acme/xyz-pro 无精确价 → acme.strong = (1500×5 + 150×50)/1e6 = 0.015
-  const acme = { acme: { strong: { in: 5, out: 50 } } }
-  assert.ok(Math.abs(turnCostYuan(usage, 'acme', 'xyz-pro', 'strong', acme) - 0.015) < 1e-9)
-  // 3) 未知 provider 用 '*' 通用档位（绝不套用 DeepSeek 价）：'*'.fast = (1500×1 + 150×4)/1e6 = 0.0021
-  assert.ok(Math.abs(turnCostYuan(usage, 'mystery', 'some-model', 'fast', DEFAULT_PRICES) - 0.0021) < 1e-9)
-  // 4) 连 '*' 都没有 → 保守兜底 (3,16) = (1500×3 + 150×16)/1e6 = 0.0069
-  assert.ok(Math.abs(turnCostYuan(usage, 'mystery', 'some-model', 'fast', {}) - 0.0069) < 1e-9)
-  assert.equal(turnCostYuan(null, 'deepseek-official', 'deepseek-v4-pro', 'strong', DEFAULT_PRICES), 0)
-})
-
-test('resolvePrice 返回来源标注（透明审计）', () => {
-  const acme = { acme: { strong: { in: 5, out: 50 } } }
-  assert.equal(resolvePrice('deepseek-official', 'deepseek-v4-pro', 'strong', DEFAULT_PRICES).source, 'provider-model')
-  assert.equal(resolvePrice('acme', 'xyz-pro', 'strong', acme).source, 'provider-tier')
-  assert.equal(resolvePrice('mystery', 'some-model', 'fast', DEFAULT_PRICES).source, 'generic-tier')
-  assert.equal(resolvePrice('mystery', 'some-model', 'fast', {}).source, 'unknown-conservative')
-})
-
-test('rewardOf 成本项：weight×元封顶 cap', () => {
-  const td = { toolErrors: 0, retries: 0, costYuan: 0.02, costWeight: 20, costCap: 0.5 }
-  const r = rewardOf(td, 'clean-close', 1000)
-  assert.ok(Math.abs(r.reward - 0.6) < 1e-9, '1 − 0.4 = 0.6，实际 ' + r.reward)
-  assert.equal(r.breakdown.costPenalty, 0.4)
-  assert.equal(r.breakdown.costYuan, 0.02)
-
-  const td2 = { toolErrors: 0, retries: 0, costYuan: 0.1, costWeight: 20, costCap: 0.5 }
-  const r2 = rewardOf(td2, 'clean-close', 1000)
-  assert.equal(r2.breakdown.costPenalty, 0.5, '惩罚封顶 0.5')
-  assert.equal(r2.reward, 0.5)
-})