dsh-all-usage 1.0.7 → 1.0.8

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to `dsh-all-usage` are documented here.
 
+## [1.0.8] - 2026-08-23
+
+### Added
+
+- Added a restart read-avoidance cursor: on startup the plugin uses the persisted log revision (via `sessionPersistence.listSnapshots()`, a header-line + stat read) as a per-session change signal. Sessions whose log is unchanged since the last ledger write are applied straight from the durable ledger without reading their full event log; only changed or new sessions are read (incrementally).
+- Stored the log revision in each durable ledger record (`lastRevision`); existing rows without it are re-read once and backfilled, so behavior is backward compatible.
+
+### Fixed
+
+- Eliminated the per-session full-event read at restart for unchanged persisted sessions, so DSH restarts no longer re-read every session's history from scratch.
+
 ## [1.0.7] - 2026-08-23
 
 ### Added
@@ -51,6 +62,7 @@ All notable changes to `dsh-all-usage` are documented here.
 - Allowed same-origin browser balance GET requests that omit `Origin` while retaining token protection.
 - Standardized English date buckets, range filters, streaks, heatmap dates, and export timestamps on UTC.
 
+[1.0.8]: https://github.com/ParticleLight/dsh-all-usage/releases/tag/v1.0.8
 [1.0.7]: https://github.com/ParticleLight/dsh-all-usage/releases/tag/v1.0.7
 [1.0.6]: https://github.com/ParticleLight/dsh-all-usage/releases/tag/v1.0.6
 [1.0.5]: https://github.com/ParticleLight/dsh-all-usage/releases/tag/v1.0.5

package/README.md

@@ -18,15 +18,15 @@ DeepSeek Harness 全量用量看板：按模型、供应商、工作区和时间
 - **工作区别名**：在侧栏入口打开看板后管理，持久化保存到 $DSH_HOME/storages 的 KV 单元 `all_usage_aliases`
 - **界面语言**：在看板顶部切换中文与 English；选择会保存到浏览器本地
 - **完整历史与增量重建**：基线扫描全部可读历史会话；独立用量账本同时作为每会话游标——未变化的会话直接复用账本，新增事件只增量回填，长历史重启不再全量重建
+- **重启免读**：用持久化日志的 revision 作为每会话的变更信号（只读头部行 + stat，不读全量）——日志未变的会话重启时连事件都不读，直接从账本复用；仅日志变化（新增/修改）的会话才做增量读取
 - **Token 口径**：输入按「未含缓存命中」计，缓存命中 / 写入与推理独立成桶；全 0 用量的重放事件不会覆盖已记录的真实用量，仅缓存命中的请求也会计入
 
 ### 最近更新
 
-**v1.0.7**
+**v1.0.8**
 
-- 增量游标：启动重扫只增量回填新增事件，未变化的会话直接从独立账本复用，不再全量重建
-- 全 0 用量防护：全 0 用量的重放事件不会覆盖已记录的真实用量；纯缓存命中的请求仍会计入
-- 结构化语义声明：API 返回机读的 token 口径（输入不含缓存命中，缓存与推理独立成桶）
+- 重启免读：用持久化日志的 revision 做每会话变更信号，未变化会话重启时完全不读事件，直接复用账本；仅在日志变化时增量读取
+- 账本记录持久化每会话的日志 revision（旧记录首次重读后自动回填）
 
 完整版本记录见 [CHANGELOG.md](CHANGELOG.md)。
 
@@ -104,15 +104,15 @@ A full usage dashboard for DeepSeek Harness. Analyze tokens, cache behavior, acc
 - **Workspace aliases**: manage aliases from the sidebar dashboard; values persist in the $DSH_HOME/storages KV cell `all_usage_aliases`
 - **Interface language**: switch between Chinese and English from the dashboard header; your choice persists locally in the browser
 - **Full history & incremental rebuild**: the baseline scans every readable historical session; the durable usage ledger doubles as a per-session cursor, so unchanged sessions are reused straight from the ledger and only newly appended events are folded — long histories restart without a full rebuild
+- **Restart with no re-read**: the persisted log revision (a header-line + stat via `sessionPersistence.listSnapshots()`) acts as a per-session change signal — sessions whose log is unchanged are applied from the ledger on restart without reading their events at all; only changed/new sessions are read incrementally
 - **Token accounting semantics**: input tokens are fresh (exclude cache hits/writes, which sit in separate buckets along with reasoning); all-zero usage replays never overwrite recorded usage, while cache-only requests still count
 
 ### Latest Update
 
-**v1.0.7**
+**v1.0.8**
 
-- Incremental scan cursor: restarts re-fold only newly appended events; unchanged sessions are seeded straight from the durable ledger instead of a full rebuild
-- All-zero usage guard: zero-usage replays no longer overwrite recorded usage, while pure cache-read requests still count
-- Structured token semantics: the API now declares a machine-readable accounting contract (input excludes cache; cache and reasoning are separate buckets)
+- Restart with no re-read: the persisted log revision acts as a per-session change signal, so unchanged sessions are applied from the ledger on restart without reading any events; only changed logs are read incrementally
+- The ledger now stores each session's log revision; existing rows are re-read once and backfilled automatically
 
 See [CHANGELOG.md](CHANGELOG.md) for the complete version history.
 

package/lib/index.js

@@ -3,7 +3,7 @@
 import { randomBytes, timingSafeEqual } from 'node:crypto'
 
 const name = 'dsh-all-usage'
-const inject = ['sessionQuery', 'workspaceRegistry', 'timer', 'storage']
+const inject = ['sessionQuery', 'workspaceRegistry', 'timer', 'sessionPersistence', 'storage']
 
 // webServer route handlers do not inherit the connection API fence; keep this plugin
 // local and require a browser-originated capability for state-changing reads/writes.
@@ -75,6 +75,10 @@ function apply(ctx) {
   const settings = ctx.get('settings')
   const storage = ctx.get('storage')
   const webServer = ctx.get('webServer')
+  // v1.0.8: optional sessionPersistence exposes listSnapshots() — a cheap per-session
+  // revision (header line + stat, no full-log read) that lets the baseline skip
+  // re-reading unchanged sessions after a DSH restart.
+  const sessionPersistence = ctx.get('sessionPersistence')
 
   // ---------- owned aggregation state ----------
   const wsMeta = new Map()
@@ -301,7 +305,7 @@ function apply(ctx) {
   function ledgerEventKey(event, index) {
     return typeof event.seq === 'number' ? String(event.seq) : 'event:' + index
   }
-  function buildLedgerRecord(session, workspaceId, source = 'scan') {
+  function buildLedgerRecord(session, workspaceId, source = 'scan', revision) {
     const sid = session && typeof session.id === 'string' ? session.id : ''
     const events = session && Array.isArray(session.events) ? session.events : []
     if (sid === '' || workspaceId === undefined) return null
@@ -335,7 +339,7 @@ function apply(ctx) {
       if (previous !== undefined && eventSeq >= 0 && previous.seq > eventSeq) continue
       usage.set(key, { key, seq: eventSeq, time: event.time, workspaceId, modelId, values })
     }
-    return { version: LEDGER_VERSION, sessionId: sid, workspaceId, lastSeq: lastSeqOf(events), source, updatedAt: nextLedgerRevision(), turns: Array.from(turns.values()), usage: Array.from(usage.values()) }
+    return { version: LEDGER_VERSION, sessionId: sid, workspaceId, lastSeq: lastSeqOf(events), source, updatedAt: nextLedgerRevision(), lastRevision: typeof revision === 'string' ? revision : undefined, turns: Array.from(turns.values()), usage: Array.from(usage.values()) }
   }
   function normalizeLedgerRecord(raw, key) {
     if (raw === null || typeof raw !== 'object' || raw.version !== LEDGER_VERSION || typeof raw.sessionId !== 'string' || raw.sessionId !== key) return null
@@ -353,7 +357,7 @@ function apply(ctx) {
     }
     const updatedAt = typeof raw.updatedAt === 'number' ? raw.updatedAt : 0
     ledgerRevision = Math.max(ledgerRevision, updatedAt)
-    return { version: LEDGER_VERSION, sessionId: raw.sessionId, workspaceId: raw.workspaceId, lastSeq: typeof raw.lastSeq === 'number' ? raw.lastSeq : -1, source: raw.source === 'flush' ? 'flush' : 'scan', updatedAt, turns: Array.from(turnMap.values()), usage: Array.from(usageMap.values()) }
+    return { version: LEDGER_VERSION, sessionId: raw.sessionId, workspaceId: raw.workspaceId, lastSeq: typeof raw.lastSeq === 'number' ? raw.lastSeq : -1, source: raw.source === 'flush' ? 'flush' : 'scan', updatedAt, lastRevision: typeof raw.lastRevision === 'string' ? raw.lastRevision : undefined, turns: Array.from(turnMap.values()), usage: Array.from(usageMap.values()) }
   }
   function applyLedgerRecord(record) {
     if (record === null || record === undefined) return
@@ -530,6 +534,22 @@ function apply(ctx) {
     } catch (err) {
       console.error('[all-usage] session list failed:', err)
     }
+    // v1.0.8: cheap per-session change signal (header line + stat, no full-log read)
+    let snapshots = null
+    if (sessionPersistence !== undefined && typeof sessionPersistence.listSnapshots === 'function') {
+      try {
+        const rows = await sessionPersistence.listSnapshots()
+        if (Array.isArray(rows)) {
+          snapshots = new Map()
+          for (const row of rows) {
+            const rid = row && row.header && typeof row.header.id === 'string' ? row.header.id : undefined
+            if (rid !== undefined && row && typeof row.revision === 'string') snapshots.set(rid, row.revision)
+          }
+        }
+      } catch (err) {
+        console.error('[all-usage] session persistence snapshots unavailable:', err)
+      }
+    }
     if (disposed || generation !== aggregationGeneration) return
     if (setupFailed || !Array.isArray(records)) {
       // A transient registry failure must not be reported as a completed empty scan.
@@ -567,6 +587,20 @@ function apply(ctx) {
         if (disposed || generation !== aggregationGeneration) return
         try {
           if (sessionSeq.has(sid)) return
+          // v1.0.8: when the persisted log revision is unchanged since the last ledger
+          // write, the whole readSession (full event transfer) is skipped — the ledger
+          // record is applied directly and the live feed keeps catching new events.
+          const previousRecord = ledgerRecords.get(sid)
+          const revision = snapshots === null ? undefined : snapshots.get(sid)
+          if (previousRecord !== undefined && typeof previousRecord.lastRevision === 'string' && typeof revision === 'string' && revision === previousRecord.lastRevision) {
+            applyLedgerRecord(previousRecord)
+            for (const item of previousRecord.usage) {
+              usageByStep.set(item.key, { seq: item.seq, wsId: item.workspaceId, time: item.time, values: item.values, modelId: item.modelId, sid })
+            }
+            sessionSeq.set(sid, previousRecord.lastSeq)
+            sessionCount.add(sid)
+            return
+          }
           const snap = await ctx.sessionQuery.readSession(sid)
           if (disposed || generation !== aggregationGeneration) return
           if (snap && Array.isArray(snap.events)) {
@@ -585,6 +619,12 @@ function apply(ctx) {
                 usageByStep.set(item.key, { seq: item.seq, wsId: item.workspaceId, time: item.time, values: item.values, modelId: item.modelId, sid })
               }
               if (previous.lastSeq >= currentLastSeq) {
+                // Content unchanged despite a revision change (rare: ctime-only churn):
+                // refresh the stored revision so future restarts can skip the read.
+                if (revision !== undefined && previous.lastRevision !== revision) {
+                  previous.lastRevision = revision
+                  void persistLedgerRecord(previous)
+                }
                 sessionSeq.set(sid, previous.lastSeq)
                 sessionCount.add(sid)
                 return
@@ -593,7 +633,7 @@ function apply(ctx) {
             } else {
               foldEvents(wsId, snap.events, undefined, sid)
             }
-            const ledger = buildLedgerRecord({ id: sid, header: record.header, events: snap.events }, wsId)
+            const ledger = buildLedgerRecord({ id: sid, header: record.header, events: snap.events }, wsId, 'scan', revision)
             const canonical = ledger === null ? ledgerRecords.get(sid) : storeLedgerRecord(ledger)
             if (canonical === ledger) {
               void persistLedgerRecord(ledger)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-all-usage",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "DeepSeek Harness usage dashboard with model, provider, workspace, cache, balance, and CSV insights",
   "repository": {
     "type": "git",