dsh-usage-badge 0.1.10 → 0.1.12

package/README.md

@@ -83,7 +83,7 @@ dsh plugin --profile web remove dsh-usage-badge
 
 ## 已知限制
 
-- **首次启动要冷扫一遍全部会话日志**（200 多份实测约 10 秒；分片让出事件循环，界面不会卡住）。之后走增量，几乎瞬时。
+- **首次启动要冷扫一遍全部会话日志**（本机 338 份 / 348 MB 实测约 19 秒，随机器负载浮动；按解码字节数让出事件循环，最长一次阻塞约 0.4 秒，宿主启动与界面都不会被卡住，徽标先显示「…」再填上数字）。**之后每次启动只读增量**：只解压新追加的那几帧 —— 同一台机器实测「1 个日志、2 KB、57 ms」，没有任何变化时「0 个、16 ms」。
 - **历史依赖日志，但日志变短不再吃掉历史**：日志被删掉后靠缓存继续计入；缓存也丢了，那段历史就没了。同一个会话的日志**变短或还原成更早的备份**时，缓存会**把更完整的那份留着**（折叠结果变小就只作为备份副本存下，统计仍用完整的那份），要等日志真的更全、却不再包含某一天，那天才会被丢掉。**例外是改名**：会话是按「日志所在目录」识别的，把某个会话目录改名会让同一份用量各算一份（见下）。DSH 自己从不裁日志：格式升级时它另写一代新文件、旧代保留，而实测换代后统计结果逐项相同。
 - **日粒度区间仍只覆盖最近一年**：`近 7 日` / `近 30 日` / `近 12 个月` 与它们下面的滚动热力图都基于快照的最近 400 天。要看更早的日子，用 **`按年`**：那一档的月度合计、年度总额与**自然年热力图**都是直接查缓存库的，任何一年都在。
 - **只统计 DSH 记进日志的调用**：某个东西直接请求外部 API 且不向 DSH 上报 usage，这部分统计不到。
@@ -97,7 +97,7 @@ dsh plugin --profile web remove dsh-usage-badge
 
 ```sh
 npm install   # 只为测试装 react / react-dom
-npm test      # 11 个套件 908 条断言：包契约、定价、节假日、官方定价解析、缓存存储、同步分片、同步编排、宿主同步接线、自动触发、WebDAV(Digest)、浏览器半渲染
+npm test      # 11 个套件 911 条断言：包契约、定价、节假日、官方定价解析、缓存存储、同步分片、同步编排、宿主同步接线、自动触发、WebDAV(Digest)、浏览器半渲染
 ```
 
 云同步的前五步已经在真实的 `bytemark/webdav` 容器上核对通过。要自己核对一遍：

package/docs/design-notes.md

@@ -53,7 +53,7 @@ dsh plugin --profile web remove dsh-usage-badge
 - **「今日用量」** 标签
 - **峰谷圆点**：谷时灰色、峰时橙色；悬停圆点本身会显示 `峰时 ×2` / `谷时 ×1` / `国庆节 · 全天空闲`。橙色用静态色 `--dsw-static-amber-500`，**不要借 `--dsw-alias-brand-primary`** —— 那个 token 在本设计系统里是**前景墨色**（DSH 自己只用它做文字、描边、开关轨道）：浅色主题解析成 `--dsw-static-neutral-bluish-1000`（`#0f1115`，近黑），深色主题解析成 near-white。借了它的后果是峰时圆点变成一个看不出含义的深色点，`峰时 ×2` 标签变成白底白字，主按钮（白字填色）在深色主题下文字直接消失 —— 三处都已改成显式颜色（`--dsw-static-amber-500` 与 `--dsw-static-deepseek-500`），并由 `test/client.render.mjs` 里一条「墨色 token 不得作白字填充背景」的断言钉住。
 - **当日 token 总量**（输入 + 缓存 + 输出）
-- **当日估算金额**
+- **当日估算金额**：始终贴右边缘。撑开右边距的是 token 那一段的 `margin-left:auto`，所以**它在没有用量的日子也照旧渲染**（内容为空、宽度为 0，但空的 flex 项照样吃掉自由空间）。少了它，金额就退回贴着标签左对齐，同一行出现两套对齐 —— `test/client.render.mjs` 三条断言钉住，金额自己的 `margin-left` 必须保持固定值（两个 `auto` 会平分自由空间，把 token 数挤到行中间）。
 
 整行每 5 秒刷新，悬停显示完整明细（金额 / token / 请求数 / 当前档位）。点击打开两个面板：
 
@@ -327,6 +327,32 @@ dsh-usage-badge
 
 删掉 `cache.sqlite` 与删掉 `cache.json` 的后果完全一样：下次启动冷扫一遍日志重建；只有「日志已被删除」的那段历史会随之消失。
 
+### 折叠的代价：只解码新增的那几个字节
+
+「DSH 启动很慢」查下来是这个插件自己：**每启动一次就把整份日志重新解码一遍**。本机实测（373 个日志 / 348 MB）：一次启动折 25 个日志要 **3.6 秒**，冷启动（没有缓存）**20 秒**，而耗时**八成在 zstd 解压**——12.7 MB 的日志解压 775 ms，解析 JSON 只要 133 ms。两个原因叠在一起：
+
+1. **游标取错了地方**：会话的 `fileSize`/`fileMtimeMs` 原来取自它**最早那一天的行走**（每天的行记的是写它的那次折叠的戳，而折叠只重写 payload 真的变了的天），所以长寿会话的最早一天带着几个月前的戳 —— 于是**每次启动都判定成「变了」**，多天的会话全部重折。现在 `resolveRows` 取会话行本身的游标（`sessions.file_size`），那才是「这份日志我折到哪儿了」。
+2. **变了就从头折**：游标的 `fileSize` 本来**就是**上次折到哪儿的字节偏移，所以「新增了 1 KB」不需要从第 0 字节重新解压。现在 `foldSession(file, previous, { fromByte })` 只读 `[fromByte, size)`：按 zstd **帧**切（一帧要么整个折进去，要么留给下一趟）、纯文本按**最后一个换行**切，末尾那半行只有在它自身是完整 JSON 时才算数（日志最后一行常常没有换行符，漏掉它就正好漏掉最新一次请求）。
+
+规则与代价：
+
+| | 改之前 | 改之后 |
+|---|---|---|
+| 启动（25 个日志有增量时） | 折 25 个、读 45 MB、**3.6 s** | 折 1 个、读 **2 KB**、**57 ms** |
+| 启动（无变化） | 每个多天会话都重折 | **0 个、16 ms** |
+| 冷启动（无缓存，338 个日志） | 19.6 s，单次阻塞可到 ~0.8 s | 18.6 s，**最长阻塞 ~0.4 s** |
+| 使用中（每次轮询） | 活动会话整份重解压 | 只解压新追加的帧 |
+
+三条不变量：
+
+- **折不全就重折**：只有「同一路径、比游标更长」才走增量；变短、换路径、无游标、无旧记录一律从头折 —— 尾部读法假设前缀没变。
+- **不删自己没看过的天**：增量折出来的记录只覆盖窗口内的天，所以 `put(record, { keepOtherDays: true })` 跳过「记录里没有的天就删掉」那一步。否则折一次今天就会把窗口外的历史删光。
+- **不许伪造新日期**：尾部里的某天若不在旧记录里（时钟跳了、日志被原地重写），这次折叠作废、改为从头折。`test/cache.verify.mjs` 里 8 条断言钉住这些（只读增量字节数、两天相加不翻倍、无变化读 0、游标是日志大小而不是旧天戳、半行不算/补全后只算一次）。
+
+剩下的一份成本是**冷启动必须把 348 MB 读一遍**（一次性的，之后每次启动都只读增量）。它现在是**按解码字节数让出事件循环**的（每 1 MB 让一次 —— 按帧让会适得其反：一个 12 MB 日志有 34 000 帧，`setImmediate` 往返比解码本身还贵，实测 21 s 变 52 s）：18.6 秒的总时长里最长阻塞 ~0.4 秒，宿主照常启动、界面照常响应，徽标先显示「…」再填上数字。
+
+**等价性核对（真机）**：同一份 334 MB / 338 个日志，「读快照 + 只折尾部」与「清空缓存全量重折」在**共同可见的 68 天上逐日完全一致**（input、请求数逐项相等）；库里另外多的 3 天来自**日志已被删除**的会话 —— 那正是缓存有意保留的历史，全量重折本来就看不回来。
+
 ### `按年` 视图：年份列表属于数据，不属于代码
 
 历史不删，就迟早要看更早的年。这一年视图有三条决定：
@@ -373,8 +399,8 @@ npm test
 | `test/pricing.verify.mjs` | 用临时 `DSH_HOME` + 合成会话日志跑真实宿主半，断言精确金额。第一组用例**逐字移植自桌面壳的 `pricing-key-case.verify.mjs`**（同样的 fixture、同样的期望值），用来证明移植后的定价与原实现一致；另覆盖上下文档位（严格大于、`"128K"` 紧凑写法、缓存 token 计入上下文）、峰谷 `days` 规则、跨币种换算、前缀行的四条优先级规则（精确行优先、长前缀优先、星号不是分隔符、裸 `*` 仍是死配置）、隐式前缀回退（官方行兜住自己的变体、分隔符边界让 `gpt-4` 吞不掉 `gpt-4o`、开关经 PUT 路由后在**同一个进程内**立刻重算），以及未匹配模型不计价的语义（哪些行算「匹配」、token 仍计入、快照列出被跳过的路由）、逐行/表级的 `honorHolidays`（既有「节假日盖过行内规则」也有「行内拒绝日历后照样收峰价」）、行编辑器的写入路径（整份 `overrides` 经 PUT 落盘、其它字段与两个开关不受影响）、**`default` 行是整体替换而非字段合并**（清空的字段真的消失、`{}` 被当成「没有这一行」）、以及**一行 `null` 覆盖行**被跳过而不是让 `/summary` 500 |
 | `test/holidays.verify.mjs` | 节假日日历的行为：工作日节假日全天空闲、**调休周末仍按空闲价**（政策原文说周末全天空闲）、旧配置里的 `holidays.workdays` 被忽略、关闭日历时回到旧的按星期行为、自定义 `extra`、同一个月内不同日子的分类互不干扰，以及**2027 年的单日端午/中秋**（同一天 10:30，节当天 x1、旁边的周三 x2）与 2027-02-14 调休周日 |
 | `test/official-pricing.verify.mjs` | 解析器对**中英文两个页面快照**的逐字段断言（含旧模型别名、时区识别与换算）；页面结构变化时会抛错而不是静默返回错价；`应用` 的合并语义（未知字段存活、已有的 `default` 行不动、没有 `default` 行时按官方第一条补一个并报告 `defaultFrom`、页面第一条确实是最便宜那档）；并用**被 stub 掉的 fetch** 跑通两个路由，最后验证应用后的价格真的参与计费（含未列出模型按生成的 default 行计价），以及兜底行的完整生命周期：删除 → 回到内置模板并把 `defaultSource` 报成 `template` → 再次应用从官方第一条生成回来 → 手改过的兜底行不会被应用覆盖 |
-| `test/cache.verify.mjs` | 缓存存储层：**两个后端跑同一套契约断言**（会话游标与桶的往返、`hourly` 槽位与逐请求记录、重写会话即替换它的日期集合、`years()` 的年份列表与有界区间读），以及只有跨重启才看得见的行为 —— **删掉会话日志后历史仍在**（新挂载的宿主照旧报出同样的金额）、**没有变化的一轮刷新不写文件**、**超出加载窗口的那天留在库里只是不读进来**（换个更宽的窗口还能取到）、旧 `cache.json` **迁移一次**并把旧文件改名为 `.migrated`（且 `.migrated` 之后**不再被读**）、**读不出来的缓存文件被改名保留并新建一个**、**更新版本的库只读使用且绝不改名**、加载窗口必须大于快照窗口这条不变量，以及 `按年` 路由（三年以前那一年照样读得到、12 个月恒定、`daily` 带节假日标记与 provider 拆分、没有数据的年份是 12 个空月而不是报错、非法年份 400）。 |
-| `test/client.render.mjs` | 用替身 Loader 加载浏览器 bundle，检查 slot 注册形状与 `id`，再用 `react-dom/server` 渲染两个面板，断言金额格式、区间页签（含 `按年`：下拉只列出宿主报的那几年、选中的那一年被选中、月份轴恒为 12、点数是 12 × 序列数、四张卡片是那一年的合计、这一档不画热力图、没有年份时不渲染空下拉）、四序列折线的条数与配色、图例开关（单独显示某一条时的折线条数，以及面积填充有没有跟着走）、悬停 tooltip 的装配、provider 页签、热力图的格数（371 − 今天之后的那几天）与分档、官方价格表内容、两个开关（前缀回退与未匹配模型计价：开/关两种状态各自渲染出的说明与动作、default 行的来源标注、以及「哪些模型没价格」的提示）、**覆盖行编辑器**（每行的编辑/删除动作、倍率与峰谷列恒定存在、表单用被编辑行的真实数值预填而不是空模板、自定义规则才展开规则字段、新增行不给删除按钮、**兜底行同样可编辑可删除且不提供那些不生效的字段**、**重名键与「改过的行」会被保存拦下**、**旧宿主不会被说成「兜底行还没有」**、以及「保留未显示字段」与拒绝写 NaN 的源码断言）、节假日徽标与日历区块、展开/收起两种行形态、**弹窗那一段 CSS 里不许出现任何宿主颜色令牌（`--dsw-`），必须自带浅色/深色两套 `--dub-*` 调色板**，以及空数据 / 稀疏 provider 两个边界不崩 |
+| `test/cache.verify.mjs` | 缓存存储层：**两个后端跑同一套契约断言**（会话游标与桶的往返、`hourly` 槽位与逐请求记录、重写会话即替换它的日期集合、`years()` 的年份列表与有界区间读），以及只有跨重启才看得见的行为 —— **删掉会话日志后历史仍在**（新挂载的宿主照旧报出同样的金额）、**没有变化的一轮刷新不写文件**、**超出加载窗口的那天留在库里只是不读进来**（换个更宽的窗口还能取到）、旧 `cache.json` **迁移一次**并把旧文件改名为 `.migrated`（且 `.migrated` 之后**不再被读**）、**读不出来的缓存文件被改名保留并新建一个**、**更新版本的库只读使用且绝不改名**、加载窗口必须大于快照窗口这条不变量、**增量折叠**（重启只读新追加的字节且读的字节数正好等于追加量、两天相加不翻倍、无变化时读 0、游标是日志大小而不是最早那天的戳、半行不算而补全后只算一次），以及 `按年` 路由（三年以前那一年照样读得到、12 个月恒定、`daily` 带节假日标记与 provider 拆分、没有数据的年份是 12 个空月而不是报错、非法年份 400）。 |
+| `test/client.render.mjs` | 用替身 Loader 加载浏览器 bundle，检查 slot 注册形状与 `id`，再用 `react-dom/server` 渲染两个面板，断言金额格式、区间页签（含 `按年`：下拉只列出宿主报的那几年、选中的那一年被选中、月份轴恒为 12、点数是 12 × 序列数、四张卡片是那一年的合计、这一档不画热力图、没有年份时不渲染空下拉）、四序列折线的条数与配色、图例开关（单独显示某一条时的折线条数，以及面积填充有没有跟着走）、悬停 tooltip 的装配、provider 页签、热力图的格数（371 − 今天之后的那几天）与分档、官方价格表内容、两个开关（前缀回退与未匹配模型计价：开/关两种状态各自渲染出的说明与动作、default 行的来源标注、以及「哪些模型没价格」的提示）、**覆盖行编辑器**（每行的编辑/删除动作、倍率与峰谷列恒定存在、表单用被编辑行的真实数值预填而不是空模板、自定义规则才展开规则字段、新增行不给删除按钮、**兜底行同样可编辑可删除且不提供那些不生效的字段**、**重名键与「改过的行」会被保存拦下**、**旧宿主不会被说成「兜底行还没有」**、以及「保留未显示字段」与拒绝写 NaN 的源码断言）、节假日徽标与日历区块、展开/收起两种行形态、**没有用量的那天金额仍贴右**（token 槽位渲染但为空）、**弹窗那一段 CSS 里不许出现任何宿主颜色令牌（`--dsw-`），必须自带浅色/深色两套 `--dub-*` 调色板**，以及空数据 / 稀疏 provider 两个边界不崩 |
 | `test/smoke.mjs` | 对着**本机真实**的 `$DSH_HOME` 跑一遍，打印徽标金额、今日 token 构成、当前峰谷档位、节假日日历状态、最近 7 天，以及滚动热力图那 371 天的分档分布（有用量的天数与四档各多少天，都挤在一档说明这张图会显得很平） |
 | `test/official-pricing.live.mjs` | **联网**核对：抓真实页面并与 `test/fixtures/` 的快照逐字段比对，确认官方页面仍能解析、价格未变 |
 
@@ -824,6 +850,7 @@ storages/usage-badge/host.lock     # { pid, startedAt, instanceId, hostname, at
 - **首次启动要冷扫一遍全部日志**（实测 209 份日志约 10 秒，分片让出事件循环，不会卡住宿主）。之后走增量：实测热启动 237ms、折叠 0 份。缓存文件丢失才会再次冷扫。
 - **历史依赖日志仍在盘上，但「变短」不再吃掉历史**：已删除的日志靠缓存里保留的贡献继续计入；缓存也丢了，那段历史就没了。日志**变短或还原成更早的备份**时不再删缓存里的天：折叠结果变小只会写进 `fallback` 槽位，`current`（读的时候认的那份）仍是更完整的那份。只有日志**更全**、却不再包含某一天时，那天才会被丢掉（section 8 有正反两个方向的断言）。**例外是改名**：会话身份是日志所在目录名，改名会让同一份用量各算一份。
 - **缓存只把最近 430 天装进内存**（`CACHE_WINDOW_DAYS`，比快照要的 400 天宽）：更早的行留在库里，`按年` 视图能直接查它们，但**日粒度**的区间（`近 N 日`）与热力图仍只覆盖最近一年。
+- **第一次折叠（或缓存被删掉之后）仍要把全部会话日志读一遍**：本机 348 MB / 338 个日志约 21 秒。它是按帧让出事件循环的（实测最长一次阻塞 203 ms），所以不会拖住宿主启动，但徽标会先显示「…」再填上数字；之后每次启动只读增量（同一台机器实测：1 个日志、2 KB、57 ms）。
 - **没有 `node:sqlite` 的运行时会退回旧的 JSON 缓存**：功能一样，但保存代价与常驻内存随历史长度增长（就是换 SQLite 之前的实测数字）。面板的 ⓘ 会写明当前用的是哪一种。
 - **云同步是手动触发的**：面板上的「立即同步」+「测试连接」是目前唯一的入口（价格表变更后的自动推送、启动后延迟一次都还没接）。数据仍然只在一台机器上直到你点它 —— 换机器、重装、或删掉缓存目录，都会丢掉「日志里已经没有」的那段历史（日志还在的部分能重新折出来）。设计见上面「云同步」一节。
 - **折叠结果是日志所在目录 × 日期**：缓存按 `(会话目录, 日期)` 存，所以把某个会话目录**改名**会让同一份用量出现两个会话，**各算一份**（实测 `¥1.5 → ¥3.0`）。行模型只能处理「同一个会话的多个副本」，管不了会话 id 本身漂移 —— 要修需要从日志 header 取稳定的会话 id。删日志、截断日志、还原旧备份这三种情况现在都不会丢历史。

package/lib/buckets.js

@@ -297,12 +297,18 @@ export function resolveRows(records) {
     const byDate = [...entry.winners.values()].sort((a, b) => (a.date < b.date ? -1 : a.date > b.date ? 1 : 0))
     for (const row of byDate) days.set(row.date, deserializeDay(row.routes))
     const winner = byDate[0] ?? null
+    // The session's stamp is its **cursor** — the log version this device last folded it from —
+    // not the stamp of one of its days. A day row keeps the stamp of the fold that wrote it, and a
+    // fold rewrites only the days whose buckets changed, so the oldest day of a long-lived session
+    // carries a months-old stamp. Reading the cursor off that day made every multi-day session look
+    // changed on every start, which re-folded the whole log (measured: 3.6 s per start, 20 s cold).
+    // The day stamp is only a fallback for a record that arrived without a cursor.
     resolved.push({
       sessionId: entry.sessionId,
       path: entry.path,
-      fileSize: winner?.fileSize ?? entry.fileSize ?? 0,
-      fileMtimeMs: winner?.fileMtimeMs ?? entry.fileMtimeMs ?? 0,
-      seq: winner?.seq ?? entry.seq ?? -1,
+      fileSize: entry.fileSize ?? winner?.fileSize ?? 0,
+      fileMtimeMs: entry.fileMtimeMs ?? winner?.fileMtimeMs ?? 0,
+      seq: entry.seq ?? winner?.seq ?? -1,
       provider: entry.provider,
       model: entry.model,
       days,

package/lib/cache-store.js

@@ -351,6 +351,9 @@ function createJsonStore({ path, log }) {
     put(record, options = {}) {
       const doc = ensureDocument()
       const at = options.at ?? Date.now()
+      // A tail fold carries only the days the appended bytes touched, so the days it does not
+      // mention are not rows the log lost — they are rows this fold never looked at.
+      const keepOtherDays = options.keepOtherDays === true
       const previous = documentToRecord(record.sessionId, doc.sessions[record.sessionId])
       const incoming = rowsOf(record, { source: LOCAL_SOURCE, at })
       const incomingKeys = new Set(incoming.map((row) => `${row.date}\u0000${row.source}`))
@@ -366,7 +369,7 @@ function createJsonStore({ path, log }) {
         //     reaches back to it. A row older than the incoming cursor was folded from a fuller log
         //     — a shorter one now, or a restored backup — and it is all that is left of those days.
         const theirs = rowSource(row) !== LOCAL_SOURCE || rowKind(row) === FALLBACK
-        const keep = theirs || incomingKeys.has(key) || !rowIsNewerOrEqual(cursor, row)
+        const keep = keepOtherDays || theirs || incomingKeys.has(key) || !rowIsNewerOrEqual(cursor, row)
         if (keep) kept.push(row)
       }
       // Grouped by `(date, source, kind)`: the `current` and `fallback` copies of one date share a
@@ -793,7 +796,7 @@ function createSqliteStore({ path, jsonPath, log, DatabaseSync, db: given = null
    *   - when the fold is shorter *and* drops a day, the day is rolled back rather than deleted —
    *     this is what a restored backup looks like, and it is the case the whole row model exists for.
    */
-  const writeSession = (record, { source = LOCAL_SOURCE, at = Date.now() } = {}) => {
+  const writeSession = (record, { source = LOCAL_SOURCE, at = Date.now(), keepOtherDays = false } = {}) => {
     writeCursor(record)
     const cursor = readCursor(record.sessionId)
     const incoming = rowsOf(record, { source, at })
@@ -817,6 +820,12 @@ function createSqliteStore({ path, jsonPath, log, DatabaseSync, db: given = null
     // log. Its `current` row goes with it — unless this log version is itself weaker than the copy
     // already stored, in which case a shortened log is treated as a rollback rather than as a
     // deletion, and the day is kept.
+    //
+    // `keepOtherDays` skips this whole step: a **tail fold** only ever looked at the appended
+    // bytes, so a day it does not mention is a day it never read, not one the log dropped. Without
+    // it, folding the last five minutes of a growing log would delete every day outside the loading
+    // window the record was built from.
+    if (keepOtherDays) return
     for (const row of stored.values()) {
       if (cursor && !rowIsNewerOrEqual(cursor, row)) continue
       deleteRow.run(record.sessionId, row.date, source, CURRENT)
@@ -1036,11 +1045,11 @@ function createSqliteStore({ path, jsonPath, log, DatabaseSync, db: given = null
      * short fold it just produced. Returning the resolved record is what makes "the cache kept it"
      * true in memory as well as on disk.
      */
-    put(record, { at = Date.now() } = {}) {
+    put(record, { at = Date.now(), keepOtherDays = false } = {}) {
       if (!writable) return null
       try {
         db.exec('BEGIN IMMEDIATE')
-        writeSession(record, { source: LOCAL_SOURCE, at })
+        writeSession(record, { source: LOCAL_SOURCE, at, keepOtherDays })
         db.exec('COMMIT')
       } catch (error) {
         try {

package/lib/client.js

@@ -75,6 +75,10 @@ window.__ModuleLoader__.load({
    peak chip into white on white. */
 .dub-dot{flex:none;width:6px;height:6px;border-radius:3px;background:var(--dsw-alias-label-tertiary,#999)}
 .dub-dot-peak{background:var(--dsw-static-amber-500,#f59e0b)}
+/* This span owns the auto margin that pushes the amount to the right edge, so it is
+   rendered even when the day has no token text (an empty flex item still absorbs the
+   free space). Keep the amount's own margin a fixed gap, never auto: two auto margins
+   would split the free space and park the token text in the middle of the row. */
 .dub-pill-tokens{margin-left:auto;flex:none;color:var(--dsw-alias-label-tertiary,#999);font-size:11px;font-variant-numeric:tabular-nums}
 .dub-pill-amount{flex:none;margin-left:6px;color:var(--dsw-alias-label-primary,#111);font-variant-numeric:tabular-nums;font-weight:500}
 /* ── 弹窗自带一套样式，不读宿主的颜色令牌 ─────────────────────────────────────────────────────
@@ -2817,7 +2821,10 @@ html[data-theme="dark"] .dub-mask{
           // The marker is compact, so it carries the band text as its own tooltip:
           // hovering the dot alone explains 峰时 ×2 / 谷时 ×1 / 节假日.
           chip ? h('span', { className: `dub-dot${chip.peak ? ' dub-dot-peak' : ''}`, title: chip.text }) : null,
-          tokenTotal > 0 ? h('span', { className: 'dub-pill-tokens' }, `${tokens(tokenTotal)} tokens`) : null,
+          // Always rendered, even when a day has no tokens: this span owns the row's
+          // `margin-left:auto`, so dropping it on an idle day pulled the amount left and
+          // sat it right beside the label — two different alignments for one row.
+          h('span', { className: 'dub-pill-tokens' }, tokenTotal > 0 ? `${tokens(tokenTotal)} tokens` : ''),
           h('span', { className: 'dub-pill-amount' }, text),
         ),
         open && snapshot

package/lib/fold.js

@@ -17,7 +17,7 @@
  * @module dsh-usage-badge/fold
  */
 
-import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { closeSync, openSync, readSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
 import { zstdDecompressSync } from 'node:zlib'
@@ -57,34 +57,6 @@ export function resolveDshHome(configured, env = process.env) {
   return resolve(expandHome(chosen))
 }
 
-/**
- * Decode a log body that may hold one or more concatenated zstd frames.
- *
- * DSH appends frames as a session grows, so a `.zstd` log is a frame sequence
- * rather than one stream; `zstdDecompressSync` handles a single frame, so the
- * buffer is split on the frame magic first. A body with no frame magic is
- * returned as UTF-8, which keeps plain `.jsonl` and any partially written file
- * readable instead of throwing.
- */
-export function decodeLogBody(buf) {
-  const starts = []
-  let i = 0
-  while ((i = buf.indexOf(ZSTD_MAGIC, i)) !== -1) {
-    starts.push(i)
-    i += 1
-  }
-  if (starts.length === 0) return buf.toString('utf8')
-  if (typeof zstdDecompressSync !== 'function') {
-    throw new Error('this Node build has no zlib.zstdDecompressSync; a zstd session log cannot be read')
-  }
-  let out = ''
-  for (let k = 0; k < starts.length; k++) {
-    const end = k + 1 < starts.length ? starts[k + 1] : buf.length
-    out += zstdDecompressSync(buf.subarray(starts[k], end)).toString('utf8')
-  }
-  return out
-}
-
 function logParent(file) {
   const index = Math.max(file.lastIndexOf('\\'), file.lastIndexOf('/'))
   return index >= 0 ? file.slice(0, index) : ''
@@ -139,45 +111,129 @@ export function sessionIdFromLogPath(file) {
 }
 
 /**
- * Fold one session log into per-day, per-route buckets.
- *
- * Route attribution follows the log's own control events: `request/header` (and
- * `request/context`) carry the provider and model, and each `assistant/message`
- * carries the provider-reported `usage` for one completed request. Requests are
- * stamped with the hour they were *sent* where the log allows it, because a
- * streaming call can cross a peak/valley boundary and filing it by completion
- * would price it in the wrong band.
+ * Read a log's tail without reading the whole file.
  *
- * @returns {object|null} the session record, or null when the file is unreadable.
+ * The fold's cost is dominated by zstd decompression (measured on a real log: 12.7 MB took 775 ms
+ * to decode against 133 ms of `JSON.parse`), so re-decoding a log whose only change is an appended
+ * frame is the one thing worth avoiding. `from` is the byte offset the last fold consumed — which
+ * is exactly the `fileSize` the cursor already stores, so this needs no new field.
  */
-export function foldSession(file, previous) {
-  const sessionId = sessionIdFromLogPath(file)
-  let stat
+function readTail(file, from, size) {
+  if (!(from > 0)) return readFileSync(file)
+  const length = size - from
+  if (!(length > 0)) return Buffer.alloc(0)
+  const fd = openSync(file, 'r')
   try {
-    stat = statSync(file)
-  } catch {
-    return null
+    const buf = Buffer.allocUnsafe(length)
+    let read = 0
+    while (read < length) {
+      const n = readSync(fd, buf, read, length - read, from + read)
+      if (n <= 0) break
+      read += n
+    }
+    return read === length ? buf : buf.subarray(0, read)
+  } finally {
+    closeSync(fd)
   }
-  let body
+}
+
+/** Whether a fragment is exactly one complete JSON value — a torn append is not. */
+function isCompleteJsonLine(fragment) {
+  if (!fragment || !fragment.trim()) return false
   try {
-    body = readFileSync(file)
+    JSON.parse(fragment)
+    return true
   } catch {
-    return null
+    return false
   }
-  let text
-  try {
-    text = decodeLogBody(body)
-  } catch {
-    // An unreadable body keeps whatever this session contributed before, so a
-    // transient decompression failure cannot erase history.
-    return previous ?? null
+}
+
+/**
+ * Split a plain-text log into newline-aligned slices.
+ *
+ * Sliced rather than handed over whole so a large `.jsonl` log cannot hold the event loop for a
+ * second while the rest of the host waits. The final line may have no trailing newline yet — that
+ * is how the last request of an idle log looks, and dropping it would under-count the badge
+ * exactly where eyes are — so it counts when it parses, and a torn append is left for next time.
+ */
+function* plainChunks(text) {
+  const SLICE = 1 << 20
+  let offset = 0
+  while (offset < text.length) {
+    let end = Math.min(offset + SLICE, text.length)
+    if (end < text.length) {
+      const nl = text.lastIndexOf('\n', end - 1)
+      end = nl >= offset ? nl + 1 : text.length
+    }
+    let piece = text.slice(offset, end)
+    if (end >= text.length) {
+      const nl = piece.lastIndexOf('\n')
+      piece = piece.slice(0, nl + 1) + (isCompleteJsonLine(piece.slice(nl + 1)) ? piece.slice(nl + 1) : '')
+      if (!piece) return
+    }
+    yield { bytes: Buffer.byteLength(piece, 'utf8'), text: piece }
+    offset = end
   }
+}
 
-  const sessionDays = new Map()
-  let provider = null
-  let model = null
-  let maxSeq = -1
+/**
+ * The chunks of a body that may be folded, each carrying how many bytes it accounts for.
+ *
+ * A `.zstd` log is a sequence of independently decodable frames that DSH appends to, so "how much
+ * can I fold" is a question about frames, not bytes: a frame that does not decode (the appender is
+ * mid-write) or whose text stops mid-line is left for the next pass rather than folded half way.
+ * Anything that does not begin with a frame magic is plain text, consumed up to its last newline.
+ */
+function* foldableChunks(buf) {
+  const starts = []
+  let i = 0
+  while ((i = buf.indexOf(ZSTD_MAGIC, i)) !== -1) {
+    starts.push(i)
+    i += 1
+  }
+  if (starts.length === 0 || starts[0] !== 0) {
+    yield* plainChunks(buf.toString('utf8'))
+    return
+  }
+  if (typeof zstdDecompressSync !== 'function') {
+    throw new Error('this Node build has no zlib.zstdDecompressSync; a zstd session log cannot be read')
+  }
+  for (let k = 0; k < starts.length; k++) {
+    const end = k + 1 < starts.length ? starts[k + 1] : buf.length
+    let piece
+    try {
+      piece = zstdDecompressSync(buf.subarray(starts[k], end)).toString('utf8')
+    } catch {
+      return // an unfinished frame: the next pass picks it up
+    }
+    if (!piece.endsWith('\n')) {
+      // Only the last frame can be the end of a log, and then only when its final line is itself
+      // complete JSON; anything else is a torn append.
+      if (end === buf.length && isCompleteJsonLine(piece.slice(piece.lastIndexOf('\n') + 1))) {
+        yield { bytes: end - starts[k], text: piece }
+      }
+      return
+    }
+    yield { bytes: end - starts[k], text: piece }
+  }
+}
 
+/** A bucket copied deep enough that a fold can add to it without touching the stored record. */
+function cloneBucket(bucket) {
+  return {
+    ...bucket,
+    hourly: Array.isArray(bucket.hourly) ? bucket.hourly.map((hour) => ({ ...hour })) : bucket.hourly,
+    usageRecords: Array.isArray(bucket.usageRecords) ? bucket.usageRecords.map((usage) => ({ ...usage })) : bucket.usageRecords,
+  }
+}
+
+/**
+ * Add one decoded chunk's events to the fold state.
+ *
+ * Events land in `state.fresh` rather than in the day maps the previous record handed over, so a
+ * tail fold that has to be abandoned leaves that record exactly as it was.
+ */
+function foldText(text, state) {
   for (const line of text.split('\n')) {
     if (!line) continue
     let ev
@@ -187,25 +243,26 @@ export function foldSession(file, previous) {
       continue // a torn tail line is expected on a log being appended
     }
     const seq = typeof ev?.seq === 'number' ? ev.seq : -1
-    if (seq > maxSeq) maxSeq = seq
+    if (seq > state.seq) state.seq = seq
     const data = ev?.data ?? {}
     if (ev?.type === 'request/header') {
       const config = data.header?.config ?? {}
-      provider = config.provider ?? data.provider ?? null
-      model = config.model ?? data.model ?? null
+      state.provider = config.provider ?? data.provider ?? null
+      state.model = config.model ?? data.model ?? null
     } else if (ev?.type === 'request/context') {
-      provider = data.provider ?? provider
-      model = data.model ?? model
+      state.provider = data.provider ?? state.provider
+      state.model = data.model ?? state.model
     } else if (ev?.type === 'assistant/message') {
       const usage = data.usage
       if (!usage || typeof usage !== 'object') continue
-      const pm = provider ?? UNKNOWN
-      const mm = model ?? UNKNOWN
+      const pm = state.provider ?? UNKNOWN
+      const mm = state.model ?? UNKNOWN
       const date = dayKey(ev.time ?? Date.now())
-      let dayObj = sessionDays.get(date)
+      state.dates.add(date)
+      let dayObj = state.fresh.get(date)
       if (!dayObj) {
         dayObj = new Map()
-        sessionDays.set(date, dayObj)
+        state.fresh.set(date, dayObj)
       }
       const key = `${pm}|${mm}`
       const bucket = dayObj.get(key) ?? emptyBucket(pm, mm)
@@ -231,16 +288,115 @@ export function foldSession(file, previous) {
       dayObj.set(key, bucket)
     }
   }
+}
+
+/** Commit this pass's own buckets into the record's days, cloning what it shares with the old one. */
+function mergeFresh(state) {
+  for (const [date, dayObj] of state.fresh) {
+    const existing = state.days.get(date)
+    const target = existing ? new Map(existing) : new Map()
+    for (const [key, bucket] of dayObj) {
+      const known = target.get(key)
+      if (!known) {
+        target.set(key, bucket)
+        continue
+      }
+      const merged = cloneBucket(known)
+      addBucket(merged, bucket)
+      target.set(key, merged)
+    }
+    state.days.set(date, target)
+  }
+}
+
+/**
+ * Fold one session log into per-day, per-route buckets.
+ *
+ * Route attribution follows the log's own control events: `request/header` (and
+ * `request/context`) carry the provider and model, and each `assistant/message`
+ * carries the provider-reported `usage` for one completed request. Requests are
+ * stamped with the hour they were *sent* where the log allows it, because a
+ * streaming call can cross a peak/valley boundary and filing it by completion
+ * would price it in the wrong band.
+ *
+ * **Only the new bytes are decoded.** `fromByte` is where the previous fold stopped (the cursor's
+ * `fileSize`), and the tail is decoded on its own and merged into `previous`: re-decoding the whole
+ * log for one appended frame is what made a start with 25 grown logs cost 3.6 s and a cold cache
+ * 20 s. The returned `fileSize` is the offset this pass actually reached — a torn tail stays
+ * unfolded and is retried next time for the price of the few bytes it holds.
+ *
+ * @param {string} file
+ * @param {object|null} previous - the record this session already has; required for a tail fold.
+ * @param {{fromByte?:number, yieldBytes?:number}} [options]
+ * @returns {Promise<object|null>} the session record, or null when the file is unreadable.
+ */
+export async function foldSession(file, previous = null, { fromByte = 0, yieldBytes = 1 << 20 } = {}) {
+  const sessionId = sessionIdFromLogPath(file)
+  let stat
+  try {
+    stat = statSync(file)
+  } catch {
+    return null
+  }
+  const tail = fromByte > 0 && fromByte <= stat.size
+  let body
+  try {
+    body = readTail(file, tail ? fromByte : 0, stat.size)
+  } catch {
+    return null
+  }
+
+  const state = {
+    // A copy of the map, one level deep: `mergeFresh` replaces whole day entries and cloned
+    // buckets, so an abandoned tail fold cannot leave a mark on the record this session already has.
+    days: tail && previous?.days ? new Map(previous.days) : new Map(),
+    fresh: new Map(),
+    dates: new Set(),
+    provider: tail ? previous?.provider ?? null : null,
+    model: tail ? previous?.model ?? null : null,
+    seq: tail ? previous?.seq ?? -1 : -1,
+  }
+  // `body` holds the tail alone, so offsets inside it are buffer-relative; `consumed` is reported
+  // in file coordinates, which is what the cursor stores.
+  const shift = tail ? fromByte : 0
+  let consumed = shift
+  let sinceYield = 0
+  try {
+    for (const chunk of foldableChunks(body)) {
+      foldText(chunk.text, state)
+      consumed += chunk.bytes
+      // Yield on **bytes decoded**, not on a count of frames: a 12 MB log is ~34 000 frames, so
+      // yielding per few frames cost more in `setImmediate` round-trips than the decoding did
+      // (measured: a 338-log cold fold went from 21 s to 52 s). One megabyte is ~30 ms of zstd
+      // work — small enough that the host keeps breathing, rare enough to be free.
+      sinceYield += chunk.bytes
+      if (sinceYield >= yieldBytes) {
+        sinceYield = 0
+        await new Promise((resolve) => setImmediate(resolve))
+      }
+    }
+  } catch {
+    // An unreadable body keeps whatever this session contributed before, so a
+    // transient decompression failure cannot erase history.
+    return previous ?? null
+  }
+  mergeFresh(state)
 
   return {
     sessionId,
     path: file,
-    fileSize: stat.size,
+    fileSize: consumed,
     fileMtimeMs: stat.mtimeMs || 0,
-    seq: maxSeq,
-    provider,
-    model,
-    days: sessionDays,
+    seq: state.seq,
+    provider: state.provider,
+    model: state.model,
+    days: state.days,
+    // Which days this pass itself added. A tail fold may add a day (a session running past
+    // midnight does exactly that), but it may never add one *older* than the newest day the record
+    // already holds: an append only moves forward, so an older day means the log was rewritten
+    // rather than appended to, and the caller re-folds the session from the start.
+    touchedDates: [...state.dates],
+    foldedBytes: consumed,
   }
 }
 
@@ -351,12 +507,14 @@ export function createAggregator({ sessionsRoot, store, log = () => {} }) {
    * reason the store is not a single document, and it means there is no save timer to lose
    * work in and no moment where a burst of edits has to be batched.
    *
-   * @returns {Promise<{files:number, folded:number, ms:number}>} what this pass did.
+   * @returns {Promise<{files:number, folded:number, tailed:number, bytesRead:number, ms:number}>} what this pass did.
    */
   async function refresh() {
     const started = Date.now()
     const files = listLogFiles(sessionsRoot)
     let folded = 0
+    let tailed = 0
+    let bytesRead = 0
     let sinceYield = 0
     for (const file of files) {
       const sessionId = sessionIdFromLogPath(file)
@@ -371,7 +529,35 @@ export function createAggregator({ sessionsRoot, store, log = () => {} }) {
         continue
       }
       const previous = records.get(sessionId)
-      const record = foldSession(file, previous)
+      // The cursor's `fileSize` is the byte offset the last fold consumed, so a log that only grew
+      // is folded from there. Everything else — a shorter log, a different path, no cursor, no
+      // record to fold into — is a full re-fold, because a tail read assumes the prefix is intact.
+      const tailFrom =
+        previous && cursor && cursor.path === file && cursor.fileSize > 0 && stat.size > cursor.fileSize
+          ? cursor.fileSize
+          : 0
+      let record = await foldSession(file, tailFrom > 0 ? previous : null, { fromByte: tailFrom })
+      let tail = tailFrom > 0 && Boolean(record)
+      if (tail && record !== previous) {
+        // A tail fold may add a day — a session running past midnight does exactly that — but the
+        // days it adds cannot be *older* than the newest one already folded: an append only moves
+        // forward. An older day means the file was rewritten in place, so the prefix this pass did
+        // not look at is not the prefix the record was built from; fold that session from the start.
+        let newest = ''
+        for (const date of previous.days?.keys() ?? []) if (date > newest) newest = date
+        const stale = newest !== '' && record.touchedDates?.some((date) => date < newest)
+        if (stale) {
+          record = await foldSession(file, previous, {})
+          tail = false
+        }
+      } else if (!record) {
+        tail = false
+      }
+      if (record) {
+        bytesRead += tail && tailFrom > 0 ? Math.max(0, (record.fileSize ?? 0) - tailFrom) : (record.fileSize ?? 0)
+        delete record.touchedDates
+        delete record.foldedBytes
+      }
       // `foldSession` hands the previous record straight back when it could not read the log, and
       // that record is already in the store — writing it again would replace the session's rows
       // with only the days this process happens to hold (the loading window), deleting the older
@@ -379,6 +565,7 @@ export function createAggregator({ sessionsRoot, store, log = () => {} }) {
       // fold, which is what a transient read failure wants.
       if (record && record !== previous) {
         folded++
+        if (tail) tailed++
         // Written back one session at a time, right here: a save costs the changed session's
         // days, not the whole history, so there is nothing to batch and no timer to lose it in.
         //
@@ -386,9 +573,13 @@ export function createAggregator({ sessionsRoot, store, log = () => {} }) {
         // the fold just produced, but when the log got shorter the store keeps the fuller copy
         // it already had — and then *that* is the truth, because the whole point of the row
         // model is that a shortened log cannot make history disappear.
+        //
+        // `keepOtherDays` is what makes a tail fold safe to write: the record it carries covers
+        // the loading window, not the session's whole history, so the days outside the window are
+        // this process's blind spot rather than rows the log no longer has.
         let effective = record
         try {
-          effective = store.put(record, { source: LOCAL_SOURCE }) ?? record
+          effective = store.put(record, { source: LOCAL_SOURCE, keepOtherDays: tail }) ?? record
         } catch (error) {
           log(`cache write failed for ${sessionId}: ${error?.message ?? error}`)
         }
@@ -411,7 +602,7 @@ export function createAggregator({ sessionsRoot, store, log = () => {} }) {
     // being refreshed — and, because nothing writes it again, that history stays in the store
     // for good rather than being erased by the log's absence.
     if (folded > 0) mergeDays()
-    lastRefresh = { files: files.length, folded, ms: Date.now() - started, at: Date.now() }
+    lastRefresh = { files: files.length, folded, tailed, bytesRead, ms: Date.now() - started, at: Date.now() }
     return lastRefresh
   }
 

package/lib/index.js

@@ -1068,6 +1068,7 @@ export function apply(ctx) {
       aggregator.flush()
       log(
         `ready: ${aggregator.sessionCount} session(s) over ${status.files} log(s), folded ${status.folded} in ${status.ms}ms` +
+          ` (${status.tailed ?? 0} of them from the tail only, ${Math.round((status.bytesRead ?? 0) / 1024)} KB read)` +
           `; cache: ${store.kind}` +
           (rules.enabled ? `; holiday calendar on (${rules.holidays.size} holidays)` : ''),
       )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-usage-badge",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "DeepSeek Harness 的用量徽标插件：侧边栏底部一行显示当天的 token 总量与估算费用，点开可看 24 小时 / 近 7 日 / 近 30 日 / 近 12 个月 / 按年用量，按 provider 筛选，并按 DeepSeek 官方定价与中国法定节假日计价。A usage badge plugin for DeepSeek Harness: today's tokens and estimated spend in the sidebar, with 24h / 7d / 30d / 12-month and per-year charts, official DeepSeek pricing and Chinese public holidays.",
   "type": "module",
   "main": "lib/index.js",