@mzzsfy/dsh-usage-dash 0.1.0 → 0.2.0

package/test/pricing.test.mjs

@@ -8,6 +8,7 @@ import {
   UNIT_PER_MILLION,
   conditionMatches,
   costOf,
+  isTwoSegmentModel,
   matchPrice,
 } from '../src/pricing.js'
 
@@ -19,7 +20,7 @@ const SATURDAY = new Date(2026, 8, 12)
 const localTime = (day, hour, minute = 0) => new Date(2026, 8, day, hour, minute)
 
 const makeRule = (overrides = {}) => ({
-  model: '*',
+  model: '*/*',
   unit: UNIT_PER_MILLION,
   currency: '¥',
   price: { input: 1, output: 2, cacheRead: 0.5, cacheWrite: 1 },
@@ -53,9 +54,9 @@ test('无条件规则恒命中', () => {
 })
 
 test('精确模型优先于通配规则', () => {
-  // Given 精确规则与 '*' 规则并存 When 匹配 Then 取精确规则 price
+  // Given 精确规则与 '*/*' 规则并存 When 匹配 Then 取精确规则 price
   const exact = makeRule({ model: 'a/b', price: { input: 5 } })
-  const wildcard = makeRule({ model: '*', price: { input: 1 } })
+  const wildcard = makeRule({ model: '*/*', price: { input: 1 } })
   assert.deepEqual(matchPrice([wildcard, exact], 'a/b', SUNDAY), exact.price)
 })
 
@@ -67,25 +68,126 @@ test('精确子集按数组序取首个命中', () => {
 })
 
 test('精确子集全不命中回落通配子集', () => {
-  // Given 精确规则条件不满足、'*' 规则无条件 When 匹配 Then 回落 '*' 而非 null
+  // Given 精确规则条件不满足、'*/*' 规则无条件 When 匹配 Then 回落 '*/*' 而非 null
   const exact = makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [1] }] })
-  const wildcard = makeRule({ model: '*', price: { input: 3 } })
+  const wildcard = makeRule({ model: '*/*', price: { input: 3 } })
   assert.deepEqual(matchPrice([exact, wildcard], 'a/b', SUNDAY), wildcard.price)
 })
 
 test('通配子集按数组序取首个命中', () => {
-  // Given 首条 '*' 条件满足、次条无条件 When 匹配 Then 取首条
-  const first = makeRule({ model: '*', conditions: [{ kind: 'weekdays', days: [0] }], price: { input: 1 } })
-  const second = makeRule({ model: '*', price: { input: 2 } })
+  // Given 首条 '*/*' 条件满足、次条无条件 When 匹配 Then 取首条
+  const first = makeRule({ model: '*/*', conditions: [{ kind: 'weekdays', days: [0] }], price: { input: 1 } })
+  const second = makeRule({ model: '*/*', price: { input: 2 } })
   assert.deepEqual(matchPrice([first, second], 'a/b', SUNDAY), first.price)
 })
 
 test('无精确子集直接查通配子集', () => {
-  // Given 仅 '*' 规则 When 匹配未列出模型 Then 命中通配
-  const wildcard = makeRule({ model: '*', price: { input: 4 } })
+  // Given 仅 '*/*' 规则 When 匹配未列出模型 Then 命中通配
+  const wildcard = makeRule({ model: '*/*', price: { input: 4 } })
   assert.deepEqual(matchPrice([wildcard], 'other/c', SUNDAY), wildcard.price)
 })
 
+test('匹配链:全名优先于模型名、供应商、全通配', () => {
+  // Given 四档规则并存 When 匹配 Then 依次全名 > 模型名 > 供应商 > 全通配
+  const rules = [
+    makeRule({ model: 'x/*', price: { input: 3 } }),
+    makeRule({ model: '*/*', price: { input: 4 } }),
+    makeRule({ model: '*/a', price: { input: 2 } }),
+    makeRule({ model: 'x/a', price: { input: 1 } }),
+  ]
+  assert.deepEqual(matchPrice(rules, 'x/a', SUNDAY), { input: 1 })
+})
+
+test('匹配链:模型名通配优先于供应商通配', () => {
+  // Given '*/a' 与 'x/*' 并存 When 匹配 x/a Then 模型名精确档胜
+  const rules = [
+    makeRule({ model: 'x/*', price: { input: 3 } }),
+    makeRule({ model: '*/a', price: { input: 2 } }),
+  ]
+  assert.deepEqual(matchPrice(rules, 'x/a', SUNDAY), { input: 2 })
+})
+
+test('匹配链:供应商通配优先于全通配', () => {
+  // Given 'x/*' 与 '*/*' 并存 When 匹配 x/a Then 供应商精确档胜
+  const rules = [
+    makeRule({ model: '*/*', price: { input: 4 } }),
+    makeRule({ model: 'x/*', price: { input: 3 } }),
+  ]
+  assert.deepEqual(matchPrice(rules, 'x/a', SUNDAY), { input: 3 })
+})
+
+test('模型名通配跨供应商命中同模型名', () => {
+  // Given '*/gpt-4o' When 匹配不同供应商同模型名 Then 命中;模型名不同不命中
+  const rule = makeRule({ model: '*/gpt-4o', price: { input: 7 } })
+  assert.deepEqual(matchPrice([rule], 'openai/gpt-4o', SUNDAY), { input: 7 })
+  assert.deepEqual(matchPrice([rule], 'azure/gpt-4o', SUNDAY), { input: 7 })
+  assert.equal(matchPrice([rule], 'openai/gpt-4o-mini', SUNDAY), null)
+})
+
+test('供应商通配命中同供应商全部模型', () => {
+  // Given 'openai/*' When 匹配同供应商多模型 Then 命中;异供应商不命中
+  const rule = makeRule({ model: 'openai/*', price: { input: 6 } })
+  assert.deepEqual(matchPrice([rule], 'openai/gpt-4o', SUNDAY), { input: 6 })
+  assert.deepEqual(matchPrice([rule], 'openai/o3', SUNDAY), { input: 6 })
+  assert.equal(matchPrice([rule], 'azure/gpt-4o', SUNDAY), null)
+})
+
+test('模型名段允许含斜杠按首个斜杠分段', () => {
+  // Given vendor 段通配或精确 When 匹配模型名含斜杠的多级模型 Then 按 vendor/余段比对
+  const vendorWide = makeRule({ model: 'openrouter/*', price: { input: 8 } })
+  assert.deepEqual(matchPrice([vendorWide], 'openrouter/deepseek/deepseek-chat', SUNDAY), { input: 8 })
+  const named = makeRule({ model: '*/deepseek/deepseek-chat', price: { input: 9 } })
+  assert.deepEqual(matchPrice([named], 'openrouter/deepseek/deepseek-chat', SUNDAY), { input: 9 })
+  assert.equal(matchPrice([named], 'openrouter/deepseek/chat', SUNDAY), null)
+})
+
+test('单段规则属旧形态失效不命中', () => {
+  // Given 旧写法 '*' 与裸名规则 When 匹配 Then 一律 null
+  const legacy = makeRule({ model: '*', price: { input: 1 } })
+  const bare = makeRule({ model: 'a', price: { input: 2 } })
+  assert.equal(matchPrice([legacy, bare], 'a/b', SUNDAY), null)
+  assert.equal(matchPrice([legacy, bare], 'a', SUNDAY), null)
+})
+
+test('请求裸名模型归 default 供应商', () => {
+  // Given 无斜杠请求 When 匹配 'default/名' 与 '*/名' Then 全名档优先
+  const exact = makeRule({ model: 'default/abc', price: { input: 1 } })
+  const named = makeRule({ model: '*/abc', price: { input: 2 } })
+  assert.deepEqual(matchPrice([named, exact], 'abc', SUNDAY), { input: 1 })
+  assert.deepEqual(matchPrice([named], 'abc', SUNDAY), { input: 2 })
+})
+
+test('档位回落:高档条件不满足逐层落低档', () => {
+  // Given 全名与模型名档条件仅周一 When 周日匹配 Then 落到无条件的供应商档
+  const exact = makeRule({ model: 'x/a', conditions: [{ kind: 'weekdays', days: [1] }], price: { input: 1 } })
+  const modelName = makeRule({ model: '*/a', conditions: [{ kind: 'weekdays', days: [1] }], price: { input: 2 } })
+  const vendor = makeRule({ model: 'x/*', price: { input: 3 } })
+  assert.deepEqual(matchPrice([exact, modelName, vendor], 'x/a', SUNDAY), { input: 3 })
+})
+
+test('同档规则按数组序取首个条件满足者', () => {
+  // Given 同为 '*/a' 两条,首条条件周日 When 周日匹配 Then 取首条
+  const first = makeRule({ model: '*/a', price: { input: 1 }, conditions: [{ kind: 'weekdays', days: [0] }] })
+  const second = makeRule({ model: '*/a', price: { input: 2 } })
+  assert.deepEqual(matchPrice([first, second], 'x/a', SUNDAY), { input: 1 })
+})
+
+test('isTwoSegmentModel 判定提交形态两段式', () => {
+  // Given 两段式与单段/空白段串 When 判定 Then 首斜杠在首位之后且两段无空白才成立
+  assert.equal(isTwoSegmentModel('a/b'), true)
+  assert.equal(isTwoSegmentModel('*/*'), true)
+  assert.equal(isTwoSegmentModel('a/b/c'), true)
+  assert.equal(isTwoSegmentModel('a'), false)
+  assert.equal(isTwoSegmentModel('*'), false)
+  assert.equal(isTwoSegmentModel('/b'), false)
+  assert.equal(isTwoSegmentModel(''), false)
+  assert.equal(isTwoSegmentModel('a/'), false)
+  assert.equal(isTwoSegmentModel(' /b'), false)
+  assert.equal(isTwoSegmentModel('a/ '), false)
+  assert.equal(isTwoSegmentModel('a /b'), false)
+  assert.equal(isTwoSegmentModel('* /b'), false)
+})
+
 test('两子集全不命中返回 null 计 unpriced', () => {
   // Given 仅一条精确规则且条件不满足 When 匹配本模型与陌生模型 Then 均为 null
   const rules = [makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [1] }] })]

package/test/query.test.mjs

@@ -257,7 +257,7 @@ test('H 粒度槽数恰为 MAX_SLOTS 时不出现 truncated', () => {
 // ---- attachCosts 聚合计价:计价唯一以 H 桶起点匹配,费用精度=小时级 ----
 
 const ruleOf = (overrides = {}) => ({
-  model: '*',
+  model: '*/*',
   currency: '¥',
   price: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
   conditions: [],
@@ -266,12 +266,42 @@ const ruleOf = (overrides = {}) => ({
 
 const inputPrice = (input) => ({ input, output: 0, cacheRead: 0, cacheWrite: 0 })
 
+test('speed 配对聚合:仅 durationMs>0 行计入分子分母,老行只进 tokens', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', inputTokens: 5, outputTokens: 20, durationMs: 6500 }),
+    makeRow({ bucket: '2020-01-02', model: 'm1', provider: 'p1', outputTokens: 30, durationMs: 2500 }),
+    // 存量旧格式行:无 durationMs,token 计入总量但速度分母不含
+    makeRow({ bucket: '2020-01-03', model: 'm1', provider: 'p1', outputTokens: 100 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-03')
+  const entry = out.models.find((item) => item.model === 'm1')
+  assert.equal(entry.tokens, 25 + 30 + 100)
+  assert.equal(entry.speed, (20 + 30) / ((6500 + 2500) / 1000))
+})
+
+test('无 durationMs 数据时 models 条目无 speed 字段', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', outputTokens: 30 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-01')
+  assert.equal(out.models.length, 1)
+  assert.equal('speed' in out.models[0], false)
+})
+
+test('纯缓存行带时长:输出 0 计入分母,speed 为 0', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', cacheReadTokens: 10, outputTokens: 0, durationMs: 4000 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-01')
+  assert.equal(out.models[0].speed, 0)
+})
+
 test('attachCosts H 槽按桶起点计价并归集 totals 与 models', () => {
   const rows = [
     makeRow({ bucket: '2020-01-01T01', model: 'm1', provider: 'p1', inputTokens: 1000000, outputTokens: 500000 }),
   ]
   const result = aggregateRange(rows, 'H', '2020-01-01T00', '2020-01-01T02')
-  const out = attachCosts(result, rows, 'H', [ruleOf({ model: 'm1', price: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 } })])
+  const out = attachCosts(result, rows, 'H', [ruleOf({ model: 'default/m1', price: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 } })])
   assert.equal(out.daily[1].cost, 2)
   assert.equal(out.cost, 2)
   assert.equal(out.unpriced, 0)
@@ -289,7 +319,7 @@ test('attachCosts 多行同桶多规则累加且残缺规则跳过后回落通
     makeRow({ bucket: '2020-01-01T01', model: 'm2', inputTokens: 1000000 }),
   ]
   const rules = [
-    ruleOf({ model: 'm1', price: inputPrice(1) }),
+    ruleOf({ model: 'default/m1', price: inputPrice(1) }),
     { model: 'm2' },
     ruleOf({ price: inputPrice(3) }),
   ]

package/test/routes.test.mjs

@@ -6,7 +6,7 @@ import assert from 'node:assert/strict'
 import { Readable } from 'node:stream'
 
 import { MAX_RANGE_SPAN_DAYS, registerUsageRoutes } from '../src/routes.js'
-import { DEFAULT_MINUTE_RETENTION_DAYS, minuteKey } from '../src/store.js'
+import { DEFAULT_MINUTE_RETENTION_DAYS, hourKey, minuteKey } from '../src/store.js'
 
 const DAY_MS = 24 * 60 * 60 * 1000
 const MINUTE_MS = 60 * 1000
@@ -338,8 +338,9 @@ test('minutes 禁用保留时标注空 covered', async () => {
 
 test('minutes from 未对齐 10 分钟桶边界拒绝 400', async () => {
   const { routes } = mount()
-  const d = new Date(FIXED_NOW)
-  const unaligned = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}T12:07`
+  // from 由 hourKey 本地渲染保证与 to 同一时区基准,前一小时的 :07 早于 to 且未对齐;
+  // 前提是 FIXED_NOW 不落入 DST 回拨小时(当前 2 月常量全球无转变日)
+  const unaligned = `${hourKey(FIXED_NOW - 60 * MINUTE_MS)}:07`
   const res = await invokeJson(routes, PATH_MINUTES, { payload: { from: unaligned, to: minuteKey(FIXED_NOW) } })
   const parsed = JSON.parse(res.body)
   assert.equal(res.statusCode, 400)
@@ -349,12 +350,12 @@ test('minutes from 未对齐 10 分钟桶边界拒绝 400', async () => {
 
 test('minutes 保留值超上限时 covered 窗口按 clamp 计算', async () => {
   const { routes } = mount({ retentionDays: () => 30 })
-  const from = minuteKey(FIXED_NOW - 3 * DAY_MS)
+  const from = minuteKey(FIXED_NOW - 8 * DAY_MS)
   const to = minuteKey(FIXED_NOW)
   const res = await invokeJson(routes, PATH_MINUTES, { payload: { from, to } })
   const parsed = JSON.parse(res.body)
   assert.equal(res.statusCode, 200)
-  assert.equal(parsed.value.coveredFrom, minuteKey(FIXED_NOW - 2 * DAY_MS))
+  assert.equal(parsed.value.coveredFrom, minuteKey(FIXED_NOW - 7 * DAY_MS))
   assert.equal(parsed.value.coveredTo, to)
 })
 
@@ -382,14 +383,14 @@ test('内部错误 500 不回显内部文本', async () => {
 // ---- S13 pricing 端点与 cost 集成 ----
 
 const PRICING_RULE = {
-  model: 'deepseek-chat',
+  model: 'deepseek/deepseek-chat',
   currency: '¥',
   price: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
   conditions: [{ kind: 'dailyWindow', from: '09:00', to: '18:00' }],
 }
 
 const ruleWithInputPrice = (input) => ({
-  model: 'deepseek-chat',
+  model: 'default/deepseek-chat',
   currency: '¥',
   price: { input, output: 0, cacheRead: 0, cacheWrite: 0 },
   conditions: [],
@@ -438,6 +439,9 @@ test('pricing POST 非法规则拒绝 400 且不写入', async () => {
     { rules: 'x' },
     {},
     { rules: [{ model: 1, currency: '¥', price: PRICING_RULE.price, conditions: [] }] },
+    { rules: [{ ...PRICING_RULE, model: 'deepseek-chat' }] },
+    { rules: [{ ...PRICING_RULE, model: '*' }] },
+    { rules: [{ ...PRICING_RULE, model: '/deepseek-chat' }] },
     { rules: [{ ...PRICING_RULE, price: { input: -1, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
     { rules: [{ ...PRICING_RULE, conditions: [{ kind: 'unknown' }] }] },
     { rules: [{ ...PRICING_RULE, conditions: [{ kind: 'weekdays', days: [7] }] }] },

package/test/stats-line.test.mjs

@@ -1,19 +1,11 @@
 // 底部信息栏增强纯函数层测试:官方 StatsLine 口径(dsh-client-ui-chat 同构)+ usp 双开关状态
 // 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'
-
-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(', ')} }`)()
+import { CLIENT_BODY, DECLARATION_NAMES } from './client-eval.mjs'
+
+const core = new Function(`${CLIENT_BODY}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
 
 const {
   STATS_LINE_STORAGE_KEY,
@@ -43,11 +35,11 @@ const PREFS_COST_ON = { cachePrecision: false, tokenDetail: false, costDisplay:
 const zhT = createTranslator(MESSAGES_ZH)
 const enT = createTranslator(MESSAGES_EN)
 
-// 费用组装配输入:精确规则在前、通配规则兜底,通配仅全天时段生效
+// 费用组装配输入:精确规则在前、全通配规则兜底,通配仅全天时段生效
 const COST_RULES = [
   { model: 'p/m', currency: '¥', price: { input: 2, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
   {
-    model: '*', currency: '', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 },
+    model: '*/*', currency: '', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 },
     conditions: [{ kind: 'dailyWindow', from: '00:00', to: '00:00' }],
   },
 ]
@@ -353,8 +345,8 @@ test('buildCostItem 开关关恒为 null,组数组不受 rules 影响', () => {
   ])
 })
 
-test('buildCostItem routes 缺席按通配规则匹配,符号取全局口径(首个非空货币)', () => {
-  // 无 routes → model '*',500000 × 1 / 每百万 = 0.5;命中通配(货币空),符号取表内首个非空 ¥
+test('buildCostItem routes 缺席按全通配规则匹配,符号取全局口径(首个非空货币)', () => {
+  // 无 routes → model '*/*',500000 × 1 / 每百万 = 0.5;命中全通配(货币空),符号取表内首个非空 ¥
   assert.equal(buildCostItem(COST_USAGE, COST_RULES, PREFS_COST_ON, zhT, COST_NOW), '费用 ≈ ¥0.50')
   assert.equal(buildCostItem(COST_USAGE, COST_RULES, PREFS_COST_ON, enT, COST_NOW), 'Cost ≈ ¥0.50')
 })

package/test/store.test.mjs

@@ -94,17 +94,17 @@ const tokenSample = (time, extra = {}) => ({
 })
 
 test('分钟保留天数默认常量与上限和计划一致', () => {
-  assert.equal(DEFAULT_MINUTE_RETENTION_DAYS, 2)
-  assert.equal(MINUTE_RETENTION_MAX_DAYS, 2)
+  assert.equal(DEFAULT_MINUTE_RETENTION_DAYS, 7)
+  assert.equal(MINUTE_RETENTION_MAX_DAYS, 7)
   assert.equal(HOUR_RETENTION_DAYS, 15)
 })
 
 test('分钟保留值归一:非法回落默认,超上限截断,0 保留', () => {
   assert.equal(clampMinuteRetentionDays(1), 1)
   assert.equal(clampMinuteRetentionDays(0), 0)
-  assert.equal(clampMinuteRetentionDays(7), 2)
-  assert.equal(clampMinuteRetentionDays(-1), 2)
-  assert.equal(clampMinuteRetentionDays('x'), 2)
+  assert.equal(clampMinuteRetentionDays(30), 7)
+  assert.equal(clampMinuteRetentionDays(-1), 7)
+  assert.equal(clampMinuteRetentionDays('x'), 7)
 })
 
 test('桶键生成含补零,分钟桶对齐 10 分钟', () => {
@@ -134,6 +134,7 @@ test('token 样本同刻落三粒度三行,行内无 g 字段', async () => {
   const domain = fakeDomain()
   const store = new UsageStore(facilityOf(domain))
   await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  await store.flushNow()
   const keys = ['D|2026-08-02', 'H|2026-08-02T14', 'M|2026-08-02T14:30'].map(
     (prefix) => `${prefix}|deepseek|deepseek/deepseek-chat`,
   )
@@ -155,6 +156,7 @@ test('turn 样本落合成行:provider default 与 model (turns)', async () => {
   const domain = fakeDomain()
   const store = new UsageStore(facilityOf(domain))
   await store.record({ time: local(2026, 8, 2, 14, 37), turn: true })
+  await store.flushNow()
   const seen = domain.rows.get('D|2026-08-02|default|(turns)')
   assert.ok(seen)
   assert.equal(seen.turns, 1)
@@ -166,6 +168,7 @@ test('request 样本只计请求数,无归因落 (unknown)', async () => {
   const store = new UsageStore(facilityOf(domain))
   await store.record({ time: local(2026, 8, 2, 14, 37), request: true, model: 'deepseek-chat' })
   await store.record({ time: local(2026, 8, 2, 14, 38), request: true })
+  await store.flushNow()
   const labelled = domain.rows.get('D|2026-08-02|default|deepseek-chat')
   assert.ok(labelled)
   assert.equal(labelled.requests, 1)
@@ -175,27 +178,78 @@ test('request 样本只计请求数,无归因落 (unknown)', async () => {
   assert.equal(unknown.requests, 1)
 })
 
+test('token 样本时长落三粒度累加,request 与 turn 行时长恒 0', async () => {
+  const domain = fakeDomain()
+  const store = new UsageStore(facilityOf(domain))
+  const at = local(2026, 8, 2, 14, 37)
+  await store.record(tokenSample(at, { durationMs: 6500 }))
+  await store.record(tokenSample(at + 1000, { durationMs: 2500 }))
+  await store.record({ time: at, request: true, model: 'deepseek/deepseek-chat' })
+  await store.record({ time: at, turn: true })
+  await store.flushNow()
+  const daily = domain.rows.get('D|2026-08-02|deepseek|deepseek/deepseek-chat')
+  assert.equal(daily.outputTokens, 40)
+  assert.equal(daily.durationMs, 9000)
+  const hourly = domain.rows.get('H|2026-08-02T14|deepseek|deepseek/deepseek-chat')
+  assert.equal(hourly.durationMs, 9000)
+  const minute = domain.rows.get('M|2026-08-02T14:30|deepseek|deepseek/deepseek-chat')
+  assert.equal(minute.durationMs, 9000)
+  const requestRow = domain.rows.get('D|2026-08-02|deepseek|deepseek/deepseek-chat')
+  assert.equal(requestRow.requests, 1)
+  const turnRow = domain.rows.get('D|2026-08-02|default|(turns)')
+  assert.equal(turnRow.durationMs, 0)
+})
+
+test('老行缺 durationMs 字段:增量求和不产 NaN', async () => {
+  const domain = fakeDomain()
+  const store = new UsageStore(facilityOf(domain))
+  const at = local(2026, 8, 2, 14, 37)
+  const key = 'D|2026-08-02|deepseek|deepseek/deepseek-chat'
+  await store.record(tokenSample(at))
+  await store.flushNow()
+  // 模拟存量旧格式行:回写去掉 durationMs 字段
+  const stored = domain.rows.get(key)
+  delete stored.durationMs
+  await store.record(tokenSample(at + 1000, { durationMs: 3000 }))
+  await store.flushNow()
+  const seen = domain.rows.get(key)
+  assert.equal(seen.durationMs, 3000)
+  assert.equal(seen.outputTokens, 40)
+})
+
 test('missing-record 首写竞态:put 种子后重试写入真值', async () => {
   const domain = fakeDomain()
   const store = new UsageStore(facilityOf(domain))
   await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  await store.flushNow()
   assert.equal(domain.stats.puts, 3)
   const seen = domain.rows.get('D|2026-08-02|deepseek|deepseek/deepseek-chat')
   assert.equal(seen.inputTokens, 10)
 })
 
-test('allSettled 聚合:单粒度失败上抛且其余粒度不丢', async () => {
+test('flush 中单粒度失败:错误经 onFlushError 上抛,失败行留 pending 重试,成功粒度落盘', async () => {
+  const failedKeys = new Set()
   const domain = fakeDomain({
-    failUpdate: (key) => (key.startsWith('H|') ? new Error('simulated hour failure') : null),
+    failUpdate: (key) => {
+      if (!key.startsWith('H|') || failedKeys.has(key)) return null
+      failedKeys.add(key)
+      return new Error('simulated hour failure')
+    },
   })
   const store = new UsageStore(facilityOf(domain))
-  await assert.rejects(
-    store.record(tokenSample(local(2026, 8, 2, 14, 37))),
-    (err) => err.name === 'AggregateError' && err.errors.length === 1,
-  )
+  const errors = []
+  store.onFlushError = (err) => errors.push(err)
+  await store.readyPromise()
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  await store.flushNow()
   assert.ok(domain.rows.has('D|2026-08-02|deepseek|deepseek/deepseek-chat'))
   assert.ok(domain.rows.has('M|2026-08-02T14:30|deepseek|deepseek/deepseek-chat'))
   assert.equal(domain.rows.has('H|2026-08-02T14|deepseek|deepseek/deepseek-chat'), false)
+  assert.equal(errors.length, 1)
+  assert.equal(errors[0].name, 'AggregateError')
+  assert.equal(errors[0].errors.length, 1)
+  await store.flushNow()
+  assert.ok(domain.rows.has('H|2026-08-02T14|deepseek|deepseek/deepseek-chat'))
 })
 
 test('非 missing 错误不触发种子重试', async () => {
@@ -204,11 +258,15 @@ test('非 missing 错误不触发种子重试', async () => {
     failUpdate: (candidate) => (candidate === key ? new Error('backend write failed') : null),
   })
   const store = new UsageStore(facilityOf(domain))
-  await assert.rejects(
-    store.record(tokenSample(local(2026, 8, 2, 14, 37))),
-    (err) => err.name === 'AggregateError' && /backend write failed/.test(err.errors[0].message),
-  )
+  const errors = []
+  store.onFlushError = (err) => errors.push(err)
+  await store.readyPromise()
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  await store.flushNow()
   assert.equal(domain.rows.has(key), false)
+  assert.equal(errors.length, 1)
+  assert.match(errors[0].errors[0].message, /backend write failed/)
+  assert.equal(domain.stats.puts, 2)
 })
 
 test('rangeRows 按粒度前缀与桶串闭区间扫描', async () => {
@@ -256,16 +314,16 @@ test('保留窗口为 0 时分钟桶全部清理', async () => {
   assert.equal(domain.rows.has('D|2026-08-10|a|m'), true)
 })
 
-test('分钟保留超上限时 clamp 到 48h 窗口', async () => {
+test('分钟保留超上限时 clamp 到 7 天窗口', async () => {
   const domain = fakeDomain()
   const store = new UsageStore(facilityOf(domain), { now: () => local(2026, 8, 10, 12, 0) })
   const table = domain.table()
-  // clamp 后窗口起点 = 08-08T12:00,02 天前的桶一律清理,即使注入 30 天
-  await table.put('M|2026-08-05T00:00|a|m', rowOf('2026-08-05T00:00', 'a', 'm'))
-  await table.put('M|2026-08-08T12:00|a|m', rowOf('2026-08-08T12:00', 'a', 'm'))
+  // clamp 后窗口起点 = 08-03T12:00,7 天前的桶一律清理,即使注入 30 天
+  await table.put('M|2026-08-01T00:00|a|m', rowOf('2026-08-01T00:00', 'a', 'm'))
+  await table.put('M|2026-08-03T12:00|a|m', rowOf('2026-08-03T12:00', 'a', 'm'))
   await store.pruneMinutes(30)
-  assert.equal(domain.rows.has('M|2026-08-05T00:00|a|m'), false)
-  assert.equal(domain.rows.has('M|2026-08-08T12:00|a|m'), true)
+  assert.equal(domain.rows.has('M|2026-08-01T00:00|a|m'), false)
+  assert.equal(domain.rows.has('M|2026-08-03T12:00|a|m'), true)
 })
 
 test('pruneHours 固定 15 天窗口清理小时桶且不碰其他粒度', async () => {
@@ -283,19 +341,22 @@ test('pruneHours 固定 15 天窗口清理小时桶且不碰其他粒度', async
   assert.equal(domain.rows.has('M|2026-07-25T00:00|a|m'), true)
 })
 
-test('每日本地日首次写入触发清理,同日后续写入不重复触发', async () => {
+test('每日本地日首次 flush 触发清理,同日后续 flush 不重复触发', async () => {
   let clock = local(2026, 8, 10, 12, 0)
   const domain = fakeDomain()
   const store = new UsageStore(facilityOf(domain), { now: () => clock, retentionDays: () => 0 })
   const table = domain.table()
   await table.put('M|2026-08-01T00:00|a|m', rowOf('2026-08-01T00:00', 'a', 'm'))
   await store.record(tokenSample(local(2026, 8, 10, 12, 0)))
+  await store.flushNow()
   assert.equal(domain.rows.has('M|2026-08-01T00:00|a|m'), false)
   await table.put('M|2026-08-01T00:00|a|m', rowOf('2026-08-01T00:00', 'a', 'm'))
   await store.record(tokenSample(local(2026, 8, 10, 12, 1)))
+  await store.flushNow()
   assert.equal(domain.rows.has('M|2026-08-01T00:00|a|m'), true)
   clock = local(2026, 8, 11, 0, 0)
   await store.record(tokenSample(local(2026, 8, 11, 0, 0)))
+  await store.flushNow()
   assert.equal(domain.rows.has('M|2026-08-01T00:00|a|m'), false)
 })
 
@@ -395,3 +456,65 @@ test('globalThis 单例复用同实例,重置缝生效', () => {
   assert.notEqual(sharedStore(facilityOf(fakeDomain())), first)
   __resetSharedStoreForTests()
 })
+
+// —— 写合并(write-behind):record 同步入 pending,flush 周期落盘 ——
+
+test('record 只入 pending 不产生持久化写,flushNow 后每脏行恰一次 update', async () => {
+  const domain = fakeDomain()
+  const store = new UsageStore(facilityOf(domain))
+  await store.readyPromise()
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  assert.equal(domain.rows.size, 0)
+  await store.flushNow()
+  assert.equal(domain.rows.size, 3)
+  const seen = domain.rows.get('D|2026-08-02|deepseek|deepseek/deepseek-chat')
+  assert.equal(seen.inputTokens, 10)
+})
+
+test('同桶多样本合并:pending 累加,一次 update 落全部计数', async () => {
+  const domain = fakeDomain()
+  const store = new UsageStore(facilityOf(domain))
+  await store.readyPromise()
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  await store.record(tokenSample(local(2026, 8, 2, 14, 38)))
+  await store.record(tokenSample(local(2026, 8, 2, 14, 39)))
+  await store.flushNow()
+  const seen = domain.rows.get('D|2026-08-02|deepseek|deepseek/deepseek-chat')
+  assert.equal(seen.inputTokens, 30)
+  assert.equal(domain.stats.puts, 3)
+})
+
+test('flush 周期自动落盘', async () => {
+  const domain = fakeDomain()
+  const store = new UsageStore(facilityOf(domain), { flushIntervalMs: 5 })
+  await store.readyPromise()
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  await new Promise((resolve) => setTimeout(resolve, 30))
+  assert.equal(domain.rows.size, 3)
+})
+
+test('rangeRows 前自动 flush,读己之写', async () => {
+  const domain = fakeDomain()
+  const store = new UsageStore(facilityOf(domain))
+  await store.readyPromise()
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  const rows = await store.rangeRows('D', '2026-08-02', '2026-08-02')
+  assert.equal(rows.length, 1)
+  assert.equal(rows[0].inputTokens, 10)
+})
+
+test('reset 前 pending 先落盘再清表', async () => {
+  const domain = fakeDomain()
+  const store = new UsageStore(facilityOf(domain))
+  await store.readyPromise()
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  await store.reset(new Map())
+  assert.equal(domain.rows.size, 0)
+  assert.equal(domain.stats.puts, 3)
+})
+
+test('降级态 record 仍按调用失败', async () => {
+  const store = new UsageStore({ open: () => Promise.reject(new Error('domain already open')) })
+  await store.readyPromise()
+  await assert.rejects(store.record(tokenSample(local(2026, 8, 2, 14, 37))), /usage store degraded/)
+})

package/test/turn-tail.test.mjs

@@ -1,23 +1,15 @@
 // 注入点B(S15)纯函数层测试:select 矩阵/模型键回退/单轮行文本/title 口径/文案键/显隐 CSS 镜像
-// 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'
-
-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(', ')} }`)()
+import { CLIENT_SOURCE, CLIENT_BODY, DECLARATION_NAMES } from './client-eval.mjs'
+
+const core = new Function(`${CLIENT_BODY}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
 
 const {
   MESSAGES_EN,
   MESSAGES_ZH,
-  MODEL_WILDCARD,
+  MODEL_UNROUTED,
   TURN_TAIL_DATA_KEY,
   TURN_TAIL_PRIORITY,
   buildTurnCostLine,
@@ -58,20 +50,20 @@ test('select owner 形状残缺全部 null 不抛', () => {
   assert.equal(selectTurnTokenUsage(undefined), null)
 })
 
-test('计价模型键取 routes 首个,缺失回退通配', () => {
+test('计价模型键取 routes 首个,缺失回退全通配键', () => {
   assert.equal(turnModelOf({ routes: [{ provider: 'p', model: 'p/m' }] }), 'p/m')
-  assert.equal(turnModelOf({ routes: [] }), MODEL_WILDCARD)
-  assert.equal(turnModelOf({}), MODEL_WILDCARD)
-  assert.equal(turnModelOf(null), MODEL_WILDCARD)
+  assert.equal(turnModelOf({ routes: [] }), MODEL_UNROUTED)
+  assert.equal(turnModelOf({}), MODEL_UNROUTED)
+  assert.equal(turnModelOf(null), MODEL_UNROUTED)
 })
 
-test('routes 缺失模型键命中通配规则', () => {
+test('routes 缺失模型键命中全通配规则', () => {
   const rules = [
     { model: 'p/m', currency: '¥', price: { input: 9, output: 9, cacheRead: 9, cacheWrite: 9 }, conditions: [] },
-    { model: MODEL_WILDCARD, currency: '$', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
+    { model: '*/*', currency: '$', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
   ]
   const tokenUsage = { uncachedInputTokens: 1000, outputTokens: 0, totalTokens: 1000 }
-  assert.equal(turnModelOf(tokenUsage), MODEL_WILDCARD)
+  assert.equal(turnModelOf(tokenUsage), MODEL_UNROUTED)
   assert.deepEqual(matchPrice(rules, turnModelOf(tokenUsage), NOW), { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 })
 })