@mzzsfy/dsh-usage-dash 0.1.0 → 0.2.0

package/test/client.test.mjs

@@ -1,19 +1,14 @@
 // client 纯函数层测试:滚动窗口映射/信封解析/上限裁剪/文案/格式化/分组/柱状几何
 // Given/When/Then 场景内嵌于用例描述
-// client.js 为非模块 script(bundle 求值形态,禁 import/export),整源求值后按顶层声明名收集
+// client.js 为经典 script bundle(禁 import/export),整文件 IIFE 书挡;经 client-eval 剥壳后整源求值,按顶层声明名收集
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
+import { CLIENT_BODY, DECLARATION_NAMES } from './client-eval.mjs'
 
-const CLIENT_SOURCE = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'client.js'), 'utf8')
-const DECLARATION_NAMES = [
-  ...new Set(
-    [...CLIENT_SOURCE.matchAll(/^(?:const|function|let) ([A-Za-z_$][\w$]*)/gm)].map((match) => match[1])
-  ),
-]
-const core = new Function(`${CLIENT_SOURCE}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
+const core = new Function(`${CLIENT_BODY}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
 
 const {
   CHART_HEIGHT,
@@ -39,12 +34,16 @@ const {
   aggregateCurrencyOf,
   applyCurrencyToRules,
   cacheRateText,
+  coerceConditions,
+  coercePricingRules,
   costOf,
   costTitleText,
   createTranslator,
   daysInRange,
+  defaultCondition,
   defaultPricingRule,
   donutSegments,
+  pointStatsMatches,
   formatCompact,
   formatCost,
   formatDuration,
@@ -59,10 +58,12 @@ const {
   hourTickLabel,
   indexOfDay,
   isEmptyRange,
+  logTimeOf,
   matchPrice,
   maxSlotsFor,
   minuteTickLabel,
   modelSegmentLabel,
+  modelSpeedText,
   modelNameOf,
   niceTicks,
   otherDetailItems,
@@ -74,7 +75,6 @@ const {
   resolveMinuteRange,
   shortDay,
   smoothPath,
-  statusLineActive,
   tipPlace,
   translateWith,
   trimSlots,
@@ -91,7 +91,7 @@ const NOW = new Date(2026, 2, 15, 14, 30, 45)
 
 test('day 预设映射为最近 N 天闭区间', () => {
   assert.deepEqual(resolveDayRange('7', NOW), { from: '2026-03-09', to: '2026-03-15' })
-  assert.deepEqual(resolveDayRange('14', NOW), { from: '2026-03-02', to: '2026-03-15' })
+  assert.deepEqual(resolveDayRange('30', NOW), { from: '2026-02-14', to: '2026-03-15' })
 })
 
 test('day 预设跨年与跨月边界', () => {
@@ -105,7 +105,7 @@ test('day 90 天预设起点回卷上年', () => {
 
 test('hour 预设 now-N 舍入到整点桶起点', () => {
   assert.deepEqual(resolveHourRange('24h', NOW), { from: '2026-03-14T14', to: '2026-03-15T14' })
-  assert.deepEqual(resolveHourRange('72h', NOW), { from: '2026-03-12T14', to: '2026-03-15T14' })
+  assert.deepEqual(resolveHourRange('3d', NOW), { from: '2026-03-12T14', to: '2026-03-15T14' })
 })
 
 test('hour 预设跨日且窗口起点落整点', () => {
@@ -113,30 +113,53 @@ test('hour 预设跨日且窗口起点落整点', () => {
 })
 
 test('minute 预设起点对齐 10 分钟桶,to 保持原始分钟', () => {
-  assert.deepEqual(resolveMinuteRange('60m', NOW), { from: '2026-03-15T13:30', to: '2026-03-15T14:30' })
-  assert.deepEqual(resolveMinuteRange('360m', NOW), { from: '2026-03-15T08:30', to: '2026-03-15T14:30' })
+  assert.deepEqual(resolveMinuteRange('3h', NOW), { from: '2026-03-15T11:30', to: '2026-03-15T14:30' })
+  assert.deepEqual(resolveMinuteRange('24h', NOW), { from: '2026-03-14T14:30', to: '2026-03-15T14:30' })
   const offGrid = new Date(2026, 2, 15, 14, 37, 20)
-  assert.deepEqual(resolveMinuteRange('60m', offGrid), { from: '2026-03-15T13:30', to: '2026-03-15T14:37' })
+  assert.deepEqual(resolveMinuteRange('3h', offGrid), { from: '2026-03-15T11:30', to: '2026-03-15T14:37' })
 })
 
 test('minute 预设整桶边界不再回退', () => {
-  assert.deepEqual(resolveMinuteRange('60m', new Date(2026, 2, 15, 14, 30, 0)), { from: '2026-03-15T13:30', to: '2026-03-15T14:30' })
+  assert.deepEqual(resolveMinuteRange('3h', new Date(2026, 2, 15, 14, 30, 0)), { from: '2026-03-15T11:30', to: '2026-03-15T14:30' })
 })
 
 test('预设定义表覆盖三视图', () => {
-  assert.deepEqual(DAY_PRESETS, ['7', '14', '30', '90'])
-  assert.deepEqual(HOUR_PRESETS, ['24h', '48h', '72h'])
-  assert.deepEqual(MINUTE_PRESETS, ['60m', '180m', '360m'])
+  assert.deepEqual(DAY_PRESETS, ['7', '30', '90'])
+  assert.deepEqual(HOUR_PRESETS, ['24h', '3d', '7d', '15d'])
+  assert.deepEqual(MINUTE_PRESETS, ['3h', '24h', '3d', '7d'])
+})
+
+test('时/分挡位文案键逐挡齐备,含跨表同 id 挡位', () => {
+  // Given 时/分挡位表存在同 id('24h') When 逐挡查词典 Then 两语言均有对应键,漏配即回退键名
+  for (const id of HOUR_PRESETS) {
+    assert.notEqual(MESSAGES_ZH[`hourPreset.${id}`], undefined, `zh hourPreset.${id}`)
+    assert.notEqual(MESSAGES_EN[`hourPreset.${id}`], undefined, `en hourPreset.${id}`)
+  }
+  for (const id of MINUTE_PRESETS) {
+    assert.notEqual(MESSAGES_ZH[`minutePreset.${id}`], undefined, `zh minutePreset.${id}`)
+    assert.notEqual(MESSAGES_EN[`minutePreset.${id}`], undefined, `en minutePreset.${id}`)
+  }
+})
+
+test('pointStats 缓存命中须视图与挡位双匹配', () => {
+  // Given 同挡位 id 跨视图('24h') When 判定缓存命中 Then 视图不同即不命中,防误用他端点数据
+  const cached = { view: 'hour', preset: '24h', value: { daily: [] } }
+  assert.equal(pointStatsMatches(cached, 'hour', '24h'), true)
+  assert.equal(pointStatsMatches(cached, 'minute', '24h'), false)
+  assert.equal(pointStatsMatches(cached, 'hour', '3d'), false)
+  assert.equal(pointStatsMatches(null, 'hour', '24h'), false)
 })
 
 test('每视图渲染上限等于闭区间桶数', () => {
   assert.equal(maxSlotsFor('day', '90'), DAY_MAX_SLOTS)
   assert.equal(maxSlotsFor('hour', '24h'), 25)
-  assert.equal(maxSlotsFor('hour', '48h'), 49)
-  assert.equal(maxSlotsFor('hour', '72h'), 73)
-  assert.equal(maxSlotsFor('minute', '60m'), 7)
-  assert.equal(maxSlotsFor('minute', '180m'), 19)
-  assert.equal(maxSlotsFor('minute', '360m'), 37)
+  assert.equal(maxSlotsFor('hour', '3d'), 73)
+  assert.equal(maxSlotsFor('hour', '7d'), 169)
+  assert.equal(maxSlotsFor('hour', '15d'), 361)
+  assert.equal(maxSlotsFor('minute', '3h'), 19)
+  assert.equal(maxSlotsFor('minute', '24h'), 145)
+  assert.equal(maxSlotsFor('minute', '3d'), 433)
+  assert.equal(maxSlotsFor('minute', '7d'), 1009)
 })
 
 test('trim 超上限裁最旧且恰好达上限不裁', () => {
@@ -145,6 +168,11 @@ test('trim 超上限裁最旧且恰好达上限不裁', () => {
   assert.equal(trimSlots(slots, 6), slots)
 })
 
+test('日志条目时刻补零为 HH:mm:ss', () => {
+  assert.equal(logTimeOf(new Date(2026, 8, 8, 9, 3, 7).getTime()), '09:03:07')
+  assert.equal(logTimeOf(new Date(2026, 8, 8, 19, 13, 47).getTime()), '19:13:47')
+})
+
 test('信封解析成功透传 value', () => {
   assert.deepEqual(parseEnvelope({ ok: true, value: { a: 1 } }), { ok: true, value: { a: 1 } })
 })
@@ -177,19 +205,11 @@ test('translateWith zh/en 占位替换与缺键回退键名', () => {
 test('createTranslator 与纯查表同构', () => {
   const enT = createTranslator(MESSAGES_EN)
   assert.equal(enT('rangeCustom'), 'Custom')
-  assert.equal(enT('hourPreset', { n: 48 }), 'Last 48 hours')
+  assert.equal(enT('hourPreset.15d'), '15 days')
+  assert.equal(enT('minutePreset.7d'), '7 days')
   assert.equal(enT('missing.key'), 'missing.key')
 })
 
-test('状态行仅在回扫进行或异常存在时可见', () => {
-  assert.equal(statusLineActive(null), false)
-  assert.equal(statusLineActive({ running: false, skippedSessions: 0, recordFailures: 0 }), false)
-  assert.equal(statusLineActive({ running: true, total: 3, done: 1 }), true)
-  assert.equal(statusLineActive({ running: false, error: 'boom' }), true)
-  assert.equal(statusLineActive({ running: false, skippedSessions: 2 }), true)
-  assert.equal(statusLineActive({ running: false, recordFailures: 1 }), true)
-})
-
 test('zh/en 词典键集完全一致', () => {
   assert.deepEqual(Object.keys(MESSAGES_ZH).sort(), Object.keys(MESSAGES_EN).sort())
 })
@@ -536,6 +556,13 @@ test('donut 分段可访问标签格式化名称数值与占比', () => {
   assert.equal(modelSegmentLabel('p/m', 1234, 12.34), 'p/m: 1,234 (12.3%)')
 })
 
+test('模型速度文本:官方吞吐口径格式化,无速度为空串', () => {
+  assert.equal(modelSpeedText(5.5556), '5.6 tok/s')
+  assert.equal(modelSpeedText(12.34), '12 tok/s')
+  assert.equal(modelSpeedText(0), '0 tok/s')
+  assert.equal(modelSpeedText(undefined), '')
+})
+
 // —— S14 费用格式化与展示辅助(镜像函数核心语义见 pricing-parity.test.mjs) ——
 
 test('formatCost 千分位与两位小数', () => {
@@ -551,10 +578,10 @@ test('formatCost 微观值四位小数', () => {
 })
 
 test('镜像函数基本行为:非法输入 null 与命中计价', () => {
-  assert.equal(matchPrice(null, 'm', NOW), null)
-  assert.equal(matchPrice([], 'm', NOW), null)
+  assert.equal(matchPrice(null, 'x/m', NOW), null)
+  assert.equal(matchPrice([], 'x/m', NOW), null)
   assert.deepEqual(
-    matchPrice([{ model: 'm', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] }], 'm', NOW),
+    matchPrice([{ model: 'x/m', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] }], 'x/m', NOW),
     { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 },
   )
   assert.equal(costOf({ input: 2, output: 0, cacheRead: 0, cacheWrite: 0 }, { inputTokens: 1000 * 1000 }), 2)
@@ -594,17 +621,23 @@ test('defaultPricingRule 承接给定货币,缺省回落首档', () => {
   assert.deepEqual(defaultPricingRule('$').conditions, [])
 })
 
-test('validatePricingRules 就地校验 model 必填与价格非空非负', () => {
+test('validatePricingRules 就地校验 model 必填两段式与价格非空非负', () => {
   const valid = [{ model: 'p/m', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] }]
   assert.equal(validatePricingRules(valid).size, 0)
   const broken = [
     { model: '  ', currency: '¥', price: { input: '', output: -1, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
+    { model: 'solo', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
+    { model: '*', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
+    { model: '/x', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
   ]
   const errors = validatePricingRules(broken)
   assert.equal(errors.get('0.model'), 'required')
   assert.equal(errors.get('0.price.input'), 'required')
   assert.equal(errors.get('0.price.output'), 'priceInvalid')
   assert.equal(errors.has('0.price.cacheRead'), false)
+  assert.equal(errors.get('1.model'), 'modelFormat')
+  assert.equal(errors.get('2.model'), 'modelFormat')
+  assert.equal(errors.get('3.model'), 'modelFormat')
 })
 
 test('costTitleText 未计价计数后缀', () => {
@@ -612,3 +645,78 @@ test('costTitleText 未计价计数后缀', () => {
   assert.equal(costTitleText(zhT, 0), '按当前费率对历史用量估算,精度为小时级')
   assert.equal(costTitleText(zhT, 3), '按当前费率对历史用量估算,精度为小时级,3 个小时桶未计价')
 })
+
+test('defaultCondition 各类型默认值即填即用', () => {
+  // Given 四种条件类型 When 取默认 Then 时段全天/周几空/号段全月/日期段当天
+  assert.deepEqual(defaultCondition('dailyWindow'), { kind: 'dailyWindow', from: '00:00', to: '00:00' })
+  assert.deepEqual(defaultCondition('weekdays'), { kind: 'weekdays', days: [] })
+  assert.deepEqual(defaultCondition('monthDays'), { kind: 'monthDays', from: 1, to: 31 })
+  assert.deepEqual(defaultCondition('dateRange', new Date(2026, 2, 15)), { kind: 'dateRange', from: '2026-03-15', to: '2026-03-15' })
+})
+
+test('validatePricingRules 拒绝非法时刻与时刻字段缺失', () => {
+  // Given dailyWindow 时刻超界或缺失 When 校验 Then 标 condTime/required
+  const rules = [
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '99:99', to: '08:00' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '', to: '08:00' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '23:59', to: '24:00' }] },
+  ]
+  const errors = validatePricingRules(rules)
+  assert.equal(errors.get('0.conditions.0.from'), 'condTime')
+  assert.equal(errors.get('1.conditions.0.from'), 'required')
+  assert.equal(errors.get('2.conditions.0.to'), 'condTime')
+})
+
+test('validatePricingRules 校验周几与月号段边界', () => {
+  // Given weekdays 含 7、monthDays 含 0 或 32 When 校验 Then 标 condWeekday/condMonthDay
+  const rules = [
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'weekdays', days: [0, 7] }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'monthDays', from: 0, to: 31 }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'monthDays', from: 1, to: 32 }] },
+  ]
+  const errors = validatePricingRules(rules)
+  assert.equal(errors.get('0.conditions.0.days'), 'condWeekday')
+  assert.equal(errors.get('1.conditions.0.from'), 'condMonthDay')
+  assert.equal(errors.get('2.conditions.0.to'), 'condMonthDay')
+})
+
+test('validatePricingRules 校验日期段格式与倒序', () => {
+  // Given dateRange 非规范日期或倒序 When 校验 Then 标 condDate/condRange
+  const rules = [
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-3-5', to: '2026-03-08' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-03-08', to: '2026-03-05' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-03-05', to: '2026-03-08' }] },
+  ]
+  const errors = validatePricingRules(rules)
+  assert.equal(errors.get('0.conditions.0.from'), 'condDate')
+  assert.equal(errors.get('1.conditions.0'), 'condRange')
+  assert.equal(errors.has('2.conditions.0'), false)
+  assert.equal(errors.has('2.conditions.0.from'), false)
+})
+
+test('coerceConditions 规整数字字段且不改其余字段', () => {
+  // Given 输入框字符串形态 When 规整 Then weekdays days 与 monthDays 号段转数字,时段日期原样
+  const conditions = [
+    { kind: 'weekdays', days: ['1', '5'] },
+    { kind: 'monthDays', from: '26', to: '5' },
+    { kind: 'dailyWindow', from: '09:00', to: '18:00' },
+    { kind: 'dateRange', from: '2026-03-01', to: '2026-03-15' },
+  ]
+  const coerced = coerceConditions(conditions)
+  assert.deepEqual(coerced[0], { kind: 'weekdays', days: [1, 5] })
+  assert.deepEqual(coerced[1], { kind: 'monthDays', from: 26, to: 5 })
+  assert.deepEqual(coerced[2], conditions[2])
+  assert.deepEqual(coerced[3], conditions[3])
+})
+
+test('coercePricingRules 连带规整条件', () => {
+  // Given 含条件规则 When POST 前规整 Then 价格与条件数字字段同时规整
+  const rules = [{
+    model: 'a/b', currency: '¥',
+    price: { input: '1', output: '0', cacheRead: '0', cacheWrite: '0' },
+    conditions: [{ kind: 'weekdays', days: ['1'] }, { kind: 'monthDays', from: '1', to: '31' }],
+  }]
+  const coerced = coercePricingRules(rules)
+  assert.deepEqual(coerced[0].conditions, [{ kind: 'weekdays', days: [1] }, { kind: 'monthDays', from: 1, to: 31 }])
+  assert.deepEqual(coerced[0].price, { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 })
+})

package/test/collector.test.mjs

@@ -139,6 +139,22 @@ test('step/start 与 llm/retry-started 产生 request 标记样本', async () =>
   }
 })
 
+test('step/start 观测起点:首个 usage 样本附 durationMs(start 到样本时刻)', async () => {
+  const { ctx, store } = liveCollector()
+  const start = local(2026, 8, 2, 10, 0)
+  const sampleAt = start + 6 * 1000 + 500
+  ctx.emit('session/event', session('s1'), ev('step/start', 1, start, { turn: 0, step: 0 }))
+  ctx.emit('session/event', session('s1'), ev('assistant/message', 2, sampleAt, {
+    turn: 0,
+    step: 0,
+    usage: usage(),
+    message: {},
+  }))
+  await tick()
+  const usageSample = store.samples.find((sample) => !sample.request)
+  assert.equal(usageSample.durationMs, 6500)
+})
+
 test('(session,turn,step) 去重:同键先到样本生效,重复报告吞掉', async () => {
   const { ctx, store } = liveCollector()
   const t = local(2026, 8, 2, 10, 0)
@@ -158,6 +174,55 @@ test('(session,turn,step) 去重:同键先到样本生效,重复报告吞掉', a
   assert.equal(store.samples[0].inputTokens, 100)
 })
 
+test('无 step/start 起点的 usage 样本不带 durationMs', async () => {
+  const { ctx, store } = liveCollector()
+  const t = local(2026, 8, 2, 10, 0)
+  ctx.emit('session/event', session('s1'), ev('assistant/message', 1, t, {
+    turn: 0,
+    step: 0,
+    usage: usage(),
+    message: {},
+  }))
+  await tick()
+  assert.equal(store.samples.length, 1)
+  assert.equal(store.samples[0].durationMs, undefined)
+})
+
+test('retry-started 重置起点:时长只含最终尝试', async () => {
+  const { ctx, store } = liveCollector()
+  const start = local(2026, 8, 2, 10, 0)
+  const retryAt = start + 60 * 1000
+  const sampleAt = retryAt + 5 * 1000
+  ctx.emit('session/event', session('s1'), ev('step/start', 1, start, { turn: 0, step: 0 }))
+  ctx.emit('session/event', session('s1'), ev('llm/retry-started', 2, retryAt, { turn: 0, step: 0 }))
+  ctx.emit('session/event', session('s1'), ev('assistant/message', 3, sampleAt, {
+    turn: 0,
+    step: 0,
+    usage: usage(),
+    message: {},
+  }))
+  await tick()
+  const usageSample = store.samples.find((sample) => !sample.request)
+  assert.equal(usageSample.durationMs, 5000)
+})
+
+test('同时刻零时长不附 durationMs,request 标记样本不带时长', async () => {
+  const { ctx, store } = liveCollector()
+  const t = local(2026, 8, 2, 10, 0)
+  ctx.emit('session/event', session('s1'), ev('step/start', 1, t, { turn: 0, step: 0 }))
+  ctx.emit('session/event', session('s1'), ev('assistant/message', 2, t, {
+    turn: 0,
+    step: 0,
+    usage: usage(),
+    message: {},
+  }))
+  await tick()
+  assert.equal(store.samples.length, 2)
+  for (const sample of store.samples) {
+    assert.equal(sample.durationMs, undefined)
+  }
+})
+
 test('不同 (turn,step) 各自成立,跨会话同键互不影响', async () => {
   const { ctx, store } = liveCollector()
   const t = local(2026, 8, 2, 10, 0)
@@ -313,6 +378,8 @@ test('采集侧 store 失败计入 recordFailures 且不抛断采集', async ()
   await tick()
   await tick()
   assert.equal(collector.status().recordFailures, 2)
+  assert.equal(collector.status().log.length, 2)
+  assert.ok(collector.status().log.every((entry) => entry.kind === 'record' && typeof entry.time === 'number'))
   assert.equal(store.samples.length, 0)
 })
 
@@ -362,6 +429,28 @@ test('回扫:无边界会话全量重放,归因与游标写回', async () => {
   assert.equal(collector.status().scannedSessions, 1)
 })
 
+test('回扫:重放路径同样附加 durationMs', async () => {
+  const start = local(2026, 8, 2, 14, 0)
+  const persistence = fakePersistence([{
+    id: 's1',
+    events: [
+      ev('request/context', 0, start, { provider: 'deepseek', model: 'chat' }),
+      ev('step/start', 1, start, { turn: 0, step: 0 }),
+      ev('assistant/message', 2, start + 7 * 1000, {
+        turn: 0,
+        step: 0,
+        usage: usage(),
+        message: { source: { provider: 'deepseek', model: 'chat' } },
+      }),
+    ],
+  }])
+  const store = fakeStore()
+  const collector = new UsageCollector(fakeCtx({ persistence }), store)
+  await collector.backfill(persistence, fakeSessions())
+  const usageSample = store.samples.find((sample) => !sample.request)
+  assert.equal(usageSample.durationMs, 7000)
+})
+
 test('回扫:已入游标会话不再重扫', async () => {
   const t = local(2026, 8, 2, 14, 0)
   const persistence = fakePersistence([{ id: 's1', events: [ev('turn/end', 0, t)] }])
@@ -473,6 +562,9 @@ test('回扫:单会话失败不中断整轮且不进游标', async () => {
   assert.equal(collector.status().error, undefined)
   assert.equal(collector.status().skippedSessions, 1)
   assert.equal(collector.status().done, 2)
+  assert.equal(collector.status().log.length, 1)
+  assert.equal(collector.status().log[0].kind, 'skipped')
+  assert.ok(collector.status().log[0].detail.startsWith('s2'))
 })
 
 test('回扫:record 失败使会话失败并保留游标重试机会', async () => {
@@ -590,6 +682,7 @@ test('status() 返回快照,外部修改不影响内部状态', async () => {
     error: undefined,
     recordFailures: 0,
     skippedSessions: 0,
+    log: [],
   })
   await collector.backfill(persistence, fakeSessions())
   const snapshot = collector.status()

package/test/pricing-parity.test.mjs

@@ -1,34 +1,28 @@
 // 双实现同源 parity 测试:client.js 顶层定价镜像函数与宿主 src/pricing.js 同输入同输出
 // 向量表驱动:同一批向量喂双侧,deepEqual 双侧结果并对期望值断言
-// client.js 为非模块 script(bundle 求值形态,禁 import/export),整源求值后按顶层声明名收集
+// client.js 为经典 script bundle(禁 import/export),整文件 IIFE 书挡;经 client-eval 剥壳后整源求值,按顶层声明名收集
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
+import { CLIENT_BODY, DECLARATION_NAMES } from './client-eval.mjs'
 
 import {
   matchPrice as hostMatchPrice,
   costOf as hostCostOf,
   conditionMatches as hostConditionMatches,
+  isTwoSegmentModel as hostIsTwoSegmentModel,
   UNIT_PER_MILLION as hostUnitPerMillion,
   CURRENCIES as hostCurrencies,
   CONDITION_KINDS as hostConditionKinds,
   TOKENS_PER_MILLION as hostTokensPerMillion,
 } from '../src/pricing.js'
 
-const CLIENT_SOURCE = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'client.js'), 'utf8')
-const DECLARATION_NAMES = [
-  ...new Set(
-    [...CLIENT_SOURCE.matchAll(/^(?:const|function|let) ([A-Za-z_$][\w$]*)/gm)].map((match) => match[1])
-  ),
-]
-const core = new Function(`${CLIENT_SOURCE}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
+const core = new Function(`${CLIENT_BODY}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
 
 const {
   matchPrice: clientMatchPrice,
   costOf: clientCostOf,
   conditionMatches: clientConditionMatches,
+  isTwoSegmentModel: clientIsTwoSegmentModel,
   UNIT_PER_MILLION: clientUnitPerMillion,
   CURRENCIES: clientCurrencies,
   CONDITION_KINDS: clientConditionKinds,
@@ -83,67 +77,112 @@ const MATCH_SUNDAY_1000 = [2026, 2, 15, 10, 0]
 
 const MATCH_VECTORS = [
   {
-    name: '精确命中按数组序取首个',
-    rules: [ruleOf('a', 1), ruleOf('b', 2)], model: 'b', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+    name: '全名精确命中按数组序取首个',
+    rules: [ruleOf('x/a', 1), ruleOf('x/b', 2)], model: 'x/b', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '同全名多条取数组序第一条',
+    rules: [ruleOf('x/a', 1), ruleOf('x/a', 3)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '模型名通配跨供应商命中',
+    rules: [ruleOf('*/a', 5)], model: 'zzz/a', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+  },
+  {
+    name: '供应商通配命中同供应商模型',
+    rules: [ruleOf('x/*', 5)], model: 'x/zzz', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+  },
+  {
+    name: '无精确回落全通配',
+    rules: [ruleOf('*/*', 5)], model: 'zzz/yyy', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+  },
+  {
+    name: '全名精确优先于全通配',
+    rules: [ruleOf('*/*', 5), ruleOf('x/a', 1)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '匹配链:模型名通配优先于供应商通配',
+    rules: [ruleOf('x/*', 3), ruleOf('*/a', 2)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '匹配链:供应商通配优先于全通配',
+    rules: [ruleOf('*/*', 4), ruleOf('x/*', 3)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(3),
   },
   {
-    name: '同 model 多条取数组序第一条',
-    rules: [ruleOf('a', 1), ruleOf('a', 3)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    name: '模型名段允许含斜杠',
+    rules: [ruleOf('x/*', 1)], model: 'x/deepseek/deepseek-chat', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
-    name: '无精确回落通配',
-    rules: [ruleOf('*', 5)], model: 'zzz', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+    name: '请求裸名归 default 供应商',
+    rules: [ruleOf('default/a', 1), ruleOf('*/a', 2)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
-    name: '精确优先于通配',
-    rules: [ruleOf('*', 5), ruleOf('a', 1)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    name: '请求首位斜杠不拆段归 default 供应商',
+    rules: [ruleOf('default//x', 1), ruleOf('*/x', 2)], model: '/x', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '单段旧形态规则失效',
+    rules: [ruleOf('*', 5), ruleOf('a', 1)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: '供应商段不同不命中',
+    rules: [ruleOf('x/*', 1)], model: 'y/a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: '模型段不同不命中',
+    rules: [ruleOf('*/a', 1)], model: 'x/b', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: '多条件 AND 全过命中',
-    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [0] }, { kind: 'dailyWindow', from: '00:00', to: '23:59' }])],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [0] }, { kind: 'dailyWindow', from: '00:00', to: '23:59' }])],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
     name: '一条件不过跳至下一条规则',
-    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [1] }]), ruleOf('a', 2, [])],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [1] }]), ruleOf('x/a', 2, [])],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '高档条件不过逐层落低档',
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [1] }]), ruleOf('*/a', 5)],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(5),
   },
   {
     name: '缺 conditions 形状残缺跳过',
-    rules: [{ model: 'a', currency: '¥', price: priceOf(1) }],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [{ model: 'x/a', currency: '¥', price: priceOf(1) }],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: '缺 price 形状残缺跳过',
-    rules: [{ model: 'a', currency: '¥', conditions: [] }],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [{ model: 'x/a', currency: '¥', conditions: [] }],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: 'unit 非 perMillion 跳过',
-    rules: [{ ...ruleOf('a', 1), unit: 'perThousand' }],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [{ ...ruleOf('x/a', 1), unit: 'perThousand' }],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: 'unit 缺省视为 perMillion 命中',
-    rules: [ruleOf('a', 1)],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    rules: [ruleOf('x/a', 1)],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
     name: 'rules 非数组为 null',
-    rules: 'nope', model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: 'nope', model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: 'model 非字符串为 null',
-    rules: [ruleOf('a', 1)], model: 7, date: MATCH_SUNDAY_1000, expected: null,
+    rules: [ruleOf('x/a', 1)], model: 7, date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: '非法时间戳为 null',
-    rules: [ruleOf('a', 1)], model: 'a', date: null, expected: null,
+    rules: [ruleOf('x/a', 1)], model: 'x/a', date: null, expected: null,
   },
   {
     name: '条件不满足且无通配为 null',
-    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [1] }])],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [1] }])],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
 ]
 
@@ -221,6 +260,30 @@ test(`matchPrice 双侧一致(${MATCH_VECTORS.length} 向量)`, () => {
   }
 })
 
+const SEGMENT_VECTORS = [
+  { name: '两段合法', model: 'a/b', expected: true },
+  { name: '通配段合法', model: '*/*', expected: true },
+  { name: '多级模型名合法', model: 'a/b/c', expected: true },
+  { name: '单段非法', model: 'a', expected: false },
+  { name: '通配单段非法', model: '*', expected: false },
+  { name: '首位斜杠非法', model: '/b', expected: false },
+  { name: '空串非法', model: '', expected: false },
+  { name: '模型段空非法', model: 'a/', expected: false },
+  { name: '段含前导空白非法', model: ' /b', expected: false },
+  { name: '段含尾随空白非法', model: 'a/ ', expected: false },
+  { name: '段内含空白非法', model: 'a /b', expected: false },
+  { name: '通配段含空白非法', model: '* /b', expected: false },
+]
+
+test(`isTwoSegmentModel 双侧一致(${SEGMENT_VECTORS.length} 向量)`, () => {
+  for (const vector of SEGMENT_VECTORS) {
+    const host = hostIsTwoSegmentModel(vector.model)
+    const client = clientIsTwoSegmentModel(vector.model)
+    assert.deepEqual(client, host, vector.name)
+    assert.equal(host, vector.expected, vector.name)
+  }
+})
+
 test(`costOf 双侧一致(${COST_VECTORS.length} 向量)`, () => {
   for (const vector of COST_VECTORS) {
     const host = hostCostOf(vector.price, vector.buckets)