dsh-agentic-router 1.4.0 → 1.4.2

package/dsh/index.js

@@ -38,6 +38,31 @@ const KNN_GRADUATION = 30   // k-NN 毕业经验线
 const SETTLE_DELAY_MS = 45000 // 反馈结算窗口：回合结束 45s 后查询 messageFeedback
 const SWEEP_MS = 15000        // 结算轮询周期
 
+// 同步兜底档位表：从 DEFAULT_PRICES 已知的 provider→model 推导档位，
+// 让插件在 llm.listModels 异步加载完成之前也能立即决策与切换（不 await、不延期）。
+// 加载完成后由 refreshModelTiers 用权威目录覆盖。
+function fallbackTiers() {
+  const tiers = { fast: [], mid: [], strong: [] }
+  const providers = []
+  for (const provider of Object.keys(DEFAULT_PRICES)) {
+    if (provider === '*') continue
+    const models = Object.keys(DEFAULT_PRICES[provider] || {})
+    if (!models.length) continue
+    providers.push({ provider, models })
+    for (const n of models) tiers[tierOf(n)].push(provider + '/' + n)
+  }
+  return { providers, tiers }
+}
+
+// 当前 provider 有候选模型的档位列表（UCB/LinUCB/k-NN 只在这些档位间探索）。
+// provider 缺失或档位表不可用时回退到全部档位（保持专家函数原有行为）。
+function availableTiersFor(provider, modelTiers) {
+  const all = ['fast', 'mid', 'strong']
+  if (!modelTiers || !provider) return all
+  const has = all.filter((t) => tierTarget(t, provider, modelTiers))
+  return has.length ? has : all
+}
+
 function freshState() {
   return {
     mode: 'shadow',
@@ -45,7 +70,7 @@ function freshState() {
     decisions: [],
     forced: null,
     pending: new Map(),
-    modelTiers: null,
+    modelTiers: fallbackTiers(),
     turnDecision: {},
     openTurns: new Map(),
     pendingFeedback: [],
@@ -287,20 +312,21 @@ export function apply(ctx, config = {}) {
 
   // ---- 决策流水线（inbox 与 request 兜底共用） ----
   // 返回 { key, td, record, target }；已决策过本回合则返回 null。
-  // 档位表异步加载；决策前等待就绪（tiers-not-ready 会拿不到 target）。
-  async function decideAndRecord(payload, text, current, provider, source) {
-    if (!state.modelTiers) {
-      try { await tiersReady } catch (e) { /* keep null */ }
-    }
+  // 必须同步执行：档位表用 fallbackTiers() 兜底（见 freshState），
+  // 不 await、不延期——否则追加 header 会落到 prompt 组装之后，被 loop 覆盖。
+  function decideAndRecord(payload, text, current, provider, source) {
     const key = fullKey(payload)
     if (state.turnDecision[key]) return null
     const cls = classify(text)
     const f = featuresOf(cls, text)
+    // 只探索当前 provider 有候选模型的档位（跳过无候选的"幽灵档"，
+    // 如 mid 无模型时探索 mid 只会白费并回退到最贵的 strong）
+    const available = availableTiersFor(provider, state.modelTiers)
     const recs = {
       rule: recommendRule(cls),
-      ucb: recommendUcb(cls, state.ucb),
-      lin: recommendLin(cls, f, state.lin),
-      knn: recommendKnn(cls, f, state.knn),
+      ucb: recommendUcb(cls, state.ucb, available),
+      lin: recommendLin(cls, f, state.lin, available),
+      knn: recommendKnn(cls, f, state.knn, available),
     }
     if (state.forced) recs.rule = { tier: 'forced', reason: 'forced', conf: 1 }
     const exp3 = {
@@ -377,14 +403,14 @@ export function apply(ctx, config = {}) {
   // ---- 事件挂载 ----
   // 回合开始（prompt 组装之前）：捕获用户消息并决策，active 模式立即应用切换。
   // 这是主路径——零延迟，回合第一步就按目标模型执行。
-  ctx.on('agent/inbox/claimed', async (payload) => {
+  ctx.on('agent/inbox/claimed', (payload) => {
     try {
       const session = sessionOf(payload)
       const text = extractText(payload && payload.message)
       if (!text) return
       const current = session ? currentModel(session) : null
       const provider = session ? currentProvider(session) : ''
-      const r = await decideAndRecord(payload, text, current, provider, 'inbox')
+      const r = decideAndRecord(payload, text, current, provider, 'inbox')
       if (!r) return
       applyDecision(session, r.key, r.td, r.record, r.target)
       commitRecord(r.record)
@@ -428,7 +454,7 @@ export function apply(ctx, config = {}) {
       const text = state.pending.get(pkey) || ''
       state.pending.delete(pkey)
       const provider = typeof cfg.provider === 'string' ? cfg.provider : ''
-      const r = await decideAndRecord(payload, text, model, provider, 'request')
+      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)
@@ -571,10 +597,11 @@ export function apply(ctx, config = {}) {
   ctx.on('agent/turn-stopping', (payload) => finalize(payload, 'clean-close'))
   ctx.on('agent/error', (payload) => finalize(payload, 'error'))
 
-  // 档位表异步加载；decideAndRecord 在决策前 await 此 promise
+  // 权威档位表异步加载，就绪后覆盖同步兜底表（fallbackTiers 保证首回合即可决策）。
+  // 仅在刷新成功时覆盖，避免把兜底表清成 null。
   const tiersReady = refreshModelTiers(llm)
   tiersReady.then((t) => {
-    state.modelTiers = t
+    if (t) state.modelTiers = t
     log('model tiers: ' + JSON.stringify(t))
   }).catch((e) => log('model tiers refresh failed: ' + String(e)))
 

package/dsh/package.json

@@ -0,0 +1,43 @@
+{
+  "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

@@ -0,0 +1,405 @@
+// 插件端到端测试（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.js

@@ -40,11 +40,13 @@ export function recommendRule(cls) {
   return { tier: want, reason: 'rule threshold complexity=' + cls.complexity, conf: 0.5 }
 }
 
-// UCB：mean + c·√(lnN/n)；未探索臂上界∞，多个∞平局时按总拉动数轮转（避免永远选 fast）
-export function recommendUcb(cls, ucbState) {
+// UCB：mean + c·√(lnN/n)；未探索臂上界∞，多个∞平局时按总拉动数轮转（避免永远选 fast）。
+// availableTiers 由调用方传入（当前 provider 有候选模型的档位）——不探索无候选的"幽灵档"
+// （如 mid 无模型时，探索 mid 只会白费并回退到最贵的 strong）。
+export function recommendUcb(cls, ucbState, availableTiers = ['fast', 'mid', 'strong']) {
   const arms = ucbState.arms
   const scores = []
-  for (const tier of ['fast', 'mid', 'strong']) {
+  for (const tier of availableTiers) {
     const arm = arms[cls.type + ':' + tier] || { n: 0, mean: 0 }
     const ucb = arm.n > 0 ? arm.mean + 1.2 * Math.sqrt(Math.log(ucbState.total + 1) / arm.n) : Infinity
     scores.push({ tier, ucb, arm })
@@ -61,11 +63,12 @@ export function recommendUcb(cls, ucbState) {
   }
 }
 
-// LinUCB（近似实现）：每档线性权重 w·f + 探索项；梯度更新，探索项随档样本数衰减
-export function recommendLin(cls, f, linState) {
+// LinUCB（近似实现）：每档线性权重 w·f + 探索项；梯度更新，探索项随档样本数衰减。
+// availableTiers 同上：只评估有候选模型的档位。
+export function recommendLin(cls, f, linState, availableTiers = ['fast', 'mid', 'strong']) {
   const tn = linState.tierN
   let best = null
-  for (const tier of ['fast', 'mid', 'strong']) {
+  for (const tier of availableTiers) {
     const w = linState.tierW[tier] || []
     let dot = 0
     for (let i = 0; i < f.length; i++) dot += (w[i] || 0) * f[i]
@@ -80,8 +83,9 @@ export function recommendLin(cls, f, linState) {
   }
 }
 
-// k-NN：欧氏距离取 k=5 邻居，按邻居平均奖励选档
-export function recommendKnn(cls, f, knnState) {
+// k-NN：欧氏距离取 k=5 邻居，按邻居平均奖励选档。
+// availableTiers 同上：只从有候选模型的档位里选最佳。
+export function recommendKnn(cls, f, knnState, availableTiers = ['fast', 'mid', 'strong']) {
   const pool = knnState.pool
   if (pool.length < 5) return { tier: null, reason: 'knn cold (' + pool.length + '/5 seed)', conf: 0 }
   const scored = []
@@ -98,7 +102,7 @@ export function recommendKnn(cls, f, knnState) {
     if (agg[t]) { agg[t].n += 1; agg[t].s += scored[i].e.r }
   }
   let best = null
-  for (const tier of ['fast', 'mid', 'strong']) {
+  for (const tier of availableTiers) {
     const a = agg[tier]
     if (!best || (a.n > 0 && a.s / a.n > best.score)) best = { tier, score: a.n > 0 ? a.s / a.n : -1 }
   }

package/dsh/strategies.test.js

@@ -0,0 +1,218 @@
+// 策略与飞轮测试：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)
+})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agentic-router",
-  "version": "1.4.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 and REAL model switching via the session request-header precedence chain (v1.4.0)",
+  "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",