dsh-all-usage 1.0.5 → 1.0.7

package/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to `dsh-all-usage` are documented here.
+
+## [1.0.7] - 2026-08-23
+
+### Added
+
+- Added an incremental ledger cursor: baseline rescans reuse the durable ledger as a per-session cursor, so unchanged sessions seed from the ledger instead of re-folding every historical event, and changed sessions fold only the new tail.
+- Added an all-zero usage guard: zero-token usage replays no longer overwrite already-recorded turn/step usage, while pure cache-read requests (billable cache hits with no input/output) are still counted.
+- Added a structured, machine-readable token semantics declaration (`tokenSemantics.semantics`) to the `/api/all-usage` snapshot: input is fresh (excludes cache), cache and reasoning are separate buckets.
+
+### Fixed
+
+- Reduced startup scan cost on long usage history: sessions whose events are unchanged since the last ledger write are no longer re-folded or rewritten.
+- Prevented a live retry of an already-recorded step from double-counting after a fresh-instance seed.
+
+## [1.0.6] - 2026-08-23
+
+### Added
+
+- Added a durable per-session usage ledger written at the awaited `session/flush` boundary.
+- Preserved successfully flushed turns and token usage after conversation logs are deleted.
+- Added automatic rebuilds from ledger records after session disposal or reconciliation detects missing logs.
+
+### Fixed
+
+- Prevented stale baseline snapshots from overwriting newer flushed ledger records.
+- Normalized duplicate ledger keys during hydration and guarded ledger writes during plugin disposal.
+- Prevented inactive Cordis timer contexts from escalating into fatal DSH load failures.
+- Replaced invalid hyphenated storage unit names with valid underscore names.
+
+## [1.0.5] - 2026-08-20
+
+### Added
+
+- Added custom start/end date ranges across all available historical daily data.
+- Kept the heatmap as a fixed latest-53-week view while allowing older range aggregation and CSV export.
+- Added distinct session counts for bounded ranges.
+
+### Fixed
+
+- Added baseline retry with backoff after transient session registry failures.
+- Stopped in-flight scans and stale polling responses after plugin disposal or refresh races.
+
+## [1.0.4] - 2026-08-19
+
+### Fixed
+
+- Hardened loopback, same-origin, method, and process-token checks for dashboard API routes.
+- 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.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
+[1.0.4]: https://github.com/ParticleLight/dsh-all-usage/releases/tag/v1.0.4

package/README.md

@@ -15,8 +15,20 @@ DeepSeek Harness 全量用量看板：按模型、供应商、工作区和时间
 - **摘要与工作区**：Token 用量、缓存命中、账户余额、连续使用、工作区 Token 分布和明细
 - **导出**：按当前时间范围和模型聚合方式导出 CSV
 - **时间范围**：今日、近 30 天、近 90 天、全部，或在全部可扫描历史日数据中自定义起止日期；热力图始终展示最近 53 周
-- **工作区别名**：在侧栏入口打开看板后管理，持久化保存到 $DSH_HOME/storages 的 KV 单元 `all-usage-aliases`
+- **工作区别名**：在侧栏入口打开看板后管理，持久化保存到 $DSH_HOME/storages 的 KV 单元 `all_usage_aliases`
 - **界面语言**：在看板顶部切换中文与 English；选择会保存到浏览器本地
+- **完整历史与增量重建**：基线扫描全部可读历史会话；独立用量账本同时作为每会话游标——未变化的会话直接复用账本，新增事件只增量回填，长历史重启不再全量重建
+- **Token 口径**：输入按「未含缓存命中」计，缓存命中 / 写入与推理独立成桶；全 0 用量的重放事件不会覆盖已记录的真实用量，仅缓存命中的请求也会计入
+
+### 最近更新
+
+**v1.0.7**
+
+- 增量游标：启动重扫只增量回填新增事件，未变化的会话直接从独立账本复用，不再全量重建
+- 全 0 用量防护：全 0 用量的重放事件不会覆盖已记录的真实用量；纯缓存命中的请求仍会计入
+- 结构化语义声明：API 返回机读的 token 口径（输入不含缓存命中，缓存与推理独立成桶）
+
+完整版本记录见 [CHANGELOG.md](CHANGELOG.md)。
 
 ### 截图 / Screenshots
 
@@ -26,7 +38,7 @@ DeepSeek Harness 全量用量看板：按模型、供应商、工作区和时间
 
 ### 安装
 
-本插件是标准的 DSH 社区插件包（声明 `dsh.bundle` manifest 与 Web Client），数据全部来自持久化会话日志，安装后自动回填历史。
+本插件是标准的 DSH 社区插件包（声明 `dsh.bundle` manifest 与 Web Client），数据来自持久化会话日志和独立用量账本，安装后自动回填历史。
 
 #### 官方插件命令（推荐）
 
@@ -64,9 +76,11 @@ dsh plugin --profile web add github:ParticleLight/dsh-all-usage
 
 ### 数据说明
 
-- 使用次数与 Token 全部来自 DSH 持久化会话日志，插件激活时会自动回填全部历史，插件卸载/重启后数据不丢
+- 使用次数与 Token 来自 DSH 会话日志，并在 `session/flush` 时写入独立用量账本；插件激活时会回填日志与账本历史，插件卸载/重启后已成功持久化的数据不丢
 - 按日范围统计会保留全部可读取历史会话的有使用记录日期；热力图仅作为最近 53 周的固定视图窗口
+- 会话删除后，已成功 flush 的用量仍从独立账本恢复；会话销毁提示和周期对账只负责触发重建，不会删除账本记录
 - 同一会话的同一 `turn / step` 只保留一份最终 usage；重试或替换消息会替换旧贡献，不重复累计
+- 输入 Token 按「未含缓存命中」计（缓存命中 / 写入独立成桶）；全 0 用量的重放事件不会覆盖已记录的真实用量，纯缓存命中的请求仍会计入
 - 看板中的总处理量 = 输入 + 输出 + 缓存读写 + 推理；缓存命中表示复用的上下文 Token，不等于新生成 Token 或实际费用
 - 余额查询走 DeepSeek 官方 `/user/balance` 接口；未配置 API Key 时卡片显示引导文案
 - 仅统计能归属到已注册工作区（按会话 cwd 匹配）的会话
@@ -87,12 +101,24 @@ A full usage dashboard for DeepSeek Harness. Analyze tokens, cache behavior, acc
 - **Summary and workspaces**: processed tokens, cache hits, account balance, usage streaks, workspace distribution, and details
 - **CSV export**: export data using the selected time range and aggregation mode
 - **Time ranges**: today, last 30 days, last 90 days, all time, or a custom start/end date across all available historical daily data; the heatmap always shows the latest 53 weeks
-- **Workspace aliases**: manage aliases from the sidebar dashboard; values persist in the $DSH_HOME/storages KV cell `all-usage-aliases`
+- **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
+- **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**
+
+- 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)
+
+See [CHANGELOG.md](CHANGELOG.md) for the complete version history.
 
 ### Installation
 
-This is a standard DSH community bundle. It declares a `dsh.bundle` manifest and a web client, and backfills its data from persisted session logs after installation.
+This is a standard DSH community bundle. It declares a `dsh.bundle` manifest and a web client, and backfills its data from persisted session logs and the durable usage ledger after installation.
 
 #### Official plugin command (recommended)
 
@@ -130,9 +156,11 @@ The profile patch layer hot-reloads; save the file and refresh the page.
 
 ### Data semantics
 
-- All calls and tokens come from persisted DSH session logs; historical data is backfilled when the plugin activates and survives reloads or uninstall/reinstall cycles
+- Calls and tokens come from DSH session logs and a separate usage ledger written at `session/flush`; readable logs and ledger history are backfilled when the plugin activates, so successfully persisted data survives reloads or session deletion
 - Day-level range data retains every readable historical session date with tracked usage; the heatmap is only a fixed latest-53-week view
+- After a session is deleted, successfully flushed usage is restored from the separate ledger; disposal hints and periodic reconciliation trigger rebuilds without deleting ledger rows
 - For each session and logical `turn / step`, only the final usage contribution is kept; retries or replaced messages do not double-count
+- Input tokens are fresh (exclude cache hits/writes, which sit in their own buckets); all-zero usage replays do not overwrite recorded usage and pure cache-read requests still count
 - Processed tokens = input + output + cache read/write + reasoning; a cache hit means reused context, not newly generated tokens or actual cost
 - Balance data comes from DeepSeek’s official `/user/balance` endpoint; the card shows guidance when no API key is configured
 - English mode uses UTC for date buckets, range filters, streaks, heatmap dates, and export timestamps; Chinese mode uses local time

package/lib/index.js

@@ -3,7 +3,7 @@
 import { randomBytes, timingSafeEqual } from 'node:crypto'
 
 const name = 'dsh-all-usage'
-const inject = ['sessionQuery', 'workspaceRegistry', 'timer']
+const inject = ['sessionQuery', 'workspaceRegistry', 'timer', '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.
@@ -98,9 +98,24 @@ function apply(ctx) {
   let aliasWriteChain = Promise.resolve()
   let balanceCache = { fetchedAt: 0, payload: null }
   const requestToken = randomBytes(32).toString('base64url')
+  const ledgerRecords = new Map()
+  let ledgerUnit = null
+  let ledgerReady = Promise.resolve()
+  let ledgerWriteChain = Promise.resolve()
+  const LEDGER_VERSION = 1
+  let ledgerRevision = Date.now()
   let disposed = false
   let baselineRetryDelay = 1000
   let baselineRetryScheduled = false
+  let baselineFallbackTimer = null
+  const knownSessionIds = new Set()
+  let aggregationGeneration = 0
+  let reconcileHintScheduled = false
+  let reconcilePending = false
+  let reconcileInFlight = false
+  let reconcileTimer = null
+  const RECONCILE_INTERVAL_MS = 120000
+  const RECONCILE_HINT_DELAY_MS = 3000
 
   function dayKey(ms) {
     const d = new Date(ms)
@@ -113,6 +128,45 @@ function apply(ctx) {
   function num(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : 0
   }
+  async function safeContextTimeout(ms) {
+    if (disposed) return false
+    try {
+      await ctx.timeout(ms)
+      return !disposed
+    } catch (err) {
+      if (!disposed) console.error('[all-usage] context timer unavailable:', err)
+      return false
+    }
+  }
+  function resetAggregationState() {
+    aggregationGeneration += 1
+    wsMeta.clear()
+    pathIndex.clear()
+    memberOf.clear()
+    byDay.clear()
+    byDayUtc.clear()
+    perWorkspace.clear()
+    perModel.clear()
+    usageByStep.clear()
+    sessionModel.clear()
+    sessionCount.clear()
+    sessionSeq.clear()
+    chains.clear()
+    knownSessionIds.clear()
+    totals.turns = 0
+    totals.input = 0
+    totals.output = 0
+    totals.cacheRead = 0
+    totals.cacheWrite = 0
+    totals.reasoning = 0
+    scan.started = false
+    scan.done = false
+    scan.scanned = 0
+    scan.total = 0
+    scan.failed = 0
+    baselineRetryDelay = 1000
+    return aggregationGeneration
+  }
   function ensureDay(dayMap, date) {
     let day = dayMap.get(date)
     if (day === undefined) {
@@ -205,6 +259,10 @@ function apply(ctx) {
     const values = usageValues(usage)
     const modelId = typeof model === 'string' && model !== '' ? model : '未知模型（历史记录缺少路由）'
     const eventSeq = typeof seq === 'number' ? seq : -1
+    // v1.0.7: a usage event carrying no billable token in any bucket must not add a
+    // meaningless row nor wipe previously recorded real usage (cc-switch
+    // has_billable_tokens parity). Pure cache-read requests are billable and pass.
+    if (noValues(values)) return
     const key = usageStepKey(sid, data, seq)
     const previous = usageByStep.get(key)
     // A late replay of an older raw event cannot replace the canonical later step.
@@ -236,6 +294,96 @@ function apply(ctx) {
   function modelFromMessage(data, fallback) {
     return routeLabel(data && data.message && data.message.source) || fallback
   }
+  function nextLedgerRevision() {
+    ledgerRevision = Math.max(ledgerRevision + 1, Date.now())
+    return ledgerRevision
+  }
+  function ledgerEventKey(event, index) {
+    return typeof event.seq === 'number' ? String(event.seq) : 'event:' + index
+  }
+  function buildLedgerRecord(session, workspaceId, source = 'scan') {
+    const sid = session && typeof session.id === 'string' ? session.id : ''
+    const events = session && Array.isArray(session.events) ? session.events : []
+    if (sid === '' || workspaceId === undefined) return null
+    const turns = new Map()
+    const usage = new Map()
+    let currentModel
+    for (let index = 0; index < events.length; index += 1) {
+      const event = events[index]
+      if (event === null || typeof event !== 'object') continue
+      const data = event.data
+      if (event.type === 'request/context' || event.type === 'request/header') {
+        const model = modelFromRoute(data)
+        if (model !== undefined) currentModel = model
+        continue
+      }
+      if (event.type === 'turn/end') {
+        const key = ledgerEventKey(event, index)
+        turns.set(key, { key, time: event.time, workspaceId })
+        continue
+      }
+      if (event.type !== 'assistant/message' || data === null || typeof data !== 'object' || data.usage === undefined) continue
+      const values = usageValues(data.usage)
+      // v1.0.7: all-zero usage rows carry no billable tokens and stay out of the
+      // durable ledger (cc-switch has_billable_tokens parity).
+      if (noValues(values)) continue
+      const modelId = typeof modelFromMessage(data, currentModel) === 'string' && modelFromMessage(data, currentModel) !== ''
+        ? modelFromMessage(data, currentModel) : '未知模型（历史记录缺少路由）'
+      const eventSeq = typeof event.seq === 'number' ? event.seq : -1
+      const key = usageStepKey(sid, data, event.seq)
+      const previous = usage.get(key)
+      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()) }
+  }
+  function normalizeLedgerRecord(raw, key) {
+    if (raw === null || typeof raw !== 'object' || raw.version !== LEDGER_VERSION || typeof raw.sessionId !== 'string' || raw.sessionId !== key) return null
+    if (!Array.isArray(raw.turns) || !Array.isArray(raw.usage)) return null
+    const turnMap = new Map()
+    for (const turn of raw.turns) {
+      if (turn && typeof turn.key === 'string' && turn.workspaceId !== undefined && Number.isFinite(turn.time)) turnMap.set(turn.key, { key: turn.key, time: turn.time, workspaceId: turn.workspaceId })
+    }
+    const usageMap = new Map()
+    for (const item of raw.usage) {
+      if (!item || typeof item.key !== 'string' || item.workspaceId === undefined || typeof item.modelId !== 'string' || !Number.isFinite(item.time) || item.values === null || typeof item.values !== 'object') continue
+      const normalized = { key: item.key, seq: typeof item.seq === 'number' ? item.seq : -1, time: item.time, workspaceId: item.workspaceId, modelId: item.modelId, values: usageValues({ inputTokens: item.values.input, outputTokens: item.values.output, cacheReadTokens: item.values.cacheRead, cacheWriteTokens: item.values.cacheWrite, reasoningTokens: item.values.reasoning }) }
+      const previous = usageMap.get(normalized.key)
+      if (previous === undefined || previous.seq <= normalized.seq) usageMap.set(normalized.key, normalized)
+    }
+    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()) }
+  }
+  function applyLedgerRecord(record) {
+    if (record === null || record === undefined) return
+    for (const turn of record.turns) addTurn(turn.workspaceId, turn.time, record.sessionId)
+    for (const item of record.usage) adjustUsage(item.workspaceId, item.time, item.values, item.modelId, 1, record.sessionId)
+    if (record.turns.length > 0 || record.usage.length > 0) sessionCount.add(record.sessionId)
+  }
+  function ledgerRank(record) {
+    return [typeof record.lastSeq === 'number' ? record.lastSeq : -1, record.source === 'flush' ? 1 : 0, typeof record.updatedAt === 'number' ? record.updatedAt : 0]
+  }
+  function storeLedgerRecord(record) {
+    const current = ledgerRecords.get(record.sessionId)
+    if (current !== undefined) {
+      const nextRank = ledgerRank(record)
+      const currentRank = ledgerRank(current)
+      if (nextRank[0] < currentRank[0] || (nextRank[0] === currentRank[0] && (nextRank[1] < currentRank[1] || (nextRank[1] === currentRank[1] && nextRank[2] <= currentRank[2])))) return current
+    }
+    ledgerRecords.set(record.sessionId, record)
+    return record
+  }
+  function persistLedgerRecord(record) {
+    if (ledgerUnit === null || record === null || record === undefined) return ledgerWriteChain
+    const write = ledgerWriteChain.then(async () => {
+      if (ledgerUnit !== null && ledgerRecords.get(record.sessionId) === record) await ledgerUnit.putRecord('sessions', record.sessionId, record)
+    })
+    ledgerWriteChain = write.catch((err) => {
+      console.error('[all-usage] usage ledger write failed:', err)
+    })
+    return ledgerWriteChain
+  }
   function foldEvent(wsId, time, type, data, sid, seq) {
     if (type === 'request/context' || type === 'request/header') {
       const model = modelFromRoute(data)
@@ -276,13 +424,14 @@ function apply(ctx) {
     if (wsId !== undefined) memberOf.set(sid, wsId)
     return wsId
   }
-  async function processLiveEvent(sid, wsId, event) {
-    if (disposed) return
+  async function processLiveEvent(sid, wsId, event, generation = aggregationGeneration) {
+    if (disposed || generation !== aggregationGeneration) return
     const seq = typeof event.seq === 'number' ? event.seq : -1
     const last = sessionSeq.get(sid)
     if (last === undefined) {
       try {
         const snap = await ctx.sessionQuery.readSession(sid)
+        if (disposed || generation !== aggregationGeneration) return
         if (snap && Array.isArray(snap.events)) {
           foldEvents(wsId, snap.events, undefined, sid)
           sessionSeq.set(sid, lastSeqOf(snap.events))
@@ -295,6 +444,7 @@ function apply(ctx) {
     if (seq > last + 1) {
       try {
         const snap = await ctx.sessionQuery.readSession(sid)
+        if (disposed || generation !== aggregationGeneration) return
         if (snap && Array.isArray(snap.events)) {
           foldEvents(wsId, snap.events, last, sid)
           sessionSeq.set(sid, lastSeqOf(snap.events))
@@ -307,21 +457,55 @@ function apply(ctx) {
     sessionCount.add(sid)
   }
 
+  // ---------- durable usage ledger ----------
+  async function loadLedger() {
+    if (storage === undefined || storage.backend === undefined || typeof storage.backend.get !== 'function') return
+    try {
+      const backend = storage.backend.get('json')
+      if (backend === undefined || backend === null || backend.kv === undefined) return
+      const unit = await backend.kv.open({ name: 'all_usage_ledger', version: 0, tables: ['sessions'], hasGlobal: false })
+      if (disposed) { await unit.close().catch(() => {}); return }
+      ledgerUnit = unit
+      const snapshot = await unit.loadAll()
+      const rows = snapshot && snapshot.tables && snapshot.tables.sessions
+      if (rows !== null && rows !== undefined && typeof rows === 'object') {
+        for (const [key, raw] of Object.entries(rows)) {
+          const record = normalizeLedgerRecord(raw, key)
+          if (record === null) console.warn('[all-usage] ignoring malformed usage ledger row:', key)
+          else ledgerRecords.set(key, record)
+        }
+      }
+    } catch (err) {
+      console.error('[all-usage] usage ledger unavailable:', err)
+    }
+  }
+
   // ---------- baseline scan over durable logs ----------
-  function scheduleBaselineRetry() {
-    if (disposed || baselineRetryScheduled || scan.done) return
+  function scheduleNativeBaselineRetry(generation, delay) {
+    if (disposed || baselineFallbackTimer !== null) return
+    baselineFallbackTimer = setTimeout(() => {
+      baselineFallbackTimer = null
+      if (!disposed && generation === aggregationGeneration && !scan.started && !scan.done) void runBaseline(generation)
+    }, delay)
+    if (baselineFallbackTimer && typeof baselineFallbackTimer.unref === 'function') baselineFallbackTimer.unref()
+  }
+  function scheduleBaselineRetry(generation = aggregationGeneration) {
+    if (disposed || baselineRetryScheduled || scan.done || generation !== aggregationGeneration) return
     baselineRetryScheduled = true
     const delay = baselineRetryDelay
     baselineRetryDelay = Math.min(baselineRetryDelay * 2, 30000)
-    void Promise.resolve(ctx.timeout(delay)).then(() => {
+    void safeContextTimeout(delay).then((ready) => {
       baselineRetryScheduled = false
-      if (!disposed && !scan.started && !scan.done) return runBaseline()
+      if (ready && generation === aggregationGeneration && !scan.started && !scan.done) return runBaseline(generation)
+      if (!ready && generation === aggregationGeneration && !disposed) scheduleNativeBaselineRetry(generation, delay)
       return undefined
     })
   }
-  async function runBaseline() {
-    if (scan.started || disposed) return
+  async function runBaseline(generation = aggregationGeneration) {
+    if (scan.started || disposed || generation !== aggregationGeneration) return
     scan.started = true
+    await ledgerReady
+    if (disposed || generation !== aggregationGeneration) return
     let setupFailed = false
     try {
       const workspaces = ctx.workspaceRegistry.list()
@@ -346,16 +530,27 @@ function apply(ctx) {
     } catch (err) {
       console.error('[all-usage] session list failed:', err)
     }
-    if (disposed) return
+    if (disposed || generation !== aggregationGeneration) return
     if (setupFailed || !Array.isArray(records)) {
       // A transient registry failure must not be reported as a completed empty scan.
       scan.started = false
-      scheduleBaselineRetry()
+      scheduleBaselineRetry(generation)
       return
     }
     scan.total = records.length
+    const listedSessionIds = new Set()
     for (const record of records) {
-      if (disposed) return
+      if (record === undefined || record === null || record.header === undefined) continue
+      const sid = record.header.id
+      const cwd = typeof record.header.cwd === 'string' ? record.header.cwd : ''
+      const wsId = cwd === '' ? undefined : pathIndex.get(cwd)
+      if (sid !== undefined && wsId !== undefined) listedSessionIds.add(sid)
+    }
+    for (const [sid, record] of ledgerRecords) {
+      if (!listedSessionIds.has(sid)) applyLedgerRecord(record)
+    }
+    for (const record of records) {
+      if (disposed || generation !== aggregationGeneration) return
       if (record === undefined || record === null || record.header === undefined) {
         scan.scanned += 1
         continue
@@ -367,26 +562,136 @@ function apply(ctx) {
         scan.scanned += 1
         continue
       }
+      listedSessionIds.add(sid)
       await enqueue(sid, async () => {
-        if (disposed) return
+        if (disposed || generation !== aggregationGeneration) return
         try {
           if (sessionSeq.has(sid)) return
           const snap = await ctx.sessionQuery.readSession(sid)
+          if (disposed || generation !== aggregationGeneration) return
           if (snap && Array.isArray(snap.events)) {
-            foldEvents(wsId, snap.events, undefined, sid)
-            sessionSeq.set(sid, lastSeqOf(snap.events))
+            // v1.0.7: incremental seed — the durable ledger doubles as a per-session
+            // cursor (cc-switch session_log_sync mtime+offset parity). An unchanged
+            // session applies its canonical record directly and never re-folds;
+            // a changed session seeds the previous record once, then folds only the
+            // new tail (previously every listed session was re-read and fully rebuilt).
+            const currentLastSeq = lastSeqOf(snap.events)
+            const previous = ledgerRecords.get(sid)
+            if (previous !== undefined) {
+              applyLedgerRecord(previous)
+              // Seed usageByStep so a later live retry of an already-recorded step
+              // reverses the ledger contribution instead of double-counting it.
+              for (const item of previous.usage) {
+                usageByStep.set(item.key, { seq: item.seq, wsId: item.workspaceId, time: item.time, values: item.values, modelId: item.modelId, sid })
+              }
+              if (previous.lastSeq >= currentLastSeq) {
+                sessionSeq.set(sid, previous.lastSeq)
+                sessionCount.add(sid)
+                return
+              }
+              foldEvents(wsId, snap.events, previous.lastSeq, sid)
+            } else {
+              foldEvents(wsId, snap.events, undefined, sid)
+            }
+            const ledger = buildLedgerRecord({ id: sid, header: record.header, events: snap.events }, wsId)
+            const canonical = ledger === null ? ledgerRecords.get(sid) : storeLedgerRecord(ledger)
+            if (canonical === ledger) {
+              void persistLedgerRecord(ledger)
+            } else if (canonical !== undefined) {
+              applyLedgerRecord(canonical)
+            }
+            sessionSeq.set(sid, currentLastSeq)
             sessionCount.add(sid)
           }
         } catch (err) {
-          sessionSeq.set(sid, -1)
-          scan.failed += 1
+          const saved = ledgerRecords.get(sid)
+          if (saved !== undefined) {
+            applyLedgerRecord(saved)
+            sessionSeq.set(sid, -1)
+            sessionCount.add(sid)
+          } else if (generation === aggregationGeneration) {
+            sessionSeq.set(sid, -1)
+            scan.failed += 1
+          }
         } finally {
-          scan.scanned += 1
+          if (generation === aggregationGeneration) scan.scanned += 1
         }
       })
-      await ctx.timeout(0)
+      if (!(await safeContextTimeout(0))) {
+        scan.started = false
+        scheduleBaselineRetry(generation)
+        return
+      }
     }
+    if (disposed || generation !== aggregationGeneration) return
+    await ledgerWriteChain
+    if (disposed || generation !== aggregationGeneration) return
+    knownSessionIds.clear()
+    for (const sid of listedSessionIds) knownSessionIds.add(sid)
     scan.done = true
+    if (reconcilePending) scheduleReconcileHint()
+  }
+
+  function sessionIdsFromRecords(records) {
+    const ids = new Set()
+    for (const record of records) {
+      if (record === undefined || record === null || record.header === undefined) continue
+      const sid = record.header.id
+      const cwd = typeof record.header.cwd === 'string' ? record.header.cwd : ''
+      const wsId = cwd === '' ? undefined : pathIndex.get(cwd)
+      if (sid !== undefined && wsId !== undefined) ids.add(sid)
+    }
+    return ids
+  }
+  async function reconcileSessions() {
+    if (disposed || reconcileInFlight || !scan.done) return
+    reconcilePending = false
+    reconcileInFlight = true
+    try {
+      const records = await ctx.sessionQuery.listSessions()
+      if (disposed || !Array.isArray(records)) return
+      const currentIds = sessionIdsFromRecords(records)
+      let removed = false
+      for (const sid of knownSessionIds) {
+        if (!currentIds.has(sid)) { removed = true; break }
+      }
+      if (removed && !disposed && scan.done) {
+        console.info('[all-usage] session removal detected; rebuilding usage index')
+        const generation = resetAggregationState()
+        void runBaseline(generation)
+        return
+      }
+      knownSessionIds.clear()
+      for (const sid of currentIds) knownSessionIds.add(sid)
+    } catch (err) {
+      console.error('[all-usage] session reconciliation failed:', err)
+    } finally {
+      reconcileInFlight = false
+      if (reconcilePending && !disposed) scheduleReconcileHint()
+    }
+  }
+  function scheduleReconcileHint() {
+    if (disposed) return
+    reconcilePending = true
+    if (reconcileHintScheduled || reconcileInFlight) return
+    reconcileHintScheduled = true
+    void safeContextTimeout(RECONCILE_HINT_DELAY_MS).then((ready) => {
+      reconcileHintScheduled = false
+      if (ready && !disposed) void reconcileSessions()
+    }, () => {
+      reconcileHintScheduled = false
+    })
+  }
+  function scheduleReconcileTimer() {
+    if (disposed || reconcileTimer !== null) return
+    reconcileTimer = setTimeout(() => {
+      reconcileTimer = null
+      if (!disposed) {
+        void reconcileSessions()
+        scheduleReconcileTimer()
+      }
+    }, RECONCILE_INTERVAL_MS)
+    if (reconcileTimer && typeof reconcileTimer.unref === 'function') reconcileTimer.unref()
   }
 
   // ---------- live feed ----------
@@ -399,7 +704,23 @@ function apply(ctx) {
     if (typeof sid !== 'string') return
     const wsId = wsForLiveSession(session, sid)
     if (wsId === undefined) return
-    enqueue(sid, () => processLiveEvent(sid, wsId, event))
+    const generation = aggregationGeneration
+    knownSessionIds.add(sid)
+    enqueue(sid, () => processLiveEvent(sid, wsId, event, generation))
+  })
+  ctx.on('session/flush', async (session) => {
+    if (disposed || session === null || typeof session !== 'object' || typeof session.id !== 'string') return
+    await ledgerReady
+    if (disposed) return
+    const wsId = wsForLiveSession(session, session.id)
+    if (wsId === undefined) return
+    const ledger = buildLedgerRecord(session, wsId, 'flush')
+    if (ledger === null) return
+    const canonical = storeLedgerRecord(ledger)
+    if (canonical === ledger) await persistLedgerRecord(ledger)
+  })
+  ctx.on('session/disposed', () => {
+    if (!disposed) scheduleReconcileHint()
   })
 
   // ---------- workspace aliases (durable, schema-free KV unit) ----------
@@ -408,7 +729,7 @@ function apply(ctx) {
     try {
       const backend = storage.backend.get('json')
       if (backend === undefined || backend === null || backend.kv === undefined) return
-      const unit = await backend.kv.open({ name: 'all-usage-aliases', version: 0, tables: [], hasGlobal: true })
+      const unit = await backend.kv.open({ name: 'all_usage_aliases', version: 0, tables: [], hasGlobal: true })
       kvUnit = unit
       const snap = await unit.loadAll()
       const g = snap && snap.global
@@ -442,12 +763,26 @@ function apply(ctx) {
   }
   ctx.effect(() => () => {
     disposed = true
+    if (reconcileTimer !== null) {
+      clearTimeout(reconcileTimer)
+      reconcileTimer = null
+    }
+    if (baselineFallbackTimer !== null) {
+      clearTimeout(baselineFallbackTimer)
+      baselineFallbackTimer = null
+    }
   })
   ctx.effect(() => () => {
     const unit = kvUnit
     kvUnit = null
     if (unit !== null && unit !== undefined) void unit.close().catch(() => {})
   })
+  ctx.effect(() => async () => {
+    const unit = ledgerUnit
+    await ledgerWriteChain
+    if (unit !== null && unit !== undefined) await unit.close().catch(() => {})
+    if (ledgerUnit === unit) ledgerUnit = null
+  })
 
   // ---------- snapshot for the client ----------
   function serializeDays(dayMap) {
@@ -480,6 +815,18 @@ function apply(ctx) {
         processedTotal: 'input + output + cacheRead + cacheWrite + reasoning',
         cacheRead: 'reused context tokens; not newly generated output',
         cacheWrite: 'tokens written into a provider cache',
+        // v1.0.7: structured, machine-readable accounting semantics (cc-switch
+        // input_token_semantics parity). DSH reports input as fresh (cache read /
+        // cache write sit in their own buckets) — verified against real ledger data;
+        // reasoning is bucketed separately from output and assumed non-overlapping.
+        semantics: {
+          input: 'fresh (excludes cache-read and cache-write tokens, bucketed separately)',
+          buckets: ['input', 'output', 'cacheRead', 'cacheWrite', 'reasoning'],
+          inputIncludesCache: false,
+          cacheBucketed: true,
+          reasoningSeparate: true,
+          gate: 'all-zero usage rows are ignored; pure cache-read requests still count',
+        },
       },
       totals: { turns: totals.turns, sessions: sessionCount.size, input: totals.input, output: totals.output, cacheRead: totals.cacheRead, cacheWrite: totals.cacheWrite, reasoning: totals.reasoning },
       perWorkspace: Array.from(perWorkspace, (p) => ({ workspaceId: p[0], turns: p[1].turns, input: p[1].input, output: p[1].output, cacheRead: p[1].cacheRead, cacheWrite: p[1].cacheWrite, reasoning: p[1].reasoning })),
@@ -642,7 +989,9 @@ function apply(ctx) {
   }
 
   // ---------- start the historical backfill immediately ----------
+  ledgerReady = loadLedger()
   void runBaseline()
+  scheduleReconcileTimer()
   void loadAliases()
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-all-usage",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "DeepSeek Harness usage dashboard with model, provider, workspace, cache, balance, and CSV insights",
   "repository": {
     "type": "git",
@@ -37,6 +37,7 @@
   "files": [
     "lib/index.js",
     "lib/client.js",
+    "CHANGELOG.md",
     "cordis.patch.yml",
     "assets"
   ],