dsh-agentic-router 1.4.2 → 1.5.0

package/README.md

@@ -14,6 +14,12 @@ 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`。
+
 ## 架构
 
 ```

package/docs/DESIGN.md

@@ -226,3 +226,40 @@ 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）

package/dsh/index.js

@@ -77,6 +77,8 @@ function freshState() {
     recByTurn: new Map(),
     headerAppends: 0,
     lastActual: null,
+    stepLog: [],
+    counters: { stepSwitches: 0 },
     ucb: { total: 0, arms: {} },
     lin: {
       total: 0,
@@ -188,10 +190,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') {
   try {
     const last = session.requestHeader()
     const header = {}
@@ -204,13 +206,40 @@ function appendRouterHeader(session, targetModel) {
     config.model = targetModel
     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
   }
 }
 
+// 步骤级路由（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()
@@ -347,6 +376,8 @@ export function apply(ctx, config = {}) {
       currentModel: current, provider, costWeight, costCap,
       estInputTokens: Math.ceil(text.length / 1.5),
       target, applied: false, needsApply: false, actualModel: current,
+      // 回合级基线（供步骤级路由 v1.5.0 参考：无重型工具时保持该档）
+      turnTier: target ? tierOf(target) : null, turnTarget: target,
     }
     const record = {
       seq: state.seq,
@@ -429,6 +460,38 @@ 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()
+      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)
+      const target = resolved.target
+      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
+      const stepRec = { turn: key, step: payload.step, lastTools: tools.slice(0, 5), stepTier, target, 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()
   })
 
@@ -499,14 +562,25 @@ 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 && td.stepTarget !== currentModel(session)) {
+                const ok = appendRouterHeader(session, td.stepTarget, 'router-step')
+                if (ok) {
+                  state.counters.stepSwitches++
+                  if (td.stepRec) { td.stepRec.applied = true }
+                  log('STEP-SWAP -> ' + td.stepTarget + (td.stepRec ? ' (tools: ' + td.stepRec.lastTools.join(',') + ')' : ''))
+                }
+              }
+              td.stepTarget = 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 || ''
@@ -632,9 +706,11 @@ export function apply(ctx, config = {}) {
         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 +721,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 为最近一步真实出网模型',
       }
     },
   })

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.5.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)
-})