dsh-peak-hours 1.11.0 → 1.12.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 更新日志
 
+## 1.12.1 — 2026-10-30
+
+### 修正
+
+- **侧栏角标只剩一行文字、圆点和日程条消失**：根节点上的 `aria-label` 会被 `sidebar.footer.action` 的所有者当成「行文本」投影出来，整个组件子树被替换成一行纯文本。现已移除该属性（无障碍名交给可见文本 + `title`），并在源码里留下注释，避免回归。
+
+## 1.12.0 — 2026-10-29
+
+### 新增
+
+- **设置页「高峰/空闲用量与费用对比」卡片**（`settings.general.item`，排在「性能与用量」之后）：把本机会话日志里的每个请求按**发生时刻的北京时间**归到高峰或空闲，按模型价目表折算成钱，给出近 7 天 / 近 30 天 / 全部三个区间的「实际花费、全高峰、全空闲、省下的钱与比例、高峰占比、分模型明细」。想查「我到底因为错峰省了多少」时，不用再手算。
+- **host 半**：`index.js` 注册 `GET /dsh-peak-hours/api/usage`，60 秒 TTL + `?fresh=1` 强制刷新 + in-flight 去重；`lib/zstd.js` 自己按帧切开多帧 zstd 会话日志（`zlib.zstdDecompressSync` 只能解首帧），`lib/usage.js` 增量扫描并按文件大小/修改时间缓存到 `~/.dsh/storages/peak-hours/cache.json`。
+- 新增 10 个用例覆盖 host 半（窗口边界、周末/节假日、模型分类、价格公式、`turn+step` 替换、分桶、费用对比、区间过滤），测试总数 15 → 24。
+
+### 修正
+
+- 分模型明细里同名模型（如 `deepseek-account/deepseek-flash` 与 `deepseek-official/deepseek-flash`）不再显示成两行一模一样，第二个起会带提供商后缀（`· personal` / `· official`）。
+
 ## 1.11.0 — 2026-10-29
 
 ### 修正

package/README.md

@@ -1,6 +1,9 @@
 # dsh-peak-hours
 
-一个 DeepSeek Harness 的侧栏角标：**现在是不是高峰计价时段**。
+一个 DeepSeek Harness 插件，做两件事：
+
+1. **侧栏角标**：现在是不是高峰计价时段；
+2. **设置页卡片**：把你自己的用量按高峰/空闲拆开，并算出「实际花了多少」对比「全在高峰 / 全在空闲要花多少」。
 
 ![侧栏角标](screenshots/screenshot-1.png)
 
@@ -36,6 +39,24 @@
 
 时间一律按北京时间（UTC+8）算，和你浏览器的时区无关。
 
+## 用量与费用对比（设置 → 通用）
+
+除了角标，插件还在「设置 → 通用」里加了一行 **高峰/空闲用量与费用对比**（`settings.general.item`，排在「性能与用量」后面）。它读取本机 DeepSeek Harness 的会话日志，把每个请求按它发生的**北京时间**归到高峰或空闲，然后按模型价目表折算成钱：
+
+- **三个区间**：近 7 天 / 近 30 天 / 全部
+- **三笔钱**：实际花费（高峰按 ×2、空闲按 ×1）、假如全部落在高峰、假如全部落在空闲
+- **省下的钱与比例**：`¥68.49 · 35.5%` 这样
+- **用量拆分**：高峰 token、空闲 token、合计、高峰占比，配一条橙/蓝比例条
+- **分模型**：前四个模型各自的 token 与费用
+
+口径与限制（重要，也是诚实的地方）：
+
+- 只统计**能对上 DeepSeek 价目表**的模型（`deepseek-flash` 按 flash 价、`deepseek-v4-pro` / reasoner 按 pro 价）；其他供应商（claude、gpt、qmodel 等）只计 token、不计入费用，并在说明里单独标注
+- 价目表同样内置在 `lib/schedule.js`（元/百万 tokens，空闲→高峰）：flash 命中 0.02→0.04、未命中 1→2、输出 4→8；pro 命中 0.15→0.30、未命中 4.5→9、输出 13.5→27
+- 同一 `turn`+`step` 的多次采样按**最后一次**算（会话流式输出会反复覆盖同一步的用量），不会重复累加
+- 数据来自本机会话日志 `~/.dsh/sessions/<工作区>/<会话>/session.v4.jsonl.zstd`，**只在本地读、不外发**；解析结果按文件大小与修改时间缓存到 `~/.dsh/storages/peak-hours/cache.json`，第二次打开是毫秒级
+- 用量接口也有 60 秒 TTL，卡片上的「刷新」会跳过缓存重新扫一遍
+
 ## 安装
 
 从 npm：
@@ -61,17 +82,23 @@ dsh plugin --profile web remove dsh-peak-hours
 ## 兼容性
 
 - 需要带客户端 UI 的 DeepSeek Harness Web GUI（`dsh.client` 声明为 `platform: web`）
-- 纯客户端插件：不注册 host 工具、不写文件、不发网络请求、不需要任何配置或凭据
+- 客户端 + 一个只读的 host 半：host 半注册一条 `GET /dsh-peak-hours/api/usage`，读取本机会话日志算峰谷账，**不发任何网络请求**；除 `~/.dsh/storages/peak-hours/cache.json` 这一份解析缓存外不写文件，不需要任何配置或凭据
+- 角标部分纯客户端，不依赖 host 半；即使 host 半取数失败，角标照常工作
 - 颜色是固定值（高峰 `#f59e0b`、空闲 `#4d6bfe`，即 DeepSeek 品牌蓝），不跟随主题 `brand-primary`，以免换皮肤后蓝色被改成别的色
 
 ## 开发
 
 ```sh
-npm test          # 15 个单元测试（node --test，零依赖）
+npm test          # 24 个单元测试（node --test，零依赖）
 npm run verify    # npm pack --dry-run，检查发布清单
 ```
 
-测试通过 `vm` 加载 `client.js`，用最小的 React / locale / document 替身渲染组件，因此不用起 GUI 也能验证时段判定、分段宽度、折叠态与复制逻辑。
+测试分两块，全部零依赖、不用起 GUI：
+
+- `test/schedule.test.mjs`：通过 `vm` 加载 `client.js`，用最小的 React / locale / document 替身渲染角标，验证时段边界、日程条分段与宽度、游标位置、折叠态、复制与中英文 key 对齐
+- `test/usage.test.mjs`：直接测 host 半的 `lib/schedule.js` 与 `lib/usage.js`，用合成事件验证窗口判定、节假日、模型分类、价格公式、`turn+step` 替换语义、按日+小时+模型分桶、峰谷费用对比与区间过滤
+
+设置页卡片还有一个独立的 headless 渲染检查（真实接口数据 + 最小 hooks 替身），确认取数成功后不会渲染崩溃。
 
 ## 许可
 

package/client.js

@@ -334,7 +334,53 @@ window.__ModuleLoader__.load({
       }
       .dshph-rail .dshph-track { width: 26px; height: 6px; }
       .dshph-rail .dshph-cursor { width: 1.5px; }
-      @media (prefers-reduced-motion: reduce) {
+
+      /* ---- 峰谷用量与费用卡片（设置页） ---- */
+      .dshphu-card {
+        --dshphu-peak: #f59e0b;
+        --dshphu-off: #4d6bfe;
+        display: flex; flex-direction: column; gap: 10px;
+        box-sizing: border-box; width: 100%; min-width: 0;
+        padding: 12px 14px; border-radius: 10px;
+        border: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, .18));
+        background: var(--dsw-alias-bg-layer-1, transparent);
+        font-family: inherit; font-size: 14px; font-size: .875rem;
+        line-height: 1.45; color: var(--dsw-alias-label-primary);
+      }
+      .dshphu-head { display: flex; align-items: flex-start; gap: 10px; min-width: 0; }
+      .dshphu-titles { flex: 1 1 auto; min-width: 0; }
+      .dshphu-title { font-weight: 600; }
+      .dshphu-desc { color: var(--dsw-alias-label-secondary); font-size: .92em; }
+      .dshphu-seg { flex: none; display: flex; gap: 4px; }
+      .dshphu-segBtn {
+        font: inherit; font-size: .92em; cursor: pointer;
+        padding: 2px 9px; border-radius: 999px;
+        border: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, .18));
+        background: transparent; color: var(--dsw-alias-label-secondary);
+      }
+      .dshphu-segBtn[data-on='1'] {
+        color: #fff; border-color: transparent; background: var(--dshphu-off);
+      }
+      .dshphu-kpis { display: flex; flex-wrap: wrap; gap: 14px; }
+      .dshphu-kpi { min-width: 96px; }
+      .dshphu-kpiLabel { color: var(--dsw-alias-label-secondary); font-size: .92em; }
+      .dshphu-kpiValue { font-size: 1.18em; font-weight: 600; }
+      .dshphu-kpiValue[data-tone='peak'] { color: var(--dshphu-peak); }
+      .dshphu-kpiValue[data-tone='save'] { color: var(--dshphu-off); }
+      .dshphu-bar {
+        display: flex; height: 8px; border-radius: 999px; overflow: hidden;
+        background: var(--dsw-alias-bg-layer-2);
+      }
+      .dshphu-barPeak { background: var(--dshphu-peak); }
+      .dshphu-barOff { background: var(--dshphu-off); }
+      .dshphu-line { color: var(--dsw-alias-label-secondary); font-size: .92em; }
+      .dshphu-models { display: flex; flex-direction: column; gap: 3px; }
+      .dshphu-model { display: flex; gap: 8px; align-items: baseline; font-size: .92em; }
+      .dshphu-modelName { flex: 1 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      .dshphu-modelNum { flex: none; color: var(--dsw-alias-label-secondary); }
+      .dshphu-note { color: var(--dsw-alias-label-secondary); font-size: .88em; }
+      .dshphu-err { color: var(--dsw-alias-state-error-primary, #d33); font-size: .92em; }
+          @media (prefers-reduced-motion: reduce) {
         .dshph-root, .dshph-root * {
           animation: none !important; transition: none !important;
         }
@@ -388,6 +434,27 @@ window.__ModuleLoader__.load({
       'copy.ok': '已复制',
       'copy.fail': '复制失败',
       'copy.suffix': '（北京时间）',
+      'usage.title': '峰谷用量与费用',
+      'usage.desc': '来自本地会话日志：按高峰/空闲拆分 tokens，并按峰谷价折算费用',
+      'usage.range': '统计区间',
+      'usage.range.7': '近 7 天',
+      'usage.range.30': '近 30 天',
+      'usage.range.all': '全部',
+      'usage.actual': '实际花费',
+      'usage.allPeak': '全在高峰',
+      'usage.saved': '比全高峰省',
+      'usage.peakTokens': '高峰',
+      'usage.offTokens': '空闲',
+      'usage.totalTokens': '合计',
+      'usage.peakShare': '高峰占比',
+      'usage.refresh': '重新统计',
+      'usage.refreshHint': '点击右上角区间可切换',
+      'usage.loading': '统计中…（首次需扫描本地会话日志）',
+      'usage.error': '读取失败：',
+      'usage.empty': '暂无用量记录',
+      'usage.note': '仅 deepseek 系模型按峰谷价折算；其他供应商 {tokens} tokens 计入用量、不计费',
+      'usage.meta': '扫描 {sessions} 个会话 · 活跃 {days} 天',
+
     };
 
     const EN = {
@@ -424,6 +491,27 @@ window.__ModuleLoader__.load({
       'copy.ok': 'Copied',
       'copy.fail': 'Copy failed',
       'copy.suffix': '(Beijing time)',
+      'usage.title': 'Peak / off-peak usage and cost',
+      'usage.desc': 'From local session logs: tokens split by peak/off-peak, priced at the peak/off-peak rates',
+      'usage.range': 'Range',
+      'usage.range.7': '7 days',
+      'usage.range.30': '30 days',
+      'usage.range.all': 'All',
+      'usage.actual': 'Actual spend',
+      'usage.allPeak': 'All at peak',
+      'usage.saved': 'Saved vs all-peak',
+      'usage.peakTokens': 'Peak',
+      'usage.offTokens': 'Off-peak',
+      'usage.totalTokens': 'Total',
+      'usage.peakShare': 'Peak share',
+      'usage.refresh': 'Rescan',
+      'usage.refreshHint': 'Switch ranges above',
+      'usage.loading': 'Scanning… (first run reads local session logs)',
+      'usage.error': 'Failed to load: ',
+      'usage.empty': 'No usage yet',
+      'usage.note': 'Only DeepSeek models are priced here; {tokens} tokens from other providers count as usage, not money',
+      'usage.meta': '{sessions} sessions scanned · {days} active days',
+
     };
 
     let translate = (key) => (EN[key] !== undefined ? EN[key] : key);
@@ -495,14 +583,14 @@ window.__ModuleLoader__.load({
         h('span', { key: 'cursor', className: 'dshph-cursor', style: { left: cursorLeft } }),
       );
 
+      // 根节点**不要**放 aria-label / aria-labelledby：sidebar.footer.action 的所有者
+      // 会把这个属性当行文本投影出来，整个子树被换成一行纯文本（圆点、日程条都会消失，
+      // 1.11.0 起踩过这个坑）。无障碍名交给可见文本 + title。
       const common = {
         title,
-        role: 'button',
         tabIndex: 0,
         onClick: onCopy,
         onKeyDown,
-        'aria-label':
-          t('label') + ': ' + stateText + ', ' + remaining + '. ' + t('tip.hint'),
       };
 
       if (!wide) {
@@ -538,6 +626,241 @@ window.__ModuleLoader__.load({
       );
     }
 
+
+    // ---------------------------------------------------------------------
+    // 峰谷用量与费用（设置页卡片）
+    // ---------------------------------------------------------------------
+    const USAGE_API = '/dsh-peak-hours/api/usage';
+    const RANGES = ['7', '30', 'all'];
+    let usageCache = null;
+
+    function fmtTokens(n) {
+      const v = Number(n) || 0;
+      if (v >= 1e8) return (v / 1e8).toFixed(2) + ' 亿';
+      if (v >= 1e4) return (v / 1e4).toFixed(1) + ' 万';
+      return String(Math.round(v));
+    }
+
+    function fmtMoney(n) {
+      const v = Number(n) || 0;
+      if (v > 0 && v < 0.01) return '¥' + v.toFixed(4);
+      if (v < 1) return '¥' + v.toFixed(3);
+      return '¥' + v.toFixed(2);
+    }
+
+    function fmtPct(x) {
+      return ((Number(x) || 0) * 100).toFixed(1) + '%';
+    }
+
+    function modelParts(name) {
+      const s = String(name || '');
+      const i = s.indexOf('/');
+      return i >= 0 ? { provider: s.slice(0, i), model: s.slice(i + 1) } : { provider: '', model: s };
+    }
+
+    /** Short name; when two providers expose the same model, keep the provider tag. */
+    function shortModel(name, duplicated) {
+      const { provider, model } = modelParts(name);
+      if (!duplicated) return model;
+      const tag = provider.replace(/^deepseek-/, '').replace(/-?account$/, 'personal');
+      return tag ? model + ' · ' + tag : model;
+    }
+
+    function UsageCard() {
+      const t = translate;
+      const rangeState = React.useState('30');
+      const range = rangeState[0];
+      const setRange = rangeState[1];
+      const dataState = React.useState(usageCache);
+      const data = dataState[0];
+      const setData = dataState[1];
+      const errState = React.useState('');
+      const err = errState[0];
+      const setErr = errState[1];
+      const loadState = React.useState(!usageCache);
+      const loading = loadState[0];
+      const setLoading = loadState[1];
+      const tickState = React.useState(0);
+      const tick = tickState[0];
+      const reload = tickState[1];
+
+      React.useEffect(() => {
+        let alive = true;
+        setLoading(true);
+        fetch(USAGE_API + (tick > 0 ? '?fresh=1' : ''), { cache: 'no-store' })
+          .then((r) =>
+            r.json().then(
+              (j) => {
+                if (!r.ok) throw new Error((j && j.error) || 'HTTP ' + r.status);
+                return j;
+              },
+              () => {
+                throw new Error('HTTP ' + r.status);
+              },
+            ),
+          )
+          .then((j) => {
+            if (!alive) return;
+            usageCache = j;
+            setData(j);
+            setErr('');
+          })
+          .catch((e) => {
+            if (!alive) return;
+            setErr(String((e && e.message) || e));
+          })
+          .then(() => {
+            if (alive) setLoading(false);
+          });
+        return () => {
+          alive = false;
+        };
+      }, [tick]);
+
+      const rep = data && data.ranges ? data.ranges[range] : null;
+      const seg = h(
+        'div',
+        { className: 'dshphu-seg', role: 'group', 'aria-label': t('usage.range') },
+        ...RANGES.map((key) =>
+          h(
+            'button',
+            {
+              key,
+              type: 'button',
+              className: 'dshphu-segBtn',
+              'data-on': range === key ? '1' : '0',
+              'aria-pressed': range === key ? 'true' : 'false',
+              onClick: () => setRange(key),
+            },
+            t('usage.range.' + key),
+          ),
+        ),
+      );
+
+      const head = h(
+        'div',
+        { className: 'dshphu-head' },
+        h(
+          'div',
+          { className: 'dshphu-titles' },
+          h('div', { className: 'dshphu-title' }, t('usage.title')),
+          h('div', { className: 'dshphu-desc' }, t('usage.desc')),
+        ),
+        seg,
+      );
+
+      if (err) {
+        return h(
+          'div',
+          { className: 'dshphu-card' },
+          head,
+          h('div', { className: 'dshphu-err' }, t('usage.error') + err),
+          h(
+            'div',
+            null,
+            h('button', { type: 'button', className: 'dshphu-segBtn', onClick: () => reload((n) => n + 1) }, t('usage.refresh')),
+          ),
+        );
+      }
+
+      if (!rep) {
+        return h(
+          'div',
+          { className: 'dshphu-card' },
+          head,
+          h('div', { className: 'dshphu-line' }, loading ? t('usage.loading') : t('usage.empty')),
+        );
+      }
+
+      const tokens = rep.tokens;
+      const cost = rep.cost;
+      const peakPct = Math.max(0, Math.min(1, tokens.peakShare));
+      const modelRows = rep.classByModel || [];
+      const modelNames = new Map();
+      for (const row of modelRows) {
+        const base = modelParts(row.model).model;
+        modelNames.set(base, (modelNames.get(base) || 0) + 1);
+      }
+      const models = modelRows.slice(0, 4);
+
+      return h(
+        'div',
+        { className: 'dshphu-card' },
+        head,
+        h(
+          'div',
+          { className: 'dshphu-kpis' },
+          h(
+            'div',
+            { className: 'dshphu-kpi' },
+            h('div', { className: 'dshphu-kpiLabel' }, t('usage.actual')),
+            h('div', { className: 'dshphu-kpiValue' }, fmtMoney(cost.actual)),
+          ),
+          h(
+            'div',
+            { className: 'dshphu-kpi' },
+            h('div', { className: 'dshphu-kpiLabel' }, t('usage.allPeak')),
+            h('div', { className: 'dshphu-kpiValue', 'data-tone': 'peak' }, fmtMoney(cost.allPeak)),
+          ),
+          h(
+            'div',
+            { className: 'dshphu-kpi' },
+            h('div', { className: 'dshphu-kpiLabel' }, t('usage.saved')),
+            h(
+              'div',
+              { className: 'dshphu-kpiValue', 'data-tone': 'save' },
+              fmtMoney(cost.saved) + ' · ' + fmtPct(cost.savedPct),
+            ),
+          ),
+        ),
+        h(
+          'div',
+          { className: 'dshphu-bar', role: 'img', 'aria-label': t('usage.peakShare') + ' ' + fmtPct(peakPct) },
+          h('span', { className: 'dshphu-barPeak', style: { width: fmtPct(peakPct) } }),
+          h('span', { className: 'dshphu-barOff', style: { width: fmtPct(1 - peakPct) } }),
+        ),
+        h(
+          'div',
+          { className: 'dshphu-line' },
+          t('usage.peakTokens') + ' ' + fmtTokens(tokens.peak.total) +
+            ' · ' + t('usage.offTokens') + ' ' + fmtTokens(tokens.off.total) +
+            ' · ' + t('usage.totalTokens') + ' ' + fmtTokens(tokens.total) +
+            ' · ' + t('usage.peakShare') + ' ' + fmtPct(peakPct),
+        ),
+        models.length
+          ? h(
+              'div',
+              { className: 'dshphu-models' },
+              ...models.map((m) =>
+                h(
+                  'div',
+                  { key: m.model, className: 'dshphu-model' },
+                  h(
+                    'span',
+                    { className: 'dshphu-modelName' },
+                    shortModel(m.model, (modelNames.get(modelParts(m.model).model) || 0) > 1),
+                  ),
+                  h(
+                    'span',
+                    { className: 'dshphu-modelNum' },
+                    fmtTokens(m.peak.total + m.off.total) + ' · ' + fmtMoney(m.cost || 0),
+                  ),
+                ),
+              ),
+            )
+          : null,
+        h('div', { className: 'dshphu-note' }, t('usage.note').replace('{tokens}', fmtTokens(rep.other.tokens))),
+        h(
+          'div',
+          { className: 'dshphu-line' },
+          t('usage.meta')
+            .replace('{sessions}', String((data.stats && data.stats.sessions) || 0))
+            .replace('{days}', String(rep.activeDays || 0)) +
+            ' · ' +
+            (loading ? t('usage.loading') : t('usage.refreshHint')),
+        ),
+      );
+    }
     return {
       inject: ['slots'],
       apply(ctx) {
@@ -572,6 +895,19 @@ window.__ModuleLoader__.load({
             PeakBadge,
           ),
         );
+        ctx.slots.inject('settings.general.item', () =>
+          ctx.slots.register(
+            {
+              name: 'settings.general.item',
+              id: 'peak-hours-usage',
+              order: 31,
+              locale: NS,
+              label: () => translate('usage.title'),
+            },
+            UsageCard,
+          ),
+        );
+
       },
     };
   },

package/index.js

@@ -1,8 +1,73 @@
 /**
- * Host half of the peak-hours badge.
+ * Host half of dsh-peak-hours.
  *
- * The visible UI is a Client module (`./client`), which the Web runtime loads on
- * its own. The Host entry exists so the bundle has a valid plugin row; it needs
- * no services, tools or config.
+ * Serves the peak / off-peak usage report on `/dsh-peak-hours/api/usage` so the
+ * client half (a settings card) can show tokens and money without touching the
+ * filesystem itself.
  */
-export function apply() {}
+import { buildReport } from './lib/usage.js'
+
+export const name = 'dsh-peak-hours'
+export const inject = ['webServer']
+
+const API = '/dsh-peak-hours/api'
+/** The scan walks every session log; a short TTL keeps repeated UI loads cheap. */
+const TTL_MS = 60_000
+
+export function apply(ctx) {
+  let payload = null
+  let payloadAt = 0
+  let inflight = null
+
+  async function getReport(fresh) {
+    const now = Date.now()
+    if (!fresh && payload && now - payloadAt < TTL_MS) return payload
+    if (inflight) return inflight
+    inflight = (async () => {
+      try {
+        const report = await buildReport({})
+        payload = report
+        payloadAt = Date.now()
+        return report
+      } finally {
+        inflight = null
+      }
+    })()
+    return inflight
+  }
+
+  ctx.effect(() =>
+    ctx.webServer.register({
+      kind: 'prefix',
+      path: API,
+      handler: async (req, res) => {
+        const url = req.url || '/'
+        const pathname = url.split('?')[0]
+        const fresh = /[?&]fresh=1(?:&|$)/.test(url)
+        const sub = pathname.startsWith(API) ? pathname.slice(API.length) : pathname
+        try {
+          if (sub === '/usage') {
+            const report = await getReport(fresh)
+            res.writeHead(200, {
+              'content-type': 'application/json; charset=utf-8',
+              'cache-control': 'no-store',
+            })
+            res.end(JSON.stringify(report))
+            return
+          }
+          res.writeHead(200, {
+            'content-type': 'application/json; charset=utf-8',
+            'cache-control': 'no-store',
+          })
+          res.end(JSON.stringify({ ok: true, service: name, endpoints: ['/usage', '/usage?fresh=1'] }))
+        } catch (err) {
+          res.writeHead(500, {
+            'content-type': 'application/json; charset=utf-8',
+            'cache-control': 'no-store',
+          })
+          res.end(JSON.stringify({ ok: false, error: String((err && err.message) || err) }))
+        }
+      },
+    }),
+  )
+}

package/lib/schedule.js

@@ -0,0 +1,120 @@
+/**
+ * Peak / off-peak schedule and price table (host half).
+ *
+ * Kept in sync with `client.js` by hand: the client half is a standalone
+ * `window.__ModuleLoader__` bundle and cannot import package files, so the two
+ * copies are cross-checked by `test/schedule.test.mjs` against the published
+ * rules (09:00–12:00 and 14:00–18:00 Beijing time; weekends, Chinese public
+ * holidays and make-up rest days are all off-peak; off-peak is half price).
+ */
+
+export const MINUTE = 60_000
+export const HOUR = 60 * MINUTE
+/** Beijing is UTC+8 with no DST: shifting the instant is exact. */
+export const BEIJING_OFFSET_MS = 8 * 3_600_000
+
+/** Peak windows as minutes-of-day, Beijing time. */
+export const PEAK_WINDOWS = [
+  [540, 720], // 09:00–12:00
+  [840, 1080], // 14:00–18:00
+]
+
+/** Chinese public holidays, keyed by year → MM-DD. Extend as the calendar is announced. */
+export const HOLIDAYS = {
+  2026: [
+    '01-01', // 元旦
+    '02-17', '02-18', '02-19', '02-20', '02-21', '02-22', '02-23', // 春节
+    '04-04', '04-05', '04-06', // 清明
+    '05-01', '05-02', '05-03', '05-04', '05-05', // 劳动节
+    '06-19', '06-20', '06-21', // 端午
+    '09-25', '09-26', '09-27', // 中秋
+    '10-01', '10-02', '10-03', '10-04', '10-05', '10-06', '10-07', // 国庆
+  ],
+}
+
+/** Beijing calendar fields of an instant. */
+export function bjParts(ms) {
+  const d = new Date(ms + BEIJING_OFFSET_MS)
+  return {
+    y: d.getUTCFullYear(),
+    mo: String(d.getUTCMonth() + 1).padStart(2, '0'),
+    d: String(d.getUTCDate()).padStart(2, '0'),
+    h: d.getUTCHours(),
+    mi: d.getUTCMinutes(),
+    dow: d.getUTCDay(),
+  }
+}
+
+export function bjDayKey(ms) {
+  const p = bjParts(ms)
+  return `${p.y}-${p.mo}-${p.d}`
+}
+
+export function isHoliday(ms) {
+  const p = bjParts(ms)
+  const list = HOLIDAYS[p.y]
+  return Array.isArray(list) && list.includes(`${p.mo}-${p.d}`)
+}
+
+export function isWeekend(ms) {
+  const dow = bjParts(ms).dow
+  return dow === 0 || dow === 6
+}
+
+/** Whole day is off-peak (weekend or public holiday). */
+export function isOffDay(ms) {
+  return isWeekend(ms) || isHoliday(ms)
+}
+
+export function minuteOfDay(ms) {
+  const p = bjParts(ms)
+  return p.h * 60 + p.mi
+}
+
+export function isPeakInstant(ms) {
+  if (isOffDay(ms)) return false
+  const m = minuteOfDay(ms)
+  return PEAK_WINDOWS.some(([a, b]) => m >= a && m < b)
+}
+
+/**
+ * Prices in CNY per million tokens.
+ * `miss` also prices cache writes (a cache write is billed as uncached input).
+ */
+export const PRICES = {
+  flash: {
+    peak: { hit: 0.04, miss: 2, out: 8 },
+    off: { hit: 0.02, miss: 1, out: 4 },
+  },
+  pro: {
+    peak: { hit: 0.3, miss: 9, out: 27 },
+    off: { hit: 0.15, miss: 4.5, out: 13.5 },
+  },
+}
+
+/**
+ * Which price class a model falls into, or `null` when the model is not billed
+ * on the DeepSeek peak/off-peak table (third-party providers routed through the
+ * harness are still counted as usage, but not as money).
+ */
+export function classifyModel(model) {
+  const m = String(model || '').toLowerCase()
+  if (!m.includes('deepseek')) return null
+  if (m.includes('pro') || m.includes('reasoner')) return 'pro'
+  return 'flash'
+}
+
+/** `[input, output, cacheRead, cacheWrite]` → CNY. */
+export function bucketCost(price, b) {
+  const miss = (b[0] || 0) + (b[3] || 0)
+  const hit = b[2] || 0
+  const out = b[1] || 0
+  return (miss * price.miss + hit * price.hit + out * price.out) / 1e6
+}
+
+export function fmtYuan(n) {
+  const v = Number(n) || 0
+  if (v > 0 && v < 0.01) return '¥' + v.toFixed(4)
+  if (v < 1) return '¥' + v.toFixed(3)
+  return '¥' + v.toFixed(2)
+}

package/lib/usage.js

@@ -0,0 +1,386 @@
+/**
+ * Session-log usage scanner: turns durable session logs into peak / off-peak
+ * token totals and money.
+ *
+ * Data source (same one token-meter keeps): `~/.dsh/sessions/<cwd>/<id>/session.v<N>.jsonl.zstd`,
+ * a multi-frame zstd stream of JSONL events. Each assistant event carries a
+ * top-level `time` (epoch ms) and `data.usage`
+ * `{ inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens }`.
+ * Repeated samples for the same `turn`/`step` REPLACE the previous one, so the
+ * folder subtracts the previous sample before adding the newer one.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { decodeAllFrames } from './zstd.js'
+import { PRICES, bjDayKey, bjParts, bucketCost, classifyModel, isPeakInstant } from './schedule.js'
+
+const LOG_RE = /^session\.v\d+\.jsonl\.zstd$/
+const CACHE_VERSION = 3
+const DAY_MS = 86_400_000
+
+export function sessionsRoot() {
+  return path.join(os.homedir(), '.dsh', 'sessions')
+}
+
+export function cacheFile() {
+  return path.join(os.homedir(), '.dsh', 'storages', 'peak-hours', 'cache.json')
+}
+
+function bucketsFrom(u) {
+  return [
+    Number(u.inputTokens) || 0,
+    Number(u.outputTokens) || 0,
+    Number(u.cacheReadTokens) || 0,
+    Number(u.cacheWriteTokens) || 0,
+  ]
+}
+
+function lastStreamUsage(stream) {
+  if (!Array.isArray(stream)) return undefined
+  for (let i = stream.length - 1; i >= 0; i--) {
+    const r = stream[i]
+    if (r && r.type === 'chunk' && r.chunk && r.chunk.type === 'usage' && r.chunk.usage != null) {
+      return r.chunk.usage
+    }
+  }
+  return undefined
+}
+
+function usageOf(ev) {
+  if (ev.data && ev.data.usage != null) return ev.data.usage
+  if (ev.type !== 'assistant/message' && ev.type !== 'assistant/attempt') return undefined
+  return lastStreamUsage(ev.data && ev.data.stream)
+}
+
+function modelOfEvent(ev) {
+  const s = ev && ev.data && ev.data.message && ev.data.message.source
+  if (!s || typeof s !== 'object') return ''
+  const prov = typeof s.provider === 'string' ? s.provider : ''
+  const mod = typeof s.model === 'string' ? s.model : ''
+  return prov && mod ? prov + '/' + mod : mod || prov
+}
+
+/**
+ * Fold one session log's decoded text into `map`.
+ * Key: `${dayKey}|${hour}|${model}` → `[input, output, cacheRead, cacheWrite]`.
+ * @returns {{ samples: number, parsed: number }}
+ */
+export function foldSessionText(text, map) {
+  let last = null
+  let samples = 0
+  let parsed = 0
+  const add = (key, b, sign) => {
+    const cur = map.get(key) || [0, 0, 0, 0]
+    cur[0] += sign * b[0]
+    cur[1] += sign * b[1]
+    cur[2] += sign * b[2]
+    cur[3] += sign * b[3]
+    map.set(key, cur)
+  }
+  for (const line of text.split('\n')) {
+    if (!line) continue
+    let ev
+    try {
+      ev = JSON.parse(line)
+    } catch {
+      continue
+    }
+    parsed++
+    const t = Number(ev.time)
+    if (!(t > 0)) continue
+    const u = usageOf(ev)
+    if (u == null) continue
+    const b = bucketsFrom(u)
+    const data = ev.data || {}
+    const turn = data.turn == null ? null : data.turn
+    const step = data.step == null ? null : data.step
+    const model = modelOfEvent(ev)
+    const p = bjParts(t)
+    if (last && last.turn === turn && last.step === step && turn !== null) {
+      add(last.key, last.b, -1)
+    }
+    const key = `${p.y}-${String(p.mo).padStart(2, '0')}-${String(p.d).padStart(2, '0')}|${p.h}|${model}`
+    add(key, b, 1)
+    last = { turn, step, key, b }
+    samples++
+  }
+  return { samples, parsed }
+}
+
+function listSessionLogs(root) {
+  const out = []
+  let cwds
+  try {
+    cwds = fs.readdirSync(root, { withFileTypes: true })
+  } catch {
+    return out
+  }
+  for (const cwd of cwds) {
+    if (!cwd.isDirectory()) continue
+    const cwdDir = path.join(root, cwd.name)
+    let sessions
+    try {
+      sessions = fs.readdirSync(cwdDir, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const s of sessions) {
+      if (!s.isDirectory()) continue
+      const dir = path.join(cwdDir, s.name)
+      let files
+      try {
+        files = fs.readdirSync(dir)
+      } catch {
+        continue
+      }
+      for (const f of files) {
+        if (LOG_RE.test(f)) out.push(path.join(dir, f))
+      }
+    }
+  }
+  return out
+}
+
+function readCache(file) {
+  try {
+    const json = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (json && json.version === CACHE_VERSION && json.files && typeof json.files === 'object') return json
+  } catch {
+    /* missing or corrupt → cold scan */
+  }
+  return { version: CACHE_VERSION, files: {} }
+}
+
+function writeCache(file, data) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    const tmp = file + '.tmp'
+    fs.writeFileSync(tmp, JSON.stringify(data))
+    fs.renameSync(tmp, file)
+  } catch {
+    /* cache is an optimisation only */
+  }
+}
+
+/**
+ * Read every session log, reusing per-file aggregates for unchanged logs.
+ * Yields to the event loop between files so a cold scan never freezes the host.
+ * @returns {Promise<{ buckets: Array<[string, number, string, number, number, number, number]>, stats: object }>}
+ */
+export async function scanSessions(opts = {}) {
+  const root = opts.root || sessionsRoot()
+  const cachePath = opts.cacheFile || cacheFile()
+  const started = Date.now()
+  const cache = readCache(cachePath)
+  const files = listSessionLogs(root)
+  const stats = { sessions: files.length, scanned: 0, cacheHits: 0, dropped: 0, frames: 0 }
+  const buckets = []
+  const nextCache = { version: CACHE_VERSION, files: {} }
+  const tick = () => new Promise((resolve) => setImmediate(resolve))
+
+  for (const file of files) {
+    await tick()
+    let st
+    try {
+      st = fs.statSync(file)
+    } catch {
+      continue
+    }
+    const prev = cache.files[file]
+    if (prev && prev.size === st.size && prev.mtimeMs === Math.trunc(st.mtimeMs)) {
+      stats.cacheHits++
+      nextCache.files[file] = prev
+      for (const row of prev.buckets) buckets.push(row)
+      continue
+    }
+    let buf
+    try {
+      buf = fs.readFileSync(file)
+    } catch {
+      continue
+    }
+    const decoded = decodeAllFrames(buf)
+    const map = new Map()
+    foldSessionText(decoded.text, map)
+    stats.scanned++
+    stats.dropped += decoded.dropped
+    stats.frames += decoded.frames
+    const rows = []
+    for (const [key, b] of map) {
+      if (b[0] === 0 && b[1] === 0 && b[2] === 0 && b[3] === 0) continue
+      const [day, hour, model] = key.split('|')
+      rows.push([day, Number(hour), model, b[0], b[1], b[2], b[3]])
+      buckets.push([day, Number(hour), model, b[0], b[1], b[2], b[3]])
+    }
+    nextCache.files[file] = {
+      size: st.size,
+      mtimeMs: Math.trunc(st.mtimeMs),
+      frames: decoded.frames,
+      dropped: decoded.dropped,
+      buckets: rows,
+    }
+  }
+
+  writeCache(cachePath, nextCache)
+  stats.scanMs = Date.now() - started
+  return { buckets, stats }
+}
+
+const EMPTY = () => ({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 })
+
+function addTo(acc, b) {
+  acc.input += b[0]
+  acc.output += b[1]
+  acc.cacheRead += b[2]
+  acc.cacheWrite += b[3]
+  acc.total += b[0] + b[1] + b[2] + b[3]
+}
+
+/** Instant at the start of `dayKey` + `hour` in Beijing time. */
+function instantOf(day, hour) {
+  const [y, mo, d] = day.split('-').map(Number)
+  return Date.UTC(y, mo - 1, d, hour, 0, 0) - 8 * 3_600_000
+}
+
+/**
+ * Aggregate bucket rows into one range.
+ * @param {Array} buckets rows from `scanSessions`
+ * @param {{ days?: number|null, nowMs?: number }} opts `days = null` means all time
+ */
+export function aggregate(buckets, opts = {}) {
+  const nowMs = opts.nowMs || Date.now()
+  const days = opts.days == null ? null : Number(opts.days)
+  const cutoff = days == null ? null : nowMs - days * DAY_MS
+  const out = {
+    days,
+    peak: EMPTY(),
+    off: EMPTY(),
+    classes: { flash: EMPTY(), pro: EMPTY() },
+    peakClasses: { flash: EMPTY(), pro: EMPTY() },
+    offClasses: { flash: EMPTY(), pro: EMPTY() },
+    classByModel: {},
+    other: { tokens: 0, models: {} },
+    byModel: {},
+    days_seen: new Set(),
+  }
+  for (const row of buckets) {
+    const [day, hour, model, i, o, cr, cw] = row
+    const b = [i, o, cr, cw]
+    const inst = instantOf(day, hour)
+    if (cutoff != null && inst < cutoff) continue
+    const peak = isPeakInstant(inst)
+    const cls = classifyModel(model)
+    out.days_seen.add(day)
+    addTo(peak ? out.peak : out.off, b)
+    const modelTot = (out.byModel[model] ||= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, peak: 0, off: 0 })
+    addTo(modelTot, b)
+    if (peak) modelTot.peak += i + o + cr + cw
+    else modelTot.off += i + o + cr + cw
+    if (cls) {
+      addTo(out.classes[cls], b)
+      addTo(peak ? out.peakClasses[cls] : out.offClasses[cls], b)
+      const cm = (out.classByModel[model] ||= { class: cls, peak: EMPTY(), off: EMPTY() })
+      addTo(peak ? cm.peak : cm.off, b)
+    } else {
+      out.other.tokens += i + o + cr + cw
+      out.other.models[model] = (out.other.models[model] || 0) + i + o + cr + cw
+    }
+  }
+
+  const costActual = {}
+  const costAllPeak = {}
+  const costAllOff = {}
+  let actual = 0
+  let allPeak = 0
+  let allOff = 0
+  for (const cls of ['flash', 'pro']) {
+    const price = PRICES[cls]
+    const a = bucketCost(price.peak, toB(out.peakClasses[cls])) + bucketCost(price.off, toB(out.offClasses[cls]))
+    const p = bucketCost(price.peak, toB(out.classes[cls]))
+    const o = bucketCost(price.off, toB(out.classes[cls]))
+    costActual[cls] = a
+    costAllPeak[cls] = p
+    costAllOff[cls] = o
+    actual += a
+    allPeak += p
+    allOff += o
+  }
+
+  const peakTotal = out.peak.total
+  const offTotal = out.off.total
+  const total = peakTotal + offTotal
+  const priced = out.classes.flash.total + out.classes.pro.total
+
+  return {
+    days,
+    since: cutoff == null ? null : bjDayKey(cutoff),
+    activeDays: out.days_seen.size,
+    tokens: {
+      peak: out.peak,
+      off: out.off,
+      total,
+      peakShare: total > 0 ? peakTotal / total : 0,
+      offShare: total > 0 ? offTotal / total : 0,
+      priced,
+    },
+    classes: out.classes,
+    models: Object.entries(out.byModel)
+      .map(([model, v]) => ({ model, cls: classifyModel(model), ...v }))
+      .sort((a, b) => b.total - a.total),
+    classByModel: Object.entries(out.classByModel)
+      .map(([model, v]) => {
+        const price = PRICES[v.class]
+        const peakCost = bucketCost(price.peak, toB(v.peak))
+        const offCost = bucketCost(price.off, toB(v.off))
+        return {
+          model,
+          cls: v.class,
+          peak: v.peak,
+          off: v.off,
+          peakCost,
+          offCost,
+          allPeakCost: bucketCost(price.peak, toB(v.peak)) + bucketCost(price.peak, toB(v.off)),
+          cost: peakCost + offCost,
+        }
+      })
+      .sort((a, b) => b.cost - a.cost),
+    other: {
+      tokens: out.other.tokens,
+      models: Object.entries(out.other.models)
+        .map(([model, tokens]) => ({ model, tokens }))
+        .sort((a, b) => b.tokens - a.tokens),
+    },
+    cost: {
+      actual,
+      allPeak,
+      allOff,
+      byClass: costActual,
+      allPeakByClass: costAllPeak,
+      allOffByClass: costAllOff,
+      saved: allPeak - actual,
+      savedPct: allPeak > 0 ? (allPeak - actual) / allPeak : 0,
+    },
+  }
+}
+
+function toB(acc) {
+  return [acc.input, acc.output, acc.cacheRead, acc.cacheWrite]
+}
+
+/** One payload for the client: the three ranges it offers. */
+export async function buildReport(opts = {}) {
+  const nowMs = opts.nowMs || Date.now()
+  const { buckets, stats } = await scanSessions(opts)
+  return {
+    ok: true,
+    generatedAt: new Date(nowMs).toISOString(),
+    stats,
+    ranges: {
+      '7': aggregate(buckets, { days: 7, nowMs }),
+      '30': aggregate(buckets, { days: 30, nowMs }),
+      all: aggregate(buckets, { days: null, nowMs }),
+    },
+    cache: { file: cacheFile(), raw: false },
+  }
+}

package/lib/zstd.js

@@ -0,0 +1,122 @@
+/**
+ * Multi-frame zstd decoder.
+ *
+ * A durable session log (`session.v<N>.jsonl.zstd`) is a *sequence* of zstd
+ * frames — one frame appended per batched write. `zlib.zstdDecompressSync`
+ * decodes only the FIRST frame and silently drops the rest, so we have to walk
+ * the physical frame boundaries ourselves: parse a frame header, walk its
+ * blocks to find the frame end, then decompress exactly that slice.
+ *
+ * A torn tail (a frame still being written) is expected: we stop at the last
+ * complete frame and report how many frames were dropped, which lets callers
+ * resync on the next scan.
+ */
+import zlib from 'node:zlib'
+
+const ZSTD_MAGIC = 0xfd2fb528
+
+function isSkippableMagic(m) {
+  return m >= 0x184d2a50 && m <= 0x184d2a5f
+}
+
+function findMagic(buf, from) {
+  for (let i = from; i + 4 <= buf.length; i++) {
+    if (buf.readUInt32LE(i) === ZSTD_MAGIC) return i
+  }
+  return -1
+}
+
+/** Physical end offset of the frame starting at `off` (throws on a torn frame). */
+function parseFrameEnd(buf, off) {
+  let p = off + 4
+  const fhd = buf[p]
+  p += 1
+  const fcsFlag = fhd >> 6
+  const single = (fhd >> 5) & 1
+  const checksum = (fhd >> 2) & 1
+  const dictId = fhd & 3
+  p += [0, 1, 2, 4][dictId]
+  if (!single) p += 1 // window descriptor
+  p += fcsFlag === 0 ? (single ? 1 : 0) : fcsFlag === 1 ? 2 : fcsFlag === 2 ? 4 : 8
+  let last = false
+  let guard = 0
+  while (!last) {
+    if (p + 3 > buf.length) throw new Error('torn block header')
+    const bh = buf.readUIntLE(p, 3)
+    p += 3
+    last = (bh & 1) === 1
+    const type = (bh >>> 1) & 3
+    const size = bh >>> 3
+    if (type === 3) throw new Error('reserved block type')
+    const payload = type === 1 ? 1 : size
+    if (p + payload > buf.length) throw new Error('torn block payload')
+    p += payload
+    if (++guard > 1e7) throw new Error('runaway blocks')
+  }
+  if (checksum) {
+    if (p + 4 > buf.length) throw new Error('torn checksum')
+    p += 4
+  }
+  return p
+}
+
+/**
+ * Decode every complete frame in `buf`.
+ * @param {Buffer} buf
+ * @param {(text: string) => void} [onFrame] per-frame UTF-8 text (optional)
+ * @returns {{ text: string, frames: number, dropped: number }}
+ */
+export function decodeAllFrames(buf, onFrame) {
+  const parts = []
+  let off = 0
+  let frames = 0
+  let dropped = 0
+  while (off < buf.length) {
+    if (buf.length - off < 4) {
+      if (off < buf.length) dropped += 1
+      break
+    }
+    const magic = buf.readUInt32LE(off)
+    if (isSkippableMagic(magic)) {
+      // Skippable frame: 4-byte magic + 4-byte LE size + payload.
+      if (off + 8 > buf.length) {
+        dropped += 1
+        break
+      }
+      const size = buf.readUInt32LE(off + 4)
+      if (off + 8 + size > buf.length) {
+        dropped += 1
+        break
+      }
+      off += 8 + size
+      continue
+    }
+    if (magic !== ZSTD_MAGIC) {
+      const next = findMagic(buf, off + 1)
+      if (next < 0) break
+      off = next
+      continue
+    }
+    let end
+    try {
+      end = parseFrameEnd(buf, off)
+    } catch {
+      dropped += 1
+      break
+    }
+    const slice = buf.subarray(off, end)
+    let text
+    try {
+      text = zlib.zstdDecompressSync(slice).toString('utf8')
+    } catch {
+      dropped += 1
+      off = end
+      continue
+    }
+    frames += 1
+    if (onFrame) onFrame(text)
+    else parts.push(text)
+    off = end
+  }
+  return { text: parts.join(''), frames, dropped }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dsh-peak-hours",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "type": "module",
-  "description": "Sidebar badge that marks the current DeepSeek peak-pricing window: 24-hour schedule bar, now-cursor, countdown to the next switch, click to copy the state.",
+  "description": "Sidebar badge that marks the current DeepSeek peak-pricing window (24-hour schedule bar, countdown, click to copy) plus a settings card that splits your logged usage into peak / off-peak tokens and compares what it actually cost against all-peak and all-off-peak.",
   "license": "MIT",
   "author": "run666888 <zhirunli6@gmail.com>",
   "homepage": "https://github.com/run666888/dsh-peak-hours#readme",
@@ -27,6 +27,8 @@
     "peak-hours",
     "off-peak",
     "pricing",
+    "cost",
+    "usage",
     "sidebar"
   ],
   "publishConfig": {
@@ -42,6 +44,7 @@
   "files": [
     "index.js",
     "client.js",
+    "lib",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",