dsh-all-usage 1.0.5 → 1.0.6

package/README.md

@@ -15,7 +15,7 @@ DeepSeek Harness 全量用量看板：按模型、供应商、工作区和时间
 - **摘要与工作区**：Token 用量、缓存命中、账户余额、连续使用、工作区 Token 分布和明细
 - **导出**：按当前时间范围和模型聚合方式导出 CSV
 - **时间范围**：今日、近 30 天、近 90 天、全部，或在全部可扫描历史日数据中自定义起止日期；热力图始终展示最近 53 周
-- **工作区别名**：在侧栏入口打开看板后管理，持久化保存到 $DSH_HOME/storages 的 KV 单元 `all-usage-aliases`
+- **工作区别名**：在侧栏入口打开看板后管理，持久化保存到 $DSH_HOME/storages 的 KV 单元 `all_usage_aliases`
 - **界面语言**：在看板顶部切换中文与 English；选择会保存到浏览器本地
 
 ### 截图 / Screenshots
@@ -64,8 +64,9 @@ dsh plugin --profile web add github:ParticleLight/dsh-all-usage
 
 ### 数据说明
 
-- 使用次数与 Token 全部来自 DSH 持久化会话日志，插件激活时会自动回填全部历史，插件卸载/重启后数据不丢
+- 使用次数与 Token 来自 DSH 会话日志，并在 `session/flush` 时写入独立用量账本；插件激活时会回填日志与账本历史，插件卸载/重启后已成功持久化的数据不丢
 - 按日范围统计会保留全部可读取历史会话的有使用记录日期；热力图仅作为最近 53 周的固定视图窗口
+- 会话删除后，已成功 flush 的用量仍从独立账本恢复；会话销毁提示和周期对账只负责触发重建，不会删除账本记录
 - 同一会话的同一 `turn / step` 只保留一份最终 usage；重试或替换消息会替换旧贡献，不重复累计
 - 看板中的总处理量 = 输入 + 输出 + 缓存读写 + 推理；缓存命中表示复用的上下文 Token，不等于新生成 Token 或实际费用
 - 余额查询走 DeepSeek 官方 `/user/balance` 接口；未配置 API Key 时卡片显示引导文案
@@ -87,7 +88,7 @@ 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
 
 ### Installation
@@ -130,8 +131,9 @@ 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
 - 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

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) {
@@ -236,6 +290,93 @@ 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)
+      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 +417,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 +437,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 +450,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 +523,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 +555,114 @@ 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)
+            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)
+              foldEvents(wsId, snap.events, undefined, sid)
+            } else if (canonical !== undefined) {
+              applyLedgerRecord(canonical)
+            }
             sessionSeq.set(sid, lastSeqOf(snap.events))
             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 +675,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 +700,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 +734,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) {
@@ -642,7 +948,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.6",
   "description": "DeepSeek Harness usage dashboard with model, provider, workspace, cache, balance, and CSV insights",
   "repository": {
     "type": "git",