@mzzsfy/dsh-usage-dash 0.7.1 → 0.9.0

package/README.md

@@ -8,11 +8,11 @@
 
 - 三粒度视图,全部支持自定义时间范围:天(7/30/90 天/自定义日期段)、小时(24 小时/3 天/7 天/15 天/自定义时刻段)、分钟(3 小时/24 小时/3 天/7 天/自定义时刻段,10 分钟桶粒度),预设挡为滚动窗口;自定义时刻段为起止 datetime 双输入,两端归一到桶边界(小时取所在整点、分钟起点对齐 10 分钟且终点保留原分钟,均闭区间),跨度上限与数据保留期一致(小时 15 天、分钟 7 天,超限自动钳起点),首次切到自定义挡预填最近 24 小时,时/分两视图共享同一对自定义输入;已知限制:自定义输入残缺(任一端为空)时面板不发请求且图表静默空白,与天视图行为一致,交互反馈留待后续增强
 - 汇总卡六张:Tokens 用量(服务商总口径)、会话数量、请求数量、最常用模型、平均缓存命中率、活跃天数(恒按天口径,不随视图切换);配置定价规则后 Tokens 卡头部行右侧显示估算费用
-- 活动热力图:GitHub 风格周列×星期行,26 周窗口,五档色阶,悬停明细;仅按天视图展示
+- 活动热力图:GitHub 风格周列×星期行,26 周窗口,五档色阶,悬停明细(配置定价规则后附「费用 ≈」估算行,受「费用显示」开关;费用数据依赖小时桶保留期,仅最近 15 天的天显示,更早的天无该行);仅按天视图展示
 - 缓存命中率曲线:日粒度命中率 + 右侧副轴,并叠加平均生成速度曲线与首 token 延迟曲线(各自单独颜色,读数走悬停;仅含配对数据的槽参与,整图无数据不绘制),悬停显示当前时段命中率、平均生成速度、首 token 延迟与 token 明细(配置定价规则后附当前时段估算费用行,受「费用显示」开关;三粒度趋势图通用)
 - 模型 donut 与列表:按 token 前 5 模型占比环形图(中心为总量);每行名称两行展示(厂商/模型名,其余折叠为「其他」),右侧三排:第一排 token 数·占比,第二排输入输出占比构成(缓存/输入/输出 三段各占该模型 token 总量,缓存=读+写,三段合计 100%,无四桶数据不显示),第三排估算费用·TTFT·生成速度(费用需配置定价规则,TTFT/速度无配对数据不显示),悬停明细含输入/缓存读/缓存写/输出四桶 token 拆分并联动
-- 三粒度堆叠柱状趋势图(数据量大时裁最旧并提示);图例可点击切换显隐:点击单选(仅显示该项,左轴刻度按可见项归一)/再点恢复全部,Ctrl+点击多选,隐藏最后一项无效;悬停明细按当前时段数据展示,零用量模型不显示,全零时段不显示悬浮框
-- 回扫状态行默认隐藏:首次启用自动回扫历史会话,运行中显示进度(常显);右上角为折叠箭头与刷新图标,折叠层内展开扫描异常日志块(逐条:时间/类型/明细,计数即明细条数,上限 200 条超限丢最旧,重建时清空)与「重建」入口(二次确认 3 秒后清库重扫),采集错误常显;工具栏分主区与右侧操作区,窄宽度时挡位组在主区内换行
+- 三粒度堆叠柱状趋势图(数据量大时裁最旧并提示);节头「金额」开关把柱状图从 token 消耗切到金额消耗——柱按模型堆叠估算费用,标题与左轴同步切金额读数(悬停明细保持 token 口径与估算费用行不变,命中率/速度/首 token 延迟曲线不受影响),三粒度通用;开关仅在存在正计价数据时显示(未配置规则或全量未计价时不渲染,避免全零金额柱误导);图例可点击切换显隐:点击单选(仅显示该项,左轴刻度按可见项归一)/再点恢复全部,Ctrl+点击多选,隐藏最后一项无效;悬停明细按当前时段数据展示,零用量模型不显示,全零时段不显示悬浮框
+- 回扫状态行默认隐藏:首次启用自动回扫历史会话,运行中显示进度(常显);右上角为折叠箭头与刷新图标,折叠层内展开扫描异常日志块(逐条:时间/类型/明细,计数即明细条数,上限 200 条超限丢最旧,重建时清空)与「重建」入口(二次确认 3 秒后清库重扫),采集错误常显;折叠且有待读信息(异常日志或写入失败)时箭头带红点提醒,展开后消失;工具栏分主区与右侧操作区,窄宽度时挡位组在主区内换行
 - 会话底栏接管:替换官方信息行为增强版,偏好卡三个开关默认全开——精确缓存命中率(两位小数)、会话 Token 明细(总/命中缓存/未命中缓存/输出)、费用显示(底栏费用项、趋势 tooltip 费用行与回合费用芯片);三开关全关时与官方逐字节一致
 - 回合费用芯片:经官方 `conversation.chat.assistant-actions` 槽注入动作行(复制与分支图标之间,官方赞/踩与上下文跳转同排),每轮对话结束后显示该轮估算费用(悬停 title 带 token 摘要与估算口径;显隐节奏随官方动作行——最新一轮常显,历史轮悬停显现;受「费用显示」开关;官方用量芯片弹窗已有 token 明细,芯片只承载费用)。旧宿主无该插槽时告警禁用
 - 定价规则编辑器:设置面板内按**模型分组**编辑,组头 = 模型键(整组一次改名,改后即时重新聚合)+ 删除整组;组内 = **默认价**槽(价格四桶,不设条件——附加规则全不命中时兜底,禁排序/删除)+ **附加计费规则**列表(四桶单价 + 条件组合,「+添加条件」追加条件行,行内下拉切换类型,规则带 ↑/↓ 调序与删除),「添加额外计费规则」追加一条(默认带全天时段条件);货币为全局切换(「定价规则」标题右侧,仅 ¥/$ 两档,整表统一),显式「保存」整表写入
@@ -36,7 +36,7 @@
   - `weekdays`:`{ days: [0-6] }` 星期几(集合,非范围),0=周日,空数组不成立;编辑器为日~六七枚 pill 多选
   - `monthDays`:`{ from, to }` 月内号段双侧包含整数(1-31),from>to 跨月环绕(账单周期),from===to 单日(如 5~5 即 5 号);2 月无 31 号自然不触发
   - `dateRange`:`{ from: 'YYYY-MM-DD', to: 'YYYY-MM-DD' }` 零填充字典序双侧包含,from===to 单日,from>to 倒序不成立(不可保存)
-- 费用精度:**小时级**——聚合按小时桶起点时刻匹配价格,分钟槽费用由其所属小时桶价格导出;改价即时生效,历史费用下次查询按新规则重算(不回溯账单)
+- 费用精度:**小时级**——聚合按小时桶起点时刻匹配价格,分钟槽费用由其所属小时桶价格导出;改价即时生效,历史费用下次查询按新规则重算(不回溯账单)。定价激活时聚合响应在槽级携带 `cost` 与逐模型拆分 `costByModel`(金额柱状图与悬浮读数的数据源)
 - 时区口径:匹配与聚合均用 host 进程本地时区;client 侧注入点(底栏费用项/回合费用芯片)按**浏览器本地时区**的当前时刻评估条件,跨时区访问时与面板费用存在预期内偏差;所有费用均为按当前费率的估算值(标注「≈」与「估算」),不构成账单
 
 ## 与 dsh-usage-statistics-panel 的关系

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-usage-dash",
   "description": "用量统计面板:天/小时/分钟三粒度 token 与请求统计,26 周活跃热力图,会话底栏信息接管与官方动作行回合费用芯片,多条件分时段定价规则与费用估算;复刻自 github.com/HaoyueQin/dsh-usage-statistics-panel,感谢原作者 HaoyueQin",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/client.js

@@ -13,7 +13,7 @@ const MINUTE_PRESET_MINUTES = { '3h': 3 * 60, '24h': 24 * 60, '3d': 3 * 24 * 60,
 
 const DEFAULT_RANGE = '30'
 const DEFAULT_HOUR_PRESET = '24h'
-const DEFAULT_MINUTE_PRESET = '24h'
+const DEFAULT_MINUTE_PRESET = '3h'
 
 // 天视图渲染上限;时/分上限 = 闭区间桶数(hour N+1 槽,minute N/10+1 槽)
 const DAY_MAX_SLOTS = 180
@@ -196,6 +196,7 @@ const MESSAGES_ZH = {
   avgSpeed: '平均生成速度',
   speedLegend: '平均生成速度',
   ttftLegend: '首 token 延迟',
+  avgPrice: '均价',
   topModel: '最常用模型',
   topModelHint: '按 token 用量排序,非调用次数',
   heatmap: '活跃热力图',
@@ -203,6 +204,10 @@ const MESSAGES_ZH = {
   heatMore: '较多',
   dailyTrend: '按天 Token 趋势',
   trendLimited: '仅显示最近 {n} 天',
+  dailyCostTrend: '按天金额趋势',
+  hourCostTrend: '按小时金额趋势',
+  minuteCostTrend: '按分钟金额趋势',
+  costTrend: '金额',
   modelUsage: '模型用量',
   modelCache: '缓存',
   modelInput: '输入',
@@ -339,6 +344,7 @@ const MESSAGES_EN = {
   avgSpeed: 'Avg speed',
   speedLegend: 'Avg speed',
   ttftLegend: 'First-token latency',
+  avgPrice: 'Avg price',
   topModel: 'Top model',
   topModelHint: 'Ranked by token usage, not call count',
   heatmap: 'Activity heatmap',
@@ -346,6 +352,10 @@ const MESSAGES_EN = {
   heatMore: 'More',
   dailyTrend: 'Daily token trend',
   trendLimited: 'Showing only the last {n} days',
+  dailyCostTrend: 'Daily cost trend',
+  hourCostTrend: 'Hourly cost trend',
+  minuteCostTrend: 'Per-minute cost trend',
+  costTrend: 'Cost',
   modelUsage: 'Model usage',
   modelCache: 'Cache',
   modelInput: 'Input',
@@ -545,24 +555,53 @@ function logTimeOf(ms) {
 const toRankedModels = (totals) =>
   [...totals.entries()].map(([model, tokens]) => ({ model, tokens })).sort((a, b) => b.tokens - a.tokens)
 
-// 逐槽 byModel 把非 top 模型并入哨兵桶,原明细留 otherByModel 供 tooltip;模型顺序 = 图例序(哨兵恒最后)
+// 逐槽把非 top 模型并入哨兵桶,token 与费用双度量同折,原明细留 otherByModel/otherCostByModel 供
+// tooltip;模型顺序 = 图例序(哨兵恒最后)
+const foldMetricByTop = (entries, top) => {
+  const kept = {}
+  const other = {}
+  for (const [model, value] of Object.entries(entries)) {
+    if (top.has(model)) {
+      kept[model] = (kept[model] ?? 0) + value
+      continue
+    }
+    kept[OTHER_MODEL] = (kept[OTHER_MODEL] ?? 0) + value
+    other[model] = (other[model] ?? 0) + value
+  }
+  return { kept, other }
+}
+
 const foldSlotsByTop = (slots, topModels) => {
   const top = new Set(topModels)
   return slots.map((slot) => {
-    const byModel = {}
-    const otherByModel = {}
-    for (const [model, tokens] of Object.entries(slot.byModel)) {
-      if (top.has(model)) {
-        byModel[model] = (byModel[model] ?? 0) + tokens
-        continue
-      }
-      byModel[OTHER_MODEL] = (byModel[OTHER_MODEL] ?? 0) + tokens
-      otherByModel[model] = (otherByModel[model] ?? 0) + tokens
+    const tokens = foldMetricByTop(slot.byModel, top)
+    const costs = foldMetricByTop(slot.costByModel ?? {}, top)
+    return {
+      ...slot,
+      byModel: tokens.kept,
+      otherByModel: tokens.other,
+      byCostModel: costs.kept,
+      otherCostByModel: costs.other,
     }
-    return { ...slot, byModel, otherByModel }
   })
 }
 
+// 金额槽投影:total/byModel/otherByModel 切换为费用口径(调用方保证费用字段在场)
+const costSlotsOf = (slots) => slots.map((slot) => ({
+  ...slot,
+  total: slot.cost,
+  byModel: slot.byCostModel,
+  otherByModel: slot.otherCostByModel,
+}))
+
+// 金额视图派生:存在正计价槽才可用(零计价规则/未配价的金额图全零有误导),
+// 开关开且可用才投影金额口径,否则原槽透传(引用不变)
+const moneyViewOf = (slots, costView) => {
+  const costReady = !!slots && slots.some((slot) => slot.cost > 0)
+  const money = costView && costReady
+  return { costReady, money, chartSlots: money ? costSlotsOf(slots) : slots }
+}
+
 const topWithOther = (ranked) => {
   const models = ranked.slice(0, GROUP_TOP_COUNT)
   if (ranked.length > GROUP_TOP_COUNT) {
@@ -597,6 +636,15 @@ function groupPointSlots(slots) {
   return { models, daily: foldSlotsByTop(slots, topModels) }
 }
 
+// 聚合展示区(统计卡/模型用量/统计截至)数据源:随视图联动——天视图用 range 聚合,时/分视图
+// (预设与自定义挡)用点端点聚合,字段同形;点数据未回为 null,调用方判空不渲染
+const cardsStatsOf = (view, stats, pointView) => (view === 'day' ? stats : pointView)
+
+// 模型用量列表:天视图用预折叠分组,时/分视图折叠点窗口模型(top5+other),点数据未回为 null
+const usageModelsOf = (view, grouped, pointView) => (
+  view === 'day' ? grouped?.models ?? null : pointView ? topWithOther(pointView.models) : null
+)
+
 // 趋势图视口常量
 const CHART_HEIGHT = 220
 const CHART_PAD = { left: 46, right: 65, top: 10, bottom: 26 }
@@ -610,6 +658,8 @@ const SPEED_SCALE_FLOOR = 1
 const TTFT_SCALE_FLOOR = 1
 // 轴上限留白系数:数据峰不顶满绘图区,顶部留出标注空间
 const AXIS_SCALE_HEADROOM = 1.1
+// 金额刻度下限:仅防零值退化,亚分峰值不参与轴标定失真
+const COST_TOTAL_FLOOR = 0.0001
 // 图例键:折线项与模型项共处同一显隐集合
 const LEGEND_KEY_RATE = 'rate'
 const LEGEND_KEY_SPEED = 'speed'
@@ -626,7 +676,7 @@ function niceTicks(max, count) {
   return ticks
 }
 
-// 图例显隐切换:current 为 null 表示全部可见;普通点击单选/再点恢复,
+// 图例显隐切换:current 为当前实际生效集;普通点击单选/再点恢复,
 // ctrl 单项切换,隐藏最后一项为无操作(返回原引用)
 function legendToggle(current, key, ctrl) {
   if (ctrl) {
@@ -639,26 +689,26 @@ function legendToggle(current, key, ctrl) {
   return solo ? null : new Set([key])
 }
 
-// 左轴刻度:速度刻度存在时左轴标定速度(tok/s),否则标定 token;
+// 左轴刻度:速度刻度存在时左轴标定速度(tok/s),否则标定柱度量(token 或金额,格式化由调用方注入);
 // 刻度值统一换算为绘图区高度占比
-function leftAxisTicks(tokenTicks, tokenMax, speedTicks, speedMax) {
+function leftAxisTicks(tokenTicks, tokenMax, speedTicks, speedMax, format = formatCompact) {
   const useSpeed = speedTicks.length > 0
   return (useSpeed ? speedTicks : tokenTicks).map((tick) => ({
-    label: formatCompact(tick),
+    label: (useSpeed ? formatCompact : format)(tick),
     ratio: tick / (useSpeed ? speedMax : tokenMax),
   }))
 }
 
 // 堆叠柱几何:模型序即堆叠序(哨兵最后画柱顶),输出槽分段与左轴刻度;
-// maxTotal 按可见模型求和,单选模型时刻度跟随归一
-function trendLayout(slots, modelOrder, avail, labelMinPitch) {
+// maxTotal 按可见模型求和,单选模型时刻度跟随归一;totalFloor 为量纲下限(token 个位数/金额亚分)
+function trendLayout(slots, modelOrder, avail, labelMinPitch, totalFloor = 1) {
   const plotHeight = CHART_HEIGHT - CHART_PAD.top - CHART_PAD.bottom
   const innerWidth = Math.max(1, avail - CHART_PAD.left - CHART_PAD.right)
   const count = slots.length
   const step = count > 1 ? innerWidth / (count - 1) : innerWidth
   const barWidth = Math.max(BAR_MIN_WIDTH, Math.min(BAR_MAX_WIDTH, step * BAR_WIDTH_RATIO))
   const slotVisibleTotal = (slot) => modelOrder.reduce((sum, model) => sum + (slot.byModel[model] ?? 0), 0)
-  const maxTotal = Math.max(1, ...slots.map(slotVisibleTotal))
+  const maxTotal = Math.max(totalFloor, ...slots.map(slotVisibleTotal))
   // 轴上限 = 数据峰 × 留白系数,柱高分母与左轴刻度分母同源
   const scaleMax = maxTotal * AXIS_SCALE_HEADROOM
   // 可见模型无任何数据时左轴无标定对象,空刻度防钳底值漏成假刻度
@@ -862,6 +912,17 @@ function modelIoPercentText(item, t) {
 // 趋势 tooltip 内容门:全零槽(无任何用量)不渲染 tooltip
 const hasTipContent = (hoverSlot) => Boolean(hoverSlot) && hoverSlot.total > 0
 
+// 折叠提醒判定:折叠层内有异常日志条目或写入失败即值得提醒
+const hasAnomalyNews = (status) => !!status
+  && ((status.log?.length ?? 0) > 0 || (status.recordFailures ?? 0) > 0)
+
+// 趋势折线默认显隐集:模型全显 + 速度线(有数据时);缓存命中率与首 token 延迟默认隐藏,
+// 图例切换后以组件内键集接管(不持久化)
+const trendDefaultVisibleKeys = (modelOrder, hasSpeed) => new Set([
+  ...modelOrder,
+  ...(hasSpeed ? [LEGEND_KEY_SPEED] : []),
+])
+
 // 趋势 tooltip 模型行数据:主行 = 可见且当前时段有用量的模型;OTHER 子行 = OTHER 可见
 // 且当前时段有用量的其余模型明细,按 tokens 降序由本函数保证
 const tipModelEntries = (hoverSlot, visibleSet) => {
@@ -875,6 +936,11 @@ const tipModelEntries = (hoverSlot, visibleSet) => {
   return { main, other }
 }
 
+// 趋势 tooltip 槽级均价:槽费用折每百万 token 单价;无槽或无有效费用(含零值)为 null
+const tipAvgPriceText = (hoverSlot, currency) => (
+  hoverSlot ? avgPriceText(hoverSlot.cost, hoverSlot.total, currency) || null : null
+)
+
 // 热力图:窗口固定 26 周,与所选范围无关
 const HEAT_WEEKS = 26
 const HEAT_ROW_COUNT = 7
@@ -1378,17 +1444,35 @@ const COST_MICRO_THRESHOLD = 0.01
 const COST_PLACEHOLDER = '—'
 const THOUSANDS_PATTERN = /(\d)(?=(\d{3})+(?!\d))/g
 
-// 千分位 + 至少两位小数,正值小于 0.01 时四位;货币空串不加符号,「≈」前缀由调用方拼
-function formatCost(value, currency) {
-  const decimals = value > 0 && value < COST_MICRO_THRESHOLD ? COST_MICRO_DECIMALS : COST_DECIMALS
-  const [whole, fraction] = value.toFixed(decimals).split('.')
+// 千分位 + 至少 decimals 位小数,正值小于 10^-decimals 时小数位 +2;货币空串不加符号,「≈」前缀由调用方拼
+function formatCost(value, currency, decimals = COST_DECIMALS) {
+  const microThreshold = 10 ** -decimals
+  const used = value > 0 && value < microThreshold ? decimals + (COST_MICRO_DECIMALS - COST_DECIMALS) : decimals
+  const [whole, fraction] = value.toFixed(used).split('.')
   return `${currency}${whole.replace(THOUSANDS_PATTERN, '$1,')}.${fraction}`
 }
 
+const COST_CENT_SCALE = 100
+const COST_MICRO_SCALE = COST_CENT_SCALE * COST_CENT_SCALE
+
+// 金额轴紧凑读数:千以上 k/M 一位小数,分上取两位内,分下四位(微观阈值与 formatCost 同源)
+function formatCostCompact(value, currency) {
+  if (value >= COMPACT_BASE ** 2) return `${currency}${(value / COMPACT_BASE ** 2).toFixed(DECIMAL_DIGITS)}M`
+  if (value >= COMPACT_BASE) return `${currency}${(value / COMPACT_BASE).toFixed(DECIMAL_DIGITS)}k`
+  if (value >= COST_MICRO_THRESHOLD) return `${currency}${Math.round(value * COST_CENT_SCALE) / COST_CENT_SCALE}`
+  return `${currency}${Math.round(value * COST_MICRO_SCALE) / COST_MICRO_SCALE}`
+}
+
+// 模型均价:费用折算每百万 token 单价;无费用(cost 恒正数才有效,0 视为未配价)或零 token 无均价
+const AVG_PRICE_DECIMALS = 3
+function avgPriceText(cost, tokens, currency) {
+  if (!(cost > 0) || !(tokens > 0)) return ''
+  return `${formatCost(cost / (tokens / TOKENS_PER_MILLION), currency, AVG_PRICE_DECIMALS)}/M`
+}
+
 // 全局显示货币:规则表首个非空 currency,所有费用显示点统一取此值(全局价格定位);
 // 无则空串即不带符号。数值仍按命中规则单价计算,符号不随命中规则变化
-function aggregateCurrencyOf(rules) {
-  if (!Array.isArray(rules)) return ''
+function aggregateCurrencyOf(rules) {  if (!Array.isArray(rules)) return ''
   const found = rules.find((rule) => typeof rule?.currency === 'string' && rule.currency !== '')
   return found ? found.currency : ''
 }
@@ -1762,6 +1846,12 @@ function removeRulesAt(rules, indexes) {
 if (typeof window !== 'undefined' && window.__ModuleLoader__) {
   window.__ModuleLoader__.load({ id: '@mzzsfy/dsh-usage-dash', factory })
 
+  // 导航分区图标:表盘(dash 概念);键覆盖中英分区名 + 市场短名,语言切换下声明不漂移
+  const NAV_ICON = { '使用统计': 'gauge', 'Usage': 'gauge', 'dsh-usage-dash': 'gauge' }
+  if (window.__navicIcons !== undefined) window.__navicIcons.register(NAV_ICON)
+  else if (Array.isArray(window.__navicIconQueue)) window.__navicIconQueue.push(NAV_ICON)
+  else window.__navicIconQueue = [NAV_ICON]
+
   function factory(require) {
     let React = null
     try {
@@ -1846,7 +1936,8 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
     const ICON_STROKE_WIDTH = 2
     const NOTE_SEPARATOR = ' · '
     const TIP_Z_INDEX = 1100
-    const STYLE_ID = 'dsh-usage-dash'
+    // 与注册 id 同源:既作样式查重键,又作 data-plugin 标记值,短名会使自身 rebuilt 删不到旧样式
+    const STYLE_ID = '@mzzsfy/dsh-usage-dash'
     // 开关视觉常量(规约形态:隐藏 checkbox + track 胶囊 + thumb 圆点)
     const SWITCH_TRACK_WIDTH = 40
     const SWITCH_TRACK_HEIGHT = 22
@@ -1955,10 +2046,11 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
 .ud-empty{border:1px dashed var(--dsw-alias-border-l2);border-radius:8px;color:var(--dsw-alias-label-tertiary);text-align:center;padding:24px 16px;font-size:12px}
 .ud-foot{color:var(--dsw-alias-label-tertiary);font-size:11px}
 .ud-status{display:flex;align-items:center;justify-content:flex-end;gap:8px;flex-wrap:wrap;margin-top:4px;font-size:12px;color:var(--dsw-alias-label-tertiary)}
-.ud-status-fold{display:inline-flex;align-items:center;justify-content:center;width:28px;height:100%;min-height:28px;border:none;background:none;padding:0;font:inherit;font-size:12px;line-height:1;color:var(--dsw-alias-label-tertiary);cursor:pointer;border-radius:6px}
+.ud-status-fold{position:relative;display:inline-flex;align-items:center;justify-content:center;width:28px;height:100%;min-height:28px;border:none;background:none;padding:0;font:inherit;font-size:12px;line-height:1;color:var(--dsw-alias-label-tertiary);cursor:pointer;border-radius:6px}
 .ud-status-fold:hover{color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-interactive-bg-hover)}
 .ud-status-fold-caret{display:block;width:0;height:0;border-left:4px solid transparent;border-right:4px solid transparent;border-top:5px solid currentColor;transition:transform .15s ease}
 .ud-status-fold[aria-expanded="true"] .ud-status-fold-caret{transform:rotate(180deg)}
+.ud-status-fold-dot{position:absolute;top:4px;right:4px;width:6px;height:6px;border-radius:50%;background:var(--dsw-alias-state-error-primary)}
 .ud-status-track{display:inline-block;width:120px;height:2px;border-radius:1px;background:var(--dsw-alias-border-l1);overflow:hidden}
 .ud-status-fill{display:block;height:100%;background:var(--dsw-alias-state-business-primary)}
 .ud-status-err{color:var(--dsw-alias-state-error-primary)}
@@ -1987,6 +2079,8 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
 .ud-section-head{display:flex;align-items:baseline;gap:8px;flex-wrap:wrap}
 .ud-section-title{font-size:15px;font-weight:600}
 .ud-trend-note{font-size:11px;color:var(--dsw-alias-label-tertiary)}
+.ud-trend-metric{display:inline-flex;align-items:center;gap:6px;margin-left:auto}
+.ud-trend-metric-label{font-size:11px;color:var(--dsw-alias-label-secondary);white-space:nowrap}
 .ud-chart-wrap{width:100%;min-width:0}
 .ud-chart{display:block;width:100%}
 .ud-grid{stroke:var(--dsw-alias-border-l1);stroke-width:1}
@@ -2202,11 +2296,12 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
       return `var(--ud-chart-${rank})`
     }
 
-    function TrendChart({ title, notes, slots, modelOrder, colorFor, labelFor, slotLabelFor, labelMinPitch, busy, legendModels, panelRef, costCurrency = '', costEnabled = false, t = defaultT }) {
+    function TrendChart({ title, notes, slots, tipSlots, modelOrder, colorFor, labelFor, slotLabelFor, labelMinPitch, busy, legendModels, panelRef, costCurrency = '', money = false, costAvailable = false, onMetricToggle, t = defaultT }) {
+      const metricId = React.useId()
       const wrapRef = useRef(null)
       const [avail, setAvail] = useState(CHART_NOMINAL_WIDTH)
       const [hover, setHover] = useState(null)
-      // 图例显隐:null = 全部可见;键集 = 模型项与折线项(rate/speed)
+      // 图例显隐:null = 默认集(trendDefaultVisibleKeys);切换以实际生效集为基线展开为键集
       const [visibleKeys, setVisibleKeys] = useState(null)
       // prefs 仅用于 hover tooltip 的费用显隐,经 ref 读取:开关切换不触发本组件重渲染,
       // 避免宿主设置弹窗滚动锚定被重渲染扰动而跳变
@@ -2223,16 +2318,12 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
       }, [])
       const hasSpeed = slots.some((slot) => slot.speed !== undefined)
       const hasTtft = slots.some((slot) => slot.ttft !== undefined)
-      const visibleSet = visibleKeys ?? new Set([
-        ...modelOrder, LEGEND_KEY_RATE,
-        ...(hasSpeed ? [LEGEND_KEY_SPEED] : []),
-        ...(hasTtft ? [LEGEND_KEY_TTFT] : []),
-      ])
+      const visibleSet = visibleKeys ?? trendDefaultVisibleKeys(modelOrder, hasSpeed)
       const visibleModels = modelOrder.filter((model) => visibleSet.has(model))
       const showRate = visibleSet.has(LEGEND_KEY_RATE)
       const showSpeed = hasSpeed && visibleSet.has(LEGEND_KEY_SPEED)
       const showTtft = hasTtft && visibleSet.has(LEGEND_KEY_TTFT)
-      const layout = trendLayout(slots, visibleModels, avail, labelMinPitch)
+      const layout = trendLayout(slots, visibleModels, avail, labelMinPitch, money ? COST_TOTAL_FLOOR : 1)
       const plotRight = CHART_PAD.left + (slots.length - 1) * layout.step + layout.barWidth
       const ratePoints = trendRatePoints(slots, layout.bars, layout.plotHeight)
       const speedMax = speedScaleMax(slots)
@@ -2244,26 +2335,33 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
       // 左轴标定:可见柱有数据标 token;无柱数据且速度线可见标速度(tok/s);否则空
       // (ttft 不设轴,读数走 tooltip,毫秒域与速度轴不同单位不混轴)
       const speedAxisTicks = layout.ticks.length === 0 && showSpeed ? niceTicks(speedMax, AXIS_TICK_COUNT) : []
-      const yTicks = leftAxisTicks(layout.ticks, layout.scaleMax, speedAxisTicks, speedAxisMax)
-      const hoverSlot = hover ? slots[hover.index] : null
+      // 金额视图左轴走紧凑金额读数,速度接管时仍为 tok/s 紧凑读数
+      const yTicks = leftAxisTicks(layout.ticks, layout.scaleMax, speedAxisTicks, speedAxisMax,
+        money ? (value) => formatCostCompact(value, costCurrency) : formatCompact)
+      // 悬浮明细恒用 token 槽渲染:金额模式只切柱几何与左轴,悬浮文本不随口径变化
+      const hoverSlot = hover ? (tipSlots ?? slots)[hover.index] : null
       const hoverRatePoint = showRate && hoverSlot ? ratePoints.find((point) => point.day === hoverSlot.day) : null
       const hoverSpeedPoint = hoverSlot ? speedPoints.find((point) => point.day === hoverSlot.day) : null
       const hoverTtftPoint = hoverSlot ? ttftPoints.find((point) => point.day === hoverSlot.day) : null
       const pick = (index) => (event) => setHover({ index, anchor: pointerAt(event) })
       const clear = () => setHover(null)
       const tipEntries = hasTipContent(hoverSlot) ? tipModelEntries(hoverSlot, visibleSet) : null
+      const avgPrice = tipAvgPriceText(hoverSlot, costCurrency)
       return h('div', { className: 'ud-section' },
         h('div', { className: 'ud-section-head' },
           h('span', { className: 'ud-section-title' }, title),
-          notes.length > 0 ? h('span', { className: 'ud-trend-note' }, notes.join(NOTE_SEPARATOR)) : null),
+          notes.length > 0 ? h('span', { className: 'ud-trend-note' }, notes.join(NOTE_SEPARATOR)) : null,
+          costAvailable ? h('span', { className: 'ud-trend-metric' },
+            h('span', { className: 'ud-trend-metric-label', id: metricId }, t('costTrend')),
+            h(Switch, { checked: money, onChange: onMetricToggle, describedbyId: metricId, labelledById: metricId })) : null),
         h('div', { className: 'ud-chart-wrap', ref: wrapRef, style: busy ? { opacity: CHART_BUSY_OPACITY } : undefined },
           h('svg', {
             className: 'ud-chart', viewBox: `0 0 ${avail} ${CHART_HEIGHT}`, width: '100%', role: 'img',
             'aria-label': title, onMouseLeave: clear,
           },
-            yTicks.map((tick) => {
+            yTicks.map((tick, tickIndex) => {
               const y = CHART_PAD.top + layout.plotHeight - tick.ratio * layout.plotHeight
-              return h('g', { key: tick.label },
+              return h('g', { key: tickIndex },
                 h('line', { className: 'ud-grid', x1: CHART_PAD.left, x2: plotRight, y1: y, y2: y }),
                 h('text', { className: 'ud-axis', x: CHART_PAD.left - AXIS_LABEL_GAP, y: y + AXIS_LABEL_BASELINE, textAnchor: 'end' }, tick.label))
             }),
@@ -2317,7 +2415,7 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
         h(Legend, {
           models: legendModels, colorFor, speedEnabled: hasSpeed, ttftEnabled: hasTtft,
           isVisible: (key) => visibleSet.has(key),
-          onItem: (key, ctrl) => setVisibleKeys(legendToggle(visibleKeys, key, ctrl)),
+          onItem: (key, ctrl) => setVisibleKeys(legendToggle(visibleSet, key, ctrl)),
         }),
         h(ChartTip, { anchor: hover ? hover.anchor : null, panelRef },
           tipEntries
@@ -2332,8 +2430,11 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
                 showRate ? h('div', { key: 'rate', className: 'ud-tip-row' }, `${t('cacheHitRate')}: ${cacheRateText(hoverSlot.cacheHit, hoverSlot.cacheMiss)}`) : null,
                 showSpeed ? h('div', { key: 'speed', className: 'ud-tip-row' }, `${t('avgSpeed')}: ${speedTipText(hoverSlot.speed)}`) : null,
                 showTtft ? h('div', { key: 'ttft', className: 'ud-tip-row' }, `${t('ttftLegend')}: ${ttftTipText(hoverSlot.ttft, t)}`) : null,
-                costEnabled && prefsRef.current.costDisplay && hoverSlot.cost !== undefined
-                  ? h('div', { key: 'cost', className: 'ud-tip-row' }, `≈ ${formatCost(hoverSlot.cost, costCurrency)}`)
+                prefsRef.current.costDisplay && hoverSlot.cost !== undefined
+                  ? [
+                      h('div', { key: 'cost', className: 'ud-tip-row' }, `≈ ${formatCost(hoverSlot.cost, costCurrency)}`),
+                      avgPrice ? h('div', { key: 'avg-price', className: 'ud-tip-row' }, `${t('avgPrice')}: ${avgPrice}`) : null,
+                    ]
                   : null,
               ]
             : null))
@@ -2388,10 +2489,13 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
         : element
     }
 
-    function HeatSection({ days, panelRef, t = defaultT }) {
+    function HeatSection({ days, panelRef, costCurrency = '', t = defaultT }) {
       const wrapRef = useRef(null)
       const [width, setWidth] = useState(0)
       const [hover, setHover] = useState(null)
+      // 费用行显隐随「费用显示」偏好,经 ref 读取:开关切换不触发本组件重渲染
+      const prefsRef = useRef(statsLineState.get())
+      useEffect(() => statsLineState.subscribe(() => { prefsRef.current = statsLineState.get() }), [])
       useEffect(() => {
         const element = wrapRef.current
         const observer = new ResizeObserver((entries) => {
@@ -2440,6 +2544,9 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
                 h('div', { key: 'tokens', className: 'ud-tip-row' }, `${t('tokens')}: ${formatTokens(hover.tokens)}`),
                 h('div', { key: 'requests', className: 'ud-tip-row' }, `${t('requests')}: ${hover.requests}`),
                 h('div', { key: 'rate', className: 'ud-tip-row' }, `${t('cacheHitRate')}: ${cacheRateText(hover.cacheHit, hover.cacheMiss)}`),
+                prefsRef.current.costDisplay && hover.cost > 0
+                  ? h('div', { key: 'cost', className: 'ud-tip-row' }, t('stats.cost', { cost: formatCost(hover.cost, costCurrency) }))
+                  : null,
               ]
             : null))
     }
@@ -2496,6 +2603,8 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
               const speedText = modelSpeedText(item.speed)
               const ttftText = modelTtftText(item.ttft)
               const ioText = modelIoPercentText(item, t)
+              const avgText = avgPriceText(item.cost, item.tokens, costCurrency)
+              const tokensText = `${formatTokens(item.tokens)} (${formatPercent((item.tokens / total) * PERCENT_SCALE)})`
               const metaParts = [
                 item.cost !== undefined ? `≈ ${formatCost(item.cost, costCurrency)}` : null,
                 ttftText,
@@ -2526,8 +2635,7 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
                       }, '›')
                     : null,
                   h('div', { className: 'ud-model-values' },
-                    h('span', { className: 'ud-model-tokens' },
-                      `${formatTokens(item.tokens)} (${formatPercent((item.tokens / total) * PERCENT_SCALE)})`),
+                    h('span', { className: 'ud-model-tokens' }, avgText ? `${tokensText} · ${avgText}` : tokensText),
                     ioText ? h('span', { className: 'ud-model-io' }, ioText) : null,
                     h('span', { className: 'ud-model-meta' }, metaParts.join(' · ')))),
                 isOther
@@ -2567,13 +2675,14 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
     }
 
     // 规约形态开关:原生 checkbox 保语义并视觉隐藏,track/thumb 呈现选中态
-    function Switch({ checked, onChange, disabled, describedbyId }) {
+    function Switch({ checked, onChange, disabled, describedbyId, labelledById }) {
       return h('label', { className: 'ud-switch' },
         h('input', {
           type: 'checkbox',
           checked,
           disabled,
           'aria-describedby': describedbyId,
+          'aria-labelledby': labelledById,
           onChange: (event) => onChange(event.target.checked),
         }),
         h('span', { className: 'ud-switch__track' },
@@ -2986,14 +3095,16 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
         }, t('addGroup')))
     }
 
-    // 扫描异常日志入口:仅箭头标识,明细在展开的日志块中展示
-    function AnomalyChip({ open, onToggle, t = defaultT }) {
+    // 扫描异常日志入口:仅箭头标识,明细在展开的日志块中展示;
+    // 折叠且有待读信息时箭头带小点,展开后消失
+    function AnomalyChip({ open, news, onToggle, t = defaultT }) {
       return h('button', {
         type: 'button', className: 'ud-status-fold', 'aria-expanded': open,
         'aria-label': t('anomalyLog'), title: t('anomalyLog'),
         onClick: onToggle,
       },
-      h('span', { className: 'ud-status-fold-caret', 'aria-hidden': 'true' }))
+      h('span', { className: 'ud-status-fold-caret', 'aria-hidden': 'true' }),
+      news && !open ? h('span', { className: 'ud-status-fold-dot', 'aria-hidden': 'true' }) : null)
     }
 
     // 回扫进度与采集错误是运行状态,常显;异常明细走日志块
@@ -3104,6 +3215,7 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
 
     const viewLabel = (t, id) => (id === 'day' ? t('viewDay') : id === 'hour' ? t('viewHour') : t('viewMinute'))
     const trendTitle = (t, id) => (id === 'day' ? t('dailyTrend') : id === 'hour' ? t('hourTrend') : t('minuteTrend'))
+    const trendCostTitle = (t, id) => (id === 'day' ? t('dailyCostTrend') : id === 'hour' ? t('hourCostTrend') : t('minuteCostTrend'))
     const trendLimitedText = (t, id, count) => (id === 'day'
       ? t('trendLimited', { n: count })
       : id === 'hour' ? t('trendLimitedHour', { n: count }) : t('trendLimitedMinute', { n: count }))
@@ -3113,6 +3225,8 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
 
     function UsageDashPanel({ t = defaultT }) {
       const [view, setView] = useState('day')
+      // 趋势图金额口径开关:会话态,与视图/挡位同为面板内临时状态
+      const [costView, setCostView] = useState(false)
       const [range, setRange] = useState(DEFAULT_RANGE)
       const [customFrom, setCustomFrom] = useState('')
       const [customTo, setCustomTo] = useState('')
@@ -3163,6 +3277,7 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
               requests: slot ? slot.requests : 0,
               cacheHit: slot ? slot.cacheHit : 0,
               cacheMiss: slot ? slot.cacheMiss : 0,
+              cost: slot ? slot.cost : 0,
             }
           }))
         })
@@ -3288,14 +3403,19 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
       const grouped = useMemo(() => (stats ? groupStats(stats) : null), [stats])
       const pointView = activeQuery && pointStatsMatches(pointStats, view, activeQuery.key) ? pointStats.value : null
       const pointGrouped = useMemo(() => (pointView ? groupPointSlots(pointView.daily) : null), [pointView])
-      const colorFor = useMemo(() => colorForModel(stats ? stats.models : []), [stats])
 
       const pointActive = view !== 'day'
       const trendSource = pointActive
         ? (pointGrouped ? { slots: pointGrouped.daily, models: pointGrouped.models, value: pointView } : null)
         : (grouped ? { slots: grouped.daily, models: grouped.models, value: stats } : null)
+      // 聚合展示区(统计卡/模型用量/统计截至)与趋势图同源,随视图联动;点数据未回为 null 不渲染
+      const cardsStats = cardsStatsOf(view, stats, pointView)
+      const usageModels = usageModelsOf(view, grouped, pointView)
+      // 模型配色取当期窗口模型排名,防跨窗口取色错位
+      const colorFor = useMemo(() => colorForModel(cardsStats ? cardsStats.models : []), [cardsStats])
       const maxSlots = pointActive ? maxSlotsFor(view, rawPreset) : DAY_MAX_SLOTS
       const trimmedSlots = trendSource ? trimSlots(trendSource.slots, maxSlots) : null
+      const { costReady, money, chartSlots } = moneyViewOf(trimmedSlots, costView)
       const notes = []
       if (trendSource && trendSource.slots.length > trimmedSlots.length) notes.push(trendLimitedText(t, view, trimmedSlots.length))
       if (trendSource?.value?.truncated) notes.push(t('trendTruncated'))
@@ -3370,7 +3490,7 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
                         }))
                     : null)),
           h('div', { className: 'ud-toolbar-side' },
-            h(AnomalyChip, { open: detailsOpen, onToggle: () => setDetailsOpen((v) => !v), t }),
+            h(AnomalyChip, { open: detailsOpen, news: hasAnomalyNews(status), onToggle: () => setDetailsOpen((v) => !v), t }),
             h('button', {
               className: 'ud-btn ud-btn--text ud-icon-btn', 'aria-label': t('refresh'), title: t('refresh'),
               disabled: busy, onClick: refresh,
@@ -3385,15 +3505,16 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
           : null,
         error ? h('div', { className: 'ud-error' }, error) : null,
         loadingVisible ? h('div', { className: 'ud-loading' }, `${t('loading')}…`) : null,
-        stats ? h(StatCards, { key: 'cards', stats, costCurrency, t }) : null,
+        cardsStats ? h(StatCards, { key: 'cards', stats: cardsStats, costCurrency, t }) : null,
         // 活跃热力图仅按天视图展示:热力图口径为日桶,时/分视图无对应语义
-        view === 'day' ? h(HeatSection, { key: 'heat', days: heatDays, panelRef, t }) : null,
+        view === 'day' ? h(HeatSection, { key: 'heat', days: heatDays, panelRef, costCurrency, t }) : null,
         trimmedSlots
           ? h(TrendChart, {
               key: 'trend',
-              title: trendTitle(t, view),
+              title: money ? trendCostTitle(t, view) : trendTitle(t, view),
               notes,
-              slots: trimmedSlots,
+              slots: chartSlots,
+              tipSlots: trimmedSlots,
               modelOrder: trendSource.models.map((item) => item.model),
               colorFor,
               labelFor: tickLabelFor(view),
@@ -3403,12 +3524,14 @@ body[data-ds-dark-theme] .ud-panel{--ud-chart-1:color-mix(in srgb,#0576ff 65%,wh
               legendModels: trendSource.models,
               panelRef,
               costCurrency,
-              costEnabled: view === 'day',
+              money,
+              costAvailable: costReady,
+              onMetricToggle: setCostView,
               t,
             })
           : null,
-        grouped ? h(ModelUsage, { key: 'models', models: grouped.models, colorFor, panelRef, costCurrency, t }) : null,
-        stats?.to ? h('div', { className: 'ud-foot' }, `${t('asOf')} ${stats.to}`) : null,
+        usageModels ? h(ModelUsage, { key: 'models', models: usageModels, colorFor, panelRef, costCurrency, t }) : null,
+        cardsStats?.to ? h('div', { className: 'ud-foot' }, `${t('asOf')} ${slotLabelFor(view)(cardsStats.to)}`) : null,
         emptyVisible ? h('div', { className: 'ud-empty' }, t('empty')) : null,
         h(StatsLineOptions, { key: 'prefs', t }),
         h(PricingEditor, { key: 'pricing', t }))

package/src/collector.js

@@ -12,6 +12,8 @@ const SEQ_UNKNOWN = -1
 const DEFAULT_BACKFILL_CONCURRENCY = 4
 const MARK_BATCH = 32
 const SCAN_LOG_MAX_ENTRIES = 200
+// 单条日志 detail 上限:flush 底层行错误拼接的截断保护
+const LOG_DETAIL_MAX_CHARS = 500
 
 // 不可读会话分类:宿主可见性/可读性边界的三代实测形态(见 README 存档兼容)
 const SKIP_KINDS = { descriptor: 'descriptor', corrupt: 'corrupt', legacy: 'legacy', other: 'other' }
@@ -31,6 +33,15 @@ function classifySkip(detail) {
   return SKIP_KINDS.other
 }
 
+// flush 失败日志文本:包装文案在前,聚合的底层行错误逐条展开,超长截断
+function flushErrorText(error) {
+  const head = error instanceof Error ? error.message : String(error)
+  if (!(error instanceof AggregateError) || error.errors.length === 0) return head
+  const detail = error.errors.map((err) => (err instanceof Error ? err.message : String(err))).join('; ')
+  const text = `${head}: ${detail}`
+  return text.length > LOG_DETAIL_MAX_CHARS ? `${text.slice(0, LOG_DETAIL_MAX_CHARS)}…` : text
+}
+
 function emptySkipCounts() {
   return { [SKIP_KINDS.descriptor]: 0, [SKIP_KINDS.corrupt]: 0, [SKIP_KINDS.legacy]: 0, [SKIP_KINDS.other]: 0 }
 }
@@ -231,9 +242,10 @@ export class UsageCollector {
   constructor(ctx, store) {
     this.ctx = ctx
     this.store = store
-    // store 写合并周期落盘的失败行接入扫描异常日志,面板可观测
+    // store 写合并周期落盘的失败行接入扫描异常日志,面板可观测;
+    // AggregateError 展开底层行错误,只记包装文案无法归因
     store.onFlushError = (error) => {
-      this.pushLog('record', error instanceof Error ? error.message : String(error))
+      this.pushLog('record', flushErrorText(error))
     }
     this.folds = new Map()
     this.routes = new Map()

package/src/query.js

@@ -1,4 +1,4 @@
-import { costOf, matchPrice } from './pricing.js'
+import { costOf, matchPrice } from './pricing.js'
 
 export const MAX_SLOTS = 2000
 
@@ -14,7 +14,7 @@ const DAY_KEY_PATTERN = /^\d{4}-\d{2}-\d{2}$/
 const HOUR_KEY_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}$/
 const MINUTE_KEY_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/
 
-// 桶串前缀宽:D 段定位日桶,M 行截取父 H 桶
+// 妗朵覆鍓嶇紑瀹?D 娈靛畾浣嶆棩妗?M 琛屾埅鍙栫埗 H 妗?
 const DAY_KEY_WIDTH = 'YYYY-MM-DD'.length
 const HOUR_KEY_WIDTH = 'YYYY-MM-DDTHH'.length
 
@@ -39,10 +39,10 @@ const nextMinute = (date) => {
   return next
 }
 
-// 分钟桶粒度:枚举与桶键共用同一步长,from 必须对齐桶边界
+// 鍒嗛挓妗剁矑搴?鏋氫妇涓庢《閿叡鐢ㄥ悓涓€姝ラ暱,from 蹇呴』瀵归綈妗惰竟鐣?
 const MINUTE_STEP_MINUTES = 10
 
-// pattern 锚定桶串外形,suffix 补全为本地时区可解析日期串,format 回读校验分量合法性
+// pattern 閿氬畾妗朵覆澶栧舰,suffix 琛ュ叏涓烘湰鍦版椂鍖哄彲瑙ｆ瀽鏃ユ湡涓?format 鍥炶鏍￠獙鍒嗛噺鍚堟硶鎬?
 const BUCKET_FORMS = {
   [GRANULARITY_DAILY]: { pattern: DAY_KEY_PATTERN, suffix: 'T00:00:00', format: formatDate, step: nextDay },
   [GRANULARITY_HOURLY]: { pattern: HOUR_KEY_PATTERN, suffix: ':00:00', format: formatHour, step: nextHour },
@@ -95,8 +95,8 @@ const percentOf = (part, total) => (total === 0 ? 0 : (part / total) * PERCENT_S
 
 const rowTokens = (row) => row.inputTokens + row.outputTokens + row.cacheReadTokens + row.cacheWriteTokens
 
-// 速度配对分子:decode 口径取 decodeTokens;存量旧格式行(带时长无 decodeTokens)
-// 回落 outputTokens,聚合随新数据自然收敛
+// 閫熷害閰嶅鍒嗗瓙:decode 鍙ｅ緞鍙?decodeTokens;瀛橀噺鏃ф牸寮忚(甯︽椂闀挎棤 decodeTokens)
+// 鍥炶惤 outputTokens,鑱氬悎闅忔柊鏁版嵁鑷劧鏀舵暃
 const speedTokensOf = (row) => (row.durationMs ? row.decodeTokens ?? row.outputTokens : 0)
 
 export function aggregateRange(rows, g, from, to) {
@@ -105,19 +105,20 @@ export function aggregateRange(rows, g, from, to) {
   const slotByKey = new Map(slots.map((slot) => [slot.day, slot]))
   const modelTotals = new Map()
   const providerTotals = new Map()
-  const activeBuckets = new Set()
-  // 槽级配对:桶串 → 速度对 {decodeTokens, durationMs} 与首字对 {ttftMs, ttftSteps},
+  // 活跃天 = 有 token 产出的自然日(桶键按日去重,跨粒度统一口径)
+  const activeDays = new Set()
+  // 妲界骇閰嶅:妗朵覆 鈫?閫熷害瀵?{decodeTokens, durationMs} 涓庨瀛楀 {ttftMs, ttftSteps},
   const slotSpeeds = new Map()
   const slotTtfts = new Map()
   for (const row of rows) {
     const slot = slotByKey.get(row.bucket)
-    // 桶串未落在枚举序列(如改粒度前的历史残行)不可归属,跳过防崩
+    // 妗朵覆鏈惤鍦ㄦ灇涓惧簭鍒?濡傛敼绮掑害鍓嶇殑鍘嗗彶娈嬭)涓嶅彲褰掑睘,璺宠繃闃插穿
     if (!slot) continue
     const tokens = rowTokens(row)
     addRowToSlot(slot, row, tokens)
-    // 纯 timing 行(零 token 桶 + decode 配对)不参与归属,但仍进配对聚合
+    // 绾?timing 琛?闆?token 妗?+ decode 閰嶅)涓嶅弬涓庡綊灞?浣嗕粛杩涢厤瀵硅仛鍚?
     if (tokens > 0) {
-      activeBuckets.add(row.bucket)
+      activeDays.add(row.bucket.slice(0, DAY_KEY_WIDTH))
       slot.byModel[row.model] = (slot.byModel[row.model] ?? 0) + tokens
       slot.byProvider[row.provider] = (slot.byProvider[row.provider] ?? 0) + tokens
     }
@@ -174,9 +175,9 @@ export function aggregateRange(rows, g, from, to) {
     totals.cacheHit += slot.cacheHit
     totals.cacheMiss += slot.cacheMiss
   }
-  // speed = decode 配对口径(decodeTokens ÷ 时长秒);ttft = 首 token 延迟
-  // 加权平均(毫秒);仅配对数据存在的条目挂字段,无数据条目不挂
-  // 纯 timing 行可能产生 0-token 条目,列表保持只含 token 行(存量契约)
+  // speed = decode 閰嶅鍙ｅ緞(decodeTokens 梅 鏃堕暱绉?;ttft = 棣?token 寤惰繜
+  // 鍔犳潈骞冲潎(姣);浠呴厤瀵规暟鎹瓨鍦ㄧ殑鏉＄洰鎸傚瓧娈?鏃犳暟鎹潯鐩笉鎸?
+  // 绾?timing 琛屽彲鑳戒骇鐢?0-token 鏉＄洰,鍒楄〃淇濇寔鍙惈 token 琛?瀛橀噺濂戠害)
   const models = [...modelTotals.entries()]
     .filter(([, agg]) => agg.tokens > 0)
     .map(([model, agg]) => ({
@@ -207,7 +208,7 @@ export function aggregateRange(rows, g, from, to) {
     turns: totals.turns,
     cacheHit: totals.cacheHit,
     cacheMiss: totals.cacheMiss,
-    activeDays: activeBuckets.size,
+    activeDays: activeDays.size,
     topModel: top?.model ?? '',
     topProvider: top?.provider ?? '',
     daily,
@@ -218,18 +219,20 @@ export function aggregateRange(rows, g, from, to) {
   return result
 }
 
-// 聚合计价的槽定位:D 折叠到日槽,H/M 即本槽,计价一律取行所属 H 槽起点
+// 鑱氬悎璁′环鐨勬Ы瀹氫綅:D 鎶樺彔鍒版棩妲?H/M 鍗虫湰妲?璁′环涓€寰嬪彇琛屾墍灞?H 妲借捣鐐?
 const COST_SLOT_KEYS = {
   [GRANULARITY_DAILY]: (bucket) => bucket.slice(0, DAY_KEY_WIDTH),
   [GRANULARITY_HOURLY]: (bucket) => bucket,
   [GRANULARITY_MINUTE]: (bucket) => bucket,
 }
 
-// 聚合计价:以可见槽为唯一口径,cost 行按 H 槽起点匹配价格后累加;
+// 鑱氬悎璁′环:浠ュ彲瑙佹Ы涓哄敮涓€鍙ｅ緞,cost 琛屾寜 H 妲借捣鐐瑰尮閰嶄环鏍煎悗绱姞;
+// 妲界骇閫愭ā鍨嬫媶鍒?costByModel 渚涢噾棰濇煴鐘跺浘鎸夋ā鍨嬪爢鍙?
 export function attachCosts(result, costRows, granularity, rules) {
   const slotKeyOf = COST_SLOT_KEYS[granularity]
   const slotOfDay = new Map(result.daily.map((slot) => [slot.day, slot]))
   const slotCosts = new Map()
+  const slotCostsByModel = new Map()
   const modelCosts = new Map(result.models.map((entry) => [entry.model, 0]))
   const unpricedHours = new Set()
   for (const row of costRows) {
@@ -245,9 +248,19 @@ export function attachCosts(result, costRows, granularity, rules) {
     }
     const cost = costOf(price, row)
     slotCosts.set(slot.day, (slotCosts.get(slot.day) ?? 0) + cost)
+    let perModel = slotCostsByModel.get(slot.day)
+    if (perModel === undefined) {
+      perModel = new Map()
+      slotCostsByModel.set(slot.day, perModel)
+    }
+    perModel.set(row.model, (perModel.get(row.model) ?? 0) + cost)
     if (modelCosts.has(row.model)) modelCosts.set(row.model, modelCosts.get(row.model) + cost)
   }
-  const daily = result.daily.map((slot) => ({ ...slot, cost: slotCosts.get(slot.day) ?? 0 }))
+  const daily = result.daily.map((slot) => ({
+    ...slot,
+    cost: slotCosts.get(slot.day) ?? 0,
+    costByModel: Object.fromEntries(slotCostsByModel.get(slot.day) ?? []),
+  }))
   const cost = daily.reduce((sum, slot) => sum + slot.cost, 0)
   const models = result.models.map((entry) => ({ ...entry, cost: modelCosts.get(entry.model) }))
   return { ...result, daily, models, cost, unpriced: unpricedHours.size }

package/test/client-id.test.mjs

@@ -0,0 +1,26 @@
+// client.js 注册 id 与样式标记守卫:loader 按 graph row id(完整包名)匹配注册,短名即加载失败;
+// 样式查重键 STYLE_ID 兼作 data-plugin 标记值,短名会使自身 rebuilt 删不到旧样式,重注被跳过。
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+const { name } = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'))
+
+test('client.js 注册 id 为完整包名', () => {
+  const source = readFileSync(join(PKG_ROOT, 'src', 'client.js'), 'utf8')
+  const match = source.match(/__ModuleLoader__\.load\(\{\s*id:\s*'([^']+)'/)
+  assert.ok(match, 'client.js 缺少 __ModuleLoader__.load 注册')
+  assert.equal(match[1], name)
+})
+
+test('client.js 样式注入自带 data-plugin 且值为注册包名', () => {
+  const source = readFileSync(join(PKG_ROOT, 'src', 'client.js'), 'utf8')
+  const injections = source.split("createElement('style')").length - 1
+  assert.ok(injections > 0, 'client.js 无样式注入点')
+  assert.ok(source.includes(`STYLE_ID = '${name}'`), 'STYLE_ID 必须等于注册包名(值=注册 id),短名会使自身 rebuilt 删不到旧样式')
+  const marked = source.split("setAttribute('data-plugin'").length - 1
+  assert.equal(marked, injections, '每个样式注入点都必须设置 data-plugin,防宿主 claimStyles 误归属后随他插件 HMR 整批误删')
+})

package/test/client.test.mjs

@@ -36,16 +36,20 @@ const {
   OTHER_MODEL,
   aggregateCurrencyOf,
   applyCurrencyToRules,
+  avgPriceText,
   cacheRateText,
+  cardsStatsOf,
   coerceConditions,
   coercePricingRules,
   costOf,
+  costSlotsOf,
   costTitleText,
   createTranslator,
   daysInRange,
   defaultCondition,
   defaultPricingRule,
   donutSegments,
+  formatCostCompact,
   pointStatsMatches,
   formatCompact,
   formatCost,
@@ -68,8 +72,12 @@ const {
   maxSlotsFor,
   minuteTickLabel,
   modelIoPercentText,
+  moneyViewOf,
   hasTipContent,
+  hasAnomalyNews,
   tipModelEntries,
+  tipAvgPriceText,
+  trendDefaultVisibleKeys,
   modelSegmentLabel,
   modelSpeedText,
   modelNameOf,
@@ -107,9 +115,13 @@ const {
   speedTipText,
   speedScaleMax,
   legendToggle,
+  LEGEND_KEY_RATE,
+  LEGEND_KEY_SPEED,
+  LEGEND_KEY_TTFT,
   leftAxisTicks,
   hourSlotLabel,
   minuteSlotLabel,
+  usageModelsOf,
   validatePricingRules,
 } = core
 
@@ -159,10 +171,12 @@ test('预设定义表覆盖三视图', () => {
   assert.deepEqual(MINUTE_PRESETS, ['3h', '24h', '3d', '7d'])
 })
 
-test('默认挡位均在其挡位列表内,分钟窗口可解析', () => {
+test('默认挡位均在其挡位列表内,分钟默认挡为最短窗口 3 小时,分钟窗口可解析', () => {
   assert.ok(DAY_PRESETS.includes(DEFAULT_RANGE))
   assert.ok(HOUR_PRESETS.includes(DEFAULT_HOUR_PRESET))
   assert.ok(MINUTE_PRESETS.includes(DEFAULT_MINUTE_PRESET))
+  // Given 分钟视图初始挂载 When 取默认挡 Then 为 3 小时(分钟粒度下 24 小时过粗,近端细节优先)
+  assert.equal(DEFAULT_MINUTE_PRESET, '3h')
   assert.notEqual(resolveMinuteRange(DEFAULT_MINUTE_PRESET, NOW), null)
 })
 
@@ -450,6 +464,35 @@ test('groupPointSlots 窗口模型超上限折叠其他', () => {
   assert.deepEqual(grouped.daily[0].byModel, { m1: 1, m2: 1, m3: 1, m4: 1, m6: 1, [OTHER_MODEL]: 1 })
 })
 
+test('cardsStatsOf 天视图用 range 聚合,时/分视图用点聚合,点未回为 null', () => {
+  const stats = { tokens: 1 }
+  const pointView = { tokens: 2 }
+  assert.equal(cardsStatsOf('day', stats, pointView), stats)
+  assert.equal(cardsStatsOf('hour', stats, pointView), pointView)
+  assert.equal(cardsStatsOf('minute', stats, null), null)
+})
+
+test('usageModelsOf 天视图用预折叠分组,时/分视图折叠点窗口模型,点未回为 null', () => {
+  const grouped = { models: [{ model: 'p/m1', tokens: 1 }] }
+  assert.equal(usageModelsOf('day', grouped, null), grouped.models)
+  assert.equal(usageModelsOf('day', null, null), null)
+  const ranked = [
+    { model: 'p/m1', tokens: 3 },
+    { model: 'p/m2', tokens: 2 },
+    { model: 'p/m3', tokens: 1 },
+    { model: 'p/m4', tokens: 1 },
+    { model: 'p/m5', tokens: 1 },
+    { model: 'p/m6', tokens: 1 },
+  ]
+  const folded = usageModelsOf('hour', null, { models: ranked })
+  assert.equal(folded.length, 6)
+  assert.equal(folded.at(-1).model, OTHER_MODEL)
+  assert.equal(folded.at(-1).tokens, 1)
+  // 空窗口契约:返回空数组渲染空环(与天视图空数据行为一致),非 null 隐藏
+  assert.deepEqual(usageModelsOf('minute', null, { models: [] }), [])
+  assert.equal(usageModelsOf('minute', null, null), null)
+})
+
 test('niceTicks 产生 1/2/5 序列且零上限为空', () => {
   assert.deepEqual(niceTicks(0, 4), [])
   assert.deepEqual(niceTicks(50, 4), [20, 40])
@@ -694,7 +737,7 @@ test('speedTipText 无速度为占位符有速度为官方吞吐口径', () => {
 })
 
 test('legendToggle 普通点击单选,再点恢复全部,ctrl 多选且禁全藏', () => {
-  // null 表示全部可见
+  // null 输入(仅 historic 契约面):普通点击得单键集
   assert.deepEqual(legendToggle(null, 'a', false), new Set(['a']))
   // 单选态再点同项恢复全部(null)
   assert.equal(legendToggle(new Set(['a']), 'a', false), null)
@@ -972,6 +1015,44 @@ test('formatCost 微观值四位小数', () => {
   assert.equal(formatCost(0.009999, '$'), '$0.0100')
 })
 
+test('avgPriceText 费用折每百万 token 均价', () => {
+  assert.equal(avgPriceText(3357.85, 6232901270, '¥'), '¥0.539/M')
+  assert.equal(avgPriceText(2, 1000 * 1000, '$'), '$2.000/M')
+  assert.equal(avgPriceText(0.5, 1000 * 1000, ''), '0.500/M')
+  assert.equal(avgPriceText(0.0004, 1000 * 1000, '¥'), '¥0.00040/M')
+})
+
+test('avgPriceText 无费用或零 token 不显示', () => {
+  assert.equal(avgPriceText(undefined, 6232901270, '¥'), '')
+  assert.equal(avgPriceText(0, 6232901270, '¥'), '')
+  assert.equal(avgPriceText(3357.85, 0, '¥'), '')
+})
+
+test('tipAvgPriceText 槽费用折每百万 token 均价,无费用或零槽为 null', () => {
+  assert.equal(tipAvgPriceText({ total: 6232901270, cost: 3357.85 }, '¥'), '¥0.539/M')
+  assert.equal(tipAvgPriceText({ total: 6232901270, cost: 0 }, '¥'), null)
+  assert.equal(tipAvgPriceText({ total: 6232901270 }, '¥'), null)
+  assert.equal(tipAvgPriceText({ total: 0, cost: 3357.85 }, '¥'), null)
+})
+
+test('trendDefaultVisibleKeys 默认集含模型与速度线,不含缓存命中率与首 token 延迟', () => {
+  const keys = trendDefaultVisibleKeys(['m1', 'm2'], true)
+  assert.deepEqual([...keys], ['m1', 'm2', 'speed'])
+  assert.deepEqual([...trendDefaultVisibleKeys(['m1'], false)], ['m1'])
+  assert.deepEqual([...trendDefaultVisibleKeys([], false)], [])
+})
+
+test('图例默认态点击以实际生效集为基线,ctrl 恢复隐藏线不坍缩', () => {
+  const base = trendDefaultVisibleKeys(['m1', 'm2'], true)
+  // ctrl 点击默认隐藏的缓存命中率:默认集其余项保持,仅追加该线;再点回默认集
+  const withRate = legendToggle(base, LEGEND_KEY_RATE, true)
+  assert.deepEqual([...withRate].sort(), ['m1', 'm2', LEGEND_KEY_SPEED, LEGEND_KEY_RATE].sort())
+  assert.deepEqual([...legendToggle(withRate, LEGEND_KEY_RATE, true)].sort(), ['m1', 'm2', LEGEND_KEY_SPEED].sort())
+  // 普通点击单选隐藏线,再点回 null 由调用方 ?? 默认集承接
+  assert.deepEqual([...legendToggle(base, LEGEND_KEY_TTFT, false)], [LEGEND_KEY_TTFT])
+  assert.equal(legendToggle(new Set([LEGEND_KEY_TTFT]), LEGEND_KEY_TTFT, false), null)
+})
+
 test('镜像函数基本行为:非法输入 null 与命中计价', () => {
   assert.equal(matchPrice(null, 'x/m', NOW), null)
   assert.equal(matchPrice([], 'x/m', NOW), null)
@@ -1268,3 +1349,104 @@ test('removeRulesAt 批量移除组内槽位', () => {
   const rest = removeRulesAt(rules, [0, 2])
   assert.deepEqual(rest.map((rule) => rule.model), ['b/1'])
 })
+
+test('groupStats 折叠金额双映射:top 模型费用透传,其余归哨兵并保留明细', () => {
+  // Given 逐槽 costByModel 含 top 与非 top 模型 When 折叠 Then byCostModel 归并哨兵,otherCostByModel 保留非 top 明细
+  const stats = {
+    models: [
+      { model: 'p/m1', tokens: 500 },
+      { model: 'p/m2', tokens: 400 },
+      { model: 'p/m3', tokens: 300 },
+      { model: 'p/m4', tokens: 200 },
+      { model: 'p/m5', tokens: 100 },
+      { model: 'p/m6', tokens: 50 },
+    ],
+    daily: [{
+      day: 'd',
+      total: 110,
+      byModel: { 'p/m1': 50, 'p/m2': 40, 'p/m6': 20 },
+      costByModel: { 'p/m1': 2, 'p/m2': 2, 'p/m6': 0.5 },
+    }],
+  }
+  const grouped = groupStats(stats)
+  assert.deepEqual(grouped.daily[0].byCostModel, { 'p/m1': 2, 'p/m2': 2, [OTHER_MODEL]: 0.5 })
+  assert.deepEqual(grouped.daily[0].otherCostByModel, { 'p/m6': 0.5 })
+})
+
+test('groupStats 无费用槽金额映射为空表', () => {
+  // Given 槽无 costByModel When 折叠 Then byCostModel/otherCostByModel 恒在场为空表
+  const stats = {
+    models: [{ model: 'p/m1', tokens: 500 }],
+    daily: [{ day: 'd', total: 10, byModel: { 'p/m1': 10 } }],
+  }
+  const grouped = groupStats(stats)
+  assert.deepEqual(grouped.daily[0].byCostModel, {})
+  assert.deepEqual(grouped.daily[0].otherCostByModel, {})
+})
+
+test('costSlotsOf 槽投影切金额口径:total/byModel/otherByModel 取费用字段', () => {
+  // Given 折叠后带费用字段的槽 When 投影 Then total=cost、byModel=byCostModel、otherByModel=otherCostByModel,其余字段保留
+  const slots = [
+    { day: 'd1', total: 100, cost: 2.5, byModel: { a: 60, b: 40 }, byCostModel: { a: 1.5, b: 1 }, otherByModel: {}, otherCostByModel: {} },
+    { day: 'd2', total: 10, cost: 0, byModel: { a: 10 }, byCostModel: {}, otherByModel: {}, otherCostByModel: {} },
+  ]
+  const out = costSlotsOf(slots)
+  assert.equal(out[0].total, 2.5)
+  assert.deepEqual(out[0].byModel, { a: 1.5, b: 1 })
+  assert.deepEqual(out[0].otherByModel, {})
+  assert.equal(out[0].day, 'd1')
+  assert.equal(out[1].total, 0)
+  assert.deepEqual(out[1].byModel, {})
+})
+
+test('moneyViewOf 门控:存在正计价槽才可用,关或不可用保持 token 口径', () => {
+  // Given 槽含正计价与零计价 When 开关开 Then 可用且切金额;Given 全零计价/开关关/无槽 When 派生 Then 不可用且不投影
+  const slots = [
+    { day: 'd1', total: 10, cost: 0.5, byModel: { a: 10 }, byCostModel: { a: 0.5 }, otherByModel: {}, otherCostByModel: {} },
+    { day: 'd2', total: 5, cost: 0, byModel: { a: 5 }, byCostModel: {}, otherByModel: {}, otherCostByModel: {} },
+  ]
+  const on = moneyViewOf(slots, true)
+  assert.equal(on.costReady, true)
+  assert.equal(on.money, true)
+  assert.equal(on.chartSlots[0].total, 0.5)
+  const zeroOnly = [slots[1]]
+  const allZero = moneyViewOf(zeroOnly, true)
+  assert.equal(allZero.costReady, false)
+  assert.equal(allZero.money, false)
+  assert.equal(allZero.chartSlots, zeroOnly)
+  assert.equal(allZero.chartSlots[0].total, 5)
+  const off = moneyViewOf(slots, false)
+  assert.equal(off.costReady, true)
+  assert.equal(off.money, false)
+  assert.equal(off.chartSlots, slots)
+  const none = moneyViewOf(null, true)
+  assert.deepEqual(none, { costReady: false, money: false, chartSlots: null })
+})
+
+test('formatCostCompact 金额轴紧凑读数:千以上 k/M 一位小数,分上两位内,分下四位', () => {
+  assert.equal(formatCostCompact(1234567, '¥'), '¥1.2M')
+  assert.equal(formatCostCompact(1234, '¥'), '¥1.2k')
+  assert.equal(formatCostCompact(12.345, '$'), '$12.35')
+  assert.equal(formatCostCompact(0.1, '¥'), '¥0.1')
+  assert.equal(formatCostCompact(0.005, '¥'), '¥0.005')
+  assert.equal(formatCostCompact(0, ''), '0')
+})
+
+test('leftAxisTicks 金额格式化:柱刻度走传入格式化,速度刻度仍紧凑 token', () => {
+  // Given 金额格式化器 When 柱刻度标定 Then 标签走金额格式;Given 速度刻度接管 Then 标签仍 token 紧凑
+  const money = leftAxisTicks([50, 100], 100, [], 0, (value) => `¥${value}`)
+  assert.deepEqual(money.map((tick) => tick.label), ['¥50', '¥100'])
+  const speed = leftAxisTicks([], 100, [5, 10], 10, (value) => `¥${value}`)
+  assert.deepEqual(speed.map((tick) => tick.label), ['5', '10'])
+})
+
+test('hasAnomalyNews 折叠提醒判定:有异常日志或写入失败即提醒', () => {
+  // Given 日志有条目 When 判定 Then true;Given 仅写入失败计数 When 判定 Then true
+  assert.equal(hasAnomalyNews({ log: [{ time: 0, kind: 'record', detail: 'x' }] }), true)
+  assert.equal(hasAnomalyNews({ log: [], recordFailures: 1 }), true)
+  assert.equal(hasAnomalyNews({ log: [{ time: 0, kind: 'skipped', detail: 'y' }], recordFailures: 0 }), true)
+  // Given 全空/字段缺席/null When 判定 Then false
+  assert.equal(hasAnomalyNews({ log: [], recordFailures: 0 }), false)
+  assert.equal(hasAnomalyNews({}), false)
+  assert.equal(hasAnomalyNews(null), false)
+})

package/test/collector.test.mjs

@@ -766,6 +766,30 @@ test('采集侧 store 失败计入 recordFailures 且不抛断采集', async ()
   assert.equal(store.samples.length, 0)
 })
 
+test('flush 聚合失败日志展开底层行错误,不只剩包装文案', async () => {
+  const { store, collector } = liveCollector()
+  // Given store 上抛含两行底层失败的 AggregateError When 接入日志 Then detail 展开各原因
+  store.onFlushError(new AggregateError(
+    [new Error('boom A'), new Error('boom B')],
+    'usage store flush failed',
+  ))
+  const entry = collector.status().log.at(-1)
+  assert.equal(entry.kind, 'record')
+  assert.equal(entry.detail, 'usage store flush failed: boom A; boom B')
+  assert.equal(collector.status().recordFailures, 1)
+})
+
+test('flush 聚合失败日志截断保护:超长底层错误不撑爆日志行', async () => {
+  const { store, collector } = liveCollector()
+  store.onFlushError(new AggregateError(
+    [new Error('x'.repeat(2000))],
+    'usage store flush failed',
+  ))
+  const entry = collector.status().log.at(-1)
+  assert.ok(entry.detail.length <= 600)
+  assert.ok(entry.detail.startsWith('usage store flush failed'))
+})
+
 test('session/disposed 后该会话去重状态重置', async () => {
   const { ctx, store } = liveCollector()
   const t = local(2026, 8, 2, 10, 0)

package/test/query.test.mjs

@@ -183,6 +183,23 @@ test('H 粒度零值槽全枚举含无数据槽', () => {
   assert.equal(out.activeDays, 1)
 })
 
+test('H/M 粒度活跃天数为有用量自然日数,同日多桶计 1', () => {
+  const hourRows = [
+    makeRow({ bucket: '2020-01-01T01', model: 'm1', provider: 'p1', inputTokens: 5 }),
+    makeRow({ bucket: '2020-01-01T05', model: 'm1', provider: 'p1', inputTokens: 5 }),
+    makeRow({ bucket: '2020-01-02T01', model: 'm1', provider: 'p1', inputTokens: 5 }),
+  ]
+  const hourOut = aggregateRange(hourRows, 'H', '2020-01-01T00', '2020-01-02T23')
+  assert.equal(hourOut.activeDays, 2)
+  const minuteRows = [
+    makeRow({ bucket: '2020-01-01T00:00', model: 'm1', provider: 'p1', inputTokens: 5 }),
+    makeRow({ bucket: '2020-01-01T00:10', model: 'm1', provider: 'p1', inputTokens: 5 }),
+    makeRow({ bucket: '2020-01-01T00:20', model: 'm1', provider: 'p1', inputTokens: 5 }),
+  ]
+  const minuteOut = aggregateRange(minuteRows, 'M', '2020-01-01T00:00', '2020-01-01T23:50')
+  assert.equal(minuteOut.activeDays, 1)
+})
+
 test('M 粒度纯计数行不计入模型与活跃桶,未对齐残行跳过', () => {
   const rows = [
     makeRow({ bucket: '2020-01-01T00:00', model: '(turns)', provider: 'default', turns: 1 }),
@@ -574,3 +591,53 @@ test('attachCosts 计价时间恒为 H 桶起点(非分钟/日起点)', () => {
   const dayOut = attachCosts(dayResult, hourRows, 'D', [dayWindow, ruleOf({ price: inputPrice(3) })])
   assert.deepEqual(dayOut.daily.map((slot) => slot.cost), [1, 3])
 })
+
+test('attachCosts 槽级 costByModel 按模型拆分费用', () => {
+  // Given 同桶两模型不同单价 When H 槽计价 Then 槽 costByModel 为逐模型费用,合计等于槽 cost
+  const rows = [
+    makeRow({ bucket: '2020-01-01T01', model: 'm1', inputTokens: 1000000 }),
+    makeRow({ bucket: '2020-01-01T01', model: 'm2', inputTokens: 1000000 }),
+  ]
+  const result = aggregateRange(rows, 'H', '2020-01-01T00', '2020-01-01T01')
+  const out = attachCosts(result, rows, 'H', [ruleOf({ price: inputPrice(1) })])
+  assert.deepEqual(out.daily[1].costByModel, { m1: 1, m2: 1 })
+  assert.equal(out.daily[1].cost, 2)
+  // 纯函数:入参 result 不被修改
+  assert.equal('costByModel' in result.daily[1], false)
+})
+
+test('attachCosts D 折叠按日归集 costByModel', () => {
+  // Given 同模型 H 行落同日多桶 When D 计价 Then 日槽 costByModel 为该模型桶累加
+  const costRows = [
+    makeRow({ bucket: '2020-01-01T22', model: 'm1', inputTokens: 1000000 }),
+    makeRow({ bucket: '2020-01-01T23', model: 'm1', inputTokens: 500000 }),
+  ]
+  const aggregateRows = [makeRow({ bucket: '2020-01-01', model: 'm1', inputTokens: 1500000 })]
+  const result = aggregateRange(aggregateRows, 'D', '2020-01-01', '2020-01-01')
+  const out = attachCosts(result, costRows, 'D', [ruleOf({ price: inputPrice(2) })])
+  assert.deepEqual(out.daily[0].costByModel, { m1: 3 })
+})
+
+test('attachCosts 无规则或无费用槽 costByModel 为空表', () => {
+  // Given 无命中规则 When 计价 Then 全部槽挂空表,unpriced 照常计数
+  const rows = [
+    makeRow({ bucket: '2020-01-01T01', model: 'm1', inputTokens: 5 }),
+    makeRow({ bucket: '2020-01-01T02', model: 'm1', inputTokens: 5 }),
+  ]
+  const result = aggregateRange(rows, 'H', '2020-01-01T00', '2020-01-01T02')
+  const out = attachCosts(result, rows, 'H', [])
+  assert.deepEqual(out.daily.map((slot) => slot.costByModel), [{}, {}, {}])
+  assert.equal(out.unpriced, 2)
+})
+
+test('attachCosts M 槽 costByModel 按模型拆分', () => {
+  // Given 同分钟桶两模型 When M 计价 Then 分钟槽 costByModel 为逐模型费用
+  const rows = [
+    makeRow({ bucket: '2020-01-01T01:10', model: 'm1', inputTokens: 500000 }),
+    makeRow({ bucket: '2020-01-01T01:10', model: 'm2', inputTokens: 500000 }),
+  ]
+  const result = aggregateRange(rows, 'M', '2020-01-01T01:10', '2020-01-01T01:10')
+  const out = attachCosts(result, rows, 'M', [ruleOf({ price: inputPrice(1) })])
+  assert.deepEqual(out.daily[0].costByModel, { m1: 0.5, m2: 0.5 })
+  assert.equal(out.daily[0].cost, 1)
+})