dsh-all-usage 1.1.3 → 1.1.5

package/lib/session-sync.js

@@ -1,7 +1,8 @@
-import { extractUsageEvent } from './usage-core.js'
+import { contextTimeKey, extractUsageEvent, pickPricingTime, touchContextTimes, workspacePathKey } from './usage-core.js'
 
 const RECONCILE_INTERVAL_MS = 120000
 const RECONCILE_HINT_DELAY_MS = 3000
+const WORKSPACE_SYNC_DEBOUNCE_MS = 300
 
 export function createSessionSync(host) {
   const { ctx, state } = host
@@ -25,6 +26,7 @@ export function createSessionSync(host) {
     drainLedgerWrites,
   } = host.ledger
   const backfillUnpricedCosts = (...args) => host.pricing.backfillUnpricedCosts(...args)
+  const reconcileTemporalPricing = (...args) => host.pricing.reconcileTemporalPricing(...args)
   const safeContextTimeout = async (ms) => {
     if (state.disposed) return false
     try {
@@ -38,7 +40,14 @@ export function createSessionSync(host) {
 
   function foldEvent(wsId, time, type, data, sid, seq, materialization = 'live') {
     if ((type === 'turn/end' || type === 'assistant/message' || type === 'assistant/chunk') && !validEventTime(time)) return
-    if (type === 'request/context' || type === 'request/header') {
+    if (type === 'request/context') {
+      state.sessionModel.set(sid, identityFromRoute(data, state.sessionModel.get(sid)))
+      if (validEventTime(time)) {
+        let times = state.sessionContextTimes.get(sid)
+        if (times === undefined) { times = new Map(); state.sessionContextTimes.set(sid, times) }
+        touchContextTimes(times, contextTimeKey(data && data.turn, data && data.step), time)
+      }
+    } else if (type === 'request/header') {
       state.sessionModel.set(sid, identityFromRoute(data, state.sessionModel.get(sid)))
     } else if (type === 'turn/end') {
       addTurn(wsId, time, sid, data && typeof data.turn === 'number' ? data.turn : null, state.sessionModel.get(sid), materialization, seq)
@@ -47,10 +56,15 @@ export function createSessionSync(host) {
       if (usageEvent === null) return
       const identity = usageEvent.kind === 'message' ? identityFromMessage(data, state.sessionModel.get(sid)) : coerceIdentity(state.sessionModel.get(sid))
       state.sessionModel.set(sid, identity)
-      addUsage(wsId, time, usageEvent.usage, identity, sid, data, seq, materialization)
+      const pricing = pickPricingTime(state.sessionContextTimes.get(sid), time, usageEvent.turn, usageEvent.step)
+      addUsage(wsId, time, usageEvent.usage, identity, sid, data, seq, materialization, pricing.time, pricing.source)
     }
   }
   function foldEvents(wsId, events, fromSeq, sid, materialization = 'scan') {
+    // Full folds keep their callers responsible for atomicity: runBaseline and
+    // syncLiveSession remove the session's old usage/turn/context/identity
+    // first when the snapshot is authoritative (see rebuildSession below), so
+    // usage deleted by a history rewrite disappears from the aggregate.
     for (const ev of events) {
       if (fromSeq !== undefined) {
         const s = typeof ev.seq === 'number' ? ev.seq : -1
@@ -94,13 +108,56 @@ export function createSessionSync(host) {
     state.ledgerDirtySessions.add(sid)
     state.ledgerDirtyEpochs.set(sid, (state.ledgerDirtyEpochs.get(sid) || 0) + 1)
   }
+  function buildWorkspaceSnapshot(workspaces) {
+    const wsMeta = new Map()
+    const pathIndex = new Map()
+    const memberOf = new Map()
+    for (const w of workspaces) {
+      const id = w && w.id
+      const path = w && typeof w.path === 'string' ? w.path : ''
+      const title = w && typeof w.title === 'string' ? w.title : ''
+      if (id === undefined) continue
+      wsMeta.set(id, { id, title, path })
+      if (path !== '') pathIndex.set(workspacePathKey(path), id)
+      if (w && Array.isArray(w.sessionIds)) {
+        for (const sid of w.sessionIds) memberOf.set(sid, id)
+      }
+    }
+    return { wsMeta, pathIndex, memberOf }
+  }
+  function installWorkspaceSnapshot(next) {
+    let metadataChanged = state.wsMeta.size !== next.wsMeta.size || state.pathIndex.size !== next.pathIndex.size || state.memberOf.size !== next.memberOf.size
+    if (!metadataChanged) {
+      for (const [id, value] of next.wsMeta) {
+        const previous = state.wsMeta.get(id)
+        if (previous === undefined || previous.title !== value.title || previous.path !== value.path) { metadataChanged = true; break }
+      }
+    }
+    if (!metadataChanged) {
+      for (const [path, id] of next.pathIndex) if (state.pathIndex.get(path) !== id) { metadataChanged = true; break }
+    }
+    if (!metadataChanged) {
+      for (const [sid, id] of next.memberOf) if (state.memberOf.get(sid) !== id) { metadataChanged = true; break }
+    }
+    state.wsMeta.clear()
+    state.pathIndex.clear()
+    state.memberOf.clear()
+    for (const [id, value] of next.wsMeta) state.wsMeta.set(id, value)
+    for (const [path, id] of next.pathIndex) state.pathIndex.set(path, id)
+    for (const [sid, id] of next.memberOf) state.memberOf.set(sid, id)
+    if (metadataChanged) markStatsChanged('metadata')
+    return metadataChanged
+  }
+  function workspaceForCwd(cwd) {
+    if (typeof cwd !== 'string' || cwd === '') return undefined
+    return state.pathIndex.get(workspacePathKey(cwd))
+  }
   function wsForLiveSession(session, sid) {
     let wsId = state.memberOf.get(sid)
     if (wsId !== undefined) return wsId
     const header = session && session.header
     const cwd = header && typeof header.cwd === 'string' ? header.cwd : ''
-    if (cwd === '') return undefined
-    wsId = state.pathIndex.get(cwd)
+    wsId = workspaceForCwd(cwd)
     if (wsId !== undefined) state.memberOf.set(sid, wsId)
     return wsId
   }
@@ -140,13 +197,41 @@ export function createSessionSync(host) {
       const snap = await ctx.sessionQuery.readSession(sid)
       if (state.disposed || generation !== state.aggregationGeneration) return true
       if (snap && Array.isArray(snap.events)) {
-        const previousLast = state.sessionSeq.get(sid)
-        const previousLastSafe = Number.isSafeInteger(previousLast) && previousLast >= 0 ? previousLast : -1
         const snapshotLast = lastSeqOf(snap.events)
-        foldEvents(wsId, snap.events, undefined, sid, 'live')
-        let nextLast = Math.max(previousLastSafe, snapshotLast)
+        const snapshotProfile = sequenceProfile(snap.events)
         const eventSeq = event === null || event === undefined ? -1 : (Number.isSafeInteger(event.seq) && event.seq >= 0 ? event.seq : -1)
-        const needsFollowup = event !== null && event !== undefined && (eventSeq < 0 || eventSeq > snapshotLast)
+        // The snapshot may replace the session only when it is provably
+        // complete AND it already contains the triggering event: a timer / full
+        // resync (no event), or an explicitly contained, monotonic event
+        // stream. A snapshot that merely has a higher tail than the event is
+        // NOT proof — the event could be a live append the snapshot missed (or
+        // the snapshot could have been rewritten without it), so the event is
+        // upserted and the session stays pending for a follow-up alignment.
+        // Events without a usable seq never trigger a destructive replacement.
+        const containsEvent = event !== null && event !== undefined && eventSeq >= 0 && snap.events.some((candidate) => candidate && Number.isSafeInteger(candidate.seq) && candidate.seq === eventSeq)
+        const authoritative = event === null || event === undefined ? true : eventSeq < 0 ? false : containsEvent && !snapshotProfile.nonMonotonic && !snapshotProfile.hasInvalid
+        if (authoritative) {
+          host.aggregation.removeSession(sid)
+          // The authoritative snapshot is the new truth for both the in-memory
+          // aggregate and the durable ledger: rebuild the record from scratch
+          // and persist it, so a restart after a live history rewrite cannot
+          // resurrect usage that the snapshot deleted.
+          const rebuiltRecord = buildLedgerRecord({ id: sid, events: snap.events }, wsId, 'scan', undefined, null, true)
+          if (rebuiltRecord !== null) {
+            const canonical = replaceLedgerRecord(rebuiltRecord)
+            if (canonical === rebuiltRecord) {
+              void persistLedgerRecord(rebuiltRecord).then(() => {
+                if (state.ledgerWriteFailedSessions && state.ledgerWriteFailedSessions.has(sid)) {
+                  console.error('[all-usage] authoritative resync ledger persist failed; session stays dirty:', sid)
+                  noteSyncError('resync-ledger-persist-failed')
+                }
+              })
+            }
+          }
+        }
+        foldEvents(wsId, snap.events, undefined, sid, 'live')
+        let nextLast = snapshotLast
+        const needsFollowup = !authoritative && event !== null && event !== undefined
         if (needsFollowup) {
           foldLiveFallback(sid, wsId, event)
           const current = state.sessionSeq.get(sid)
@@ -154,8 +239,14 @@ export function createSessionSync(host) {
         }
         state.sessionSeq.set(sid, nextLast)
         state.sessionCount.add(sid)
-        if (needsFollowup) scheduleLiveResync(sid, wsId, generation)
-        else cancelLiveResync(sid)
+        if (needsFollowup) {
+          // The snapshot is behind: keep the pending flag so the follow-up
+          // resync realigns the cursor once the missing history arrives.
+          scheduleLiveResync(sid, wsId, generation)
+        } else {
+          state.liveResyncPending.delete(sid)
+          cancelLiveResync(sid)
+        }
         return true
       }
     } catch (err) {
@@ -212,6 +303,81 @@ export function createSessionSync(host) {
       return undefined
     })
   }
+  function scanOneSession(sid, record, wsId, generation, snapshots) {
+    return enqueue(sid, async () => {
+      if (state.disposed || generation !== state.aggregationGeneration) return
+      try {
+        if (state.sessionSeq.has(sid) && !state.liveResyncPending.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 = state.ledgerRecords.get(sid)
+        const revision = snapshots === null ? undefined : snapshots.get(sid)
+        if (!state.liveResyncPending.has(sid) && previousRecord !== undefined && previousRecord.needsUpgrade !== true && previousRecord.rebuildRequired === undefined && previousRecord.workspaceId === wsId && typeof previousRecord.lastRevision === 'string' && typeof revision === 'string' && revision === previousRecord.lastRevision) {
+          state.sync.sessionsSkippedByRevision += 1
+          applyLedgerRecord(previousRecord, 'ledger-reuse')
+          state.sessionSeq.set(sid, previousRecord.lastSeq)
+          state.sessionCount.add(sid)
+          markStatsChanged('scan')
+          return
+        }
+        state.sync.sessionsRead += 1
+        markStatsChanged('scan')
+        const snap = await ctx.sessionQuery.readSession(sid)
+        if (state.disposed || generation !== state.aggregationGeneration) return
+        if (snap && Array.isArray(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 sequence = sequenceProfile(snap.events)
+          const currentLastSeq = sequence.lastSeq
+          const previous = state.ledgerRecords.get(sid)
+          const canFoldTail = previous !== undefined && previous.needsUpgrade !== true && previous.rebuildRequired === undefined && previous.workspaceId === wsId && !sequence.nonMonotonic && !sequence.hasInvalid && previous.lastSeq >= 0 && currentLastSeq > previous.lastSeq
+          if (canFoldTail) {
+            applyLedgerRecord(previous, 'ledger-reuse')
+            foldEvents(wsId, snap.events, previous.lastSeq, sid, 'scan')
+          } else {
+            // A changed revision with no new tail may still contain a replacement;
+            // rebuild from the complete read instead of trusting lastSeq alone.
+            foldEvents(wsId, snap.events, undefined, sid, 'scan')
+          }
+          const ledger = buildLedgerRecord({ id: sid, header: record.header, events: snap.events }, wsId, 'scan', revision, previous, !sequence.hasInvalid)
+          const canonical = ledger === null ? state.ledgerRecords.get(sid) : (canFoldTail ? storeLedgerRecord(ledger) : replaceLedgerRecord(ledger))
+          if (canonical === ledger) {
+            void persistLedgerRecord(ledger)
+          }
+          const observedLastSeq = state.sessionSeq.get(sid)
+          const nextLastSeq = Math.max(currentLastSeq, observedLastSeq === undefined ? -1 : observedLastSeq)
+          state.sessionSeq.set(sid, nextLastSeq)
+          state.sessionCount.add(sid)
+          if (observedLastSeq === undefined || observedLastSeq <= currentLastSeq) cancelLiveResync(sid)
+          else scheduleLiveResync(sid, wsId, generation)
+        }
+      } catch (err) {
+        if (generation !== state.aggregationGeneration) return
+        state.sync.sessionsFailed += 1
+        state.scan.failed += 1
+        noteSyncError('session-read-failed')
+        const saved = state.ledgerRecords.get(sid)
+        if (saved !== undefined) {
+          applyLedgerRecord(saved, 'ledger-recovery')
+          if (saved.turns.length > 0 || saved.usage.length > 0) state.sync.sessionsRestoredFromLedger += 1
+          state.sessionSeq.set(sid, -1)
+          state.sessionCount.add(sid)
+        } else {
+          state.sessionSeq.set(sid, -1)
+        }
+      } finally {
+        if (generation === state.aggregationGeneration) {
+          state.scan.scanned += 1
+          markStatsChanged('scan')
+        }
+      }
+    })
+  }
+
   async function runBaseline(generation = state.aggregationGeneration) {
     if (state.scan.started || state.disposed || generation !== state.aggregationGeneration) return
     state.scan.started = true
@@ -221,40 +387,7 @@ export function createSessionSync(host) {
     let setupFailed = false
     try {
       const workspaces = ctx.workspaceRegistry.list()
-      const nextWsMeta = new Map()
-      const nextPathIndex = new Map()
-      const nextMemberOf = new Map()
-      for (const w of workspaces) {
-        const id = w && w.id
-        const path = w && typeof w.path === 'string' ? w.path : ''
-        const title = w && typeof w.title === 'string' ? w.title : ''
-        if (id === undefined) continue
-        nextWsMeta.set(id, { id, title, path })
-        if (path !== '') nextPathIndex.set(path, id)
-        if (w && Array.isArray(w.sessionIds)) {
-          for (const sid of w.sessionIds) nextMemberOf.set(sid, id)
-        }
-      }
-      let metadataChanged = state.wsMeta.size !== nextWsMeta.size || state.pathIndex.size !== nextPathIndex.size || state.memberOf.size !== nextMemberOf.size
-      if (!metadataChanged) {
-        for (const [id, value] of nextWsMeta) {
-          const previous = state.wsMeta.get(id)
-          if (previous === undefined || previous.title !== value.title || previous.path !== value.path) { metadataChanged = true; break }
-        }
-      }
-      if (!metadataChanged) {
-        for (const [path, id] of nextPathIndex) if (state.pathIndex.get(path) !== id) { metadataChanged = true; break }
-      }
-      if (!metadataChanged) {
-        for (const [sid, id] of nextMemberOf) if (state.memberOf.get(sid) !== id) { metadataChanged = true; break }
-      }
-      state.wsMeta.clear()
-      state.pathIndex.clear()
-      state.memberOf.clear()
-      for (const [id, value] of nextWsMeta) state.wsMeta.set(id, value)
-      for (const [path, id] of nextPathIndex) state.pathIndex.set(path, id)
-      for (const [sid, id] of nextMemberOf) state.memberOf.set(sid, id)
-      if (metadataChanged) markStatsChanged('metadata')
+      installWorkspaceSnapshot(buildWorkspaceSnapshot(workspaces))
     } catch (err) {
       console.error('[all-usage] workspace list failed:', err)
       setupFailed = true
@@ -306,11 +439,18 @@ export function createSessionSync(host) {
       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 : state.pathIndex.get(cwd)
+      const wsId = workspaceForCwd(cwd)
       if (sid !== undefined && wsId !== undefined) listedSessionIds.add(sid)
     }
     for (const [sid, record] of state.ledgerRecords) {
       if (!listedSessionIds.has(sid)) {
+        // A ledger row from a deleted cwd is stale historical data, not an
+        // active workspace. Registered records remain recoverable; unknown
+        // records are recovered only while their source cwd still exists. Old
+        // synthetic rows predate sourceCwd persistence and cannot be validated,
+        // so they are fail-closed rather than resurrected after a restart.
+        if (record.sourceCwd !== undefined && workspaceForCwd(record.sourceCwd) === undefined) continue
+        if (typeof record.workspaceId === 'string' && record.workspaceId.startsWith('unregistered:')) continue
         applyLedgerRecord(record, 'ledger-recovery')
         if (record.turns.length > 0 || record.usage.length > 0) state.sync.sessionsRestoredFromLedger += 1
       }
@@ -325,85 +465,14 @@ export function createSessionSync(host) {
       }
       const sid = record.header.id
       const cwd = typeof record.header.cwd === 'string' ? record.header.cwd : ''
-      const wsId = cwd === '' ? undefined : state.pathIndex.get(cwd)
+      const wsId = workspaceForCwd(cwd)
       if (sid === undefined || wsId === undefined) {
         state.scan.scanned += 1
         markStatsChanged('scan')
         continue
       }
       listedSessionIds.add(sid)
-      await enqueue(sid, async () => {
-        if (state.disposed || generation !== state.aggregationGeneration) return
-        try {
-          if (state.sessionSeq.has(sid) && !state.liveResyncPending.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 = state.ledgerRecords.get(sid)
-          const revision = snapshots === null ? undefined : snapshots.get(sid)
-          if (!state.liveResyncPending.has(sid) && previousRecord !== undefined && previousRecord.needsUpgrade !== true && previousRecord.rebuildRequired === undefined && previousRecord.workspaceId === wsId && typeof previousRecord.lastRevision === 'string' && typeof revision === 'string' && revision === previousRecord.lastRevision) {
-            state.sync.sessionsSkippedByRevision += 1
-            applyLedgerRecord(previousRecord, 'ledger-reuse')
-            state.sessionSeq.set(sid, previousRecord.lastSeq)
-            state.sessionCount.add(sid)
-            markStatsChanged('scan')
-            return
-          }
-          state.sync.sessionsRead += 1
-          markStatsChanged('scan')
-          const snap = await ctx.sessionQuery.readSession(sid)
-          if (state.disposed || generation !== state.aggregationGeneration) return
-          if (snap && Array.isArray(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 sequence = sequenceProfile(snap.events)
-            const currentLastSeq = sequence.lastSeq
-            const previous = state.ledgerRecords.get(sid)
-            const canFoldTail = previous !== undefined && previous.needsUpgrade !== true && previous.rebuildRequired === undefined && previous.workspaceId === wsId && !sequence.nonMonotonic && !sequence.hasInvalid && previous.lastSeq >= 0 && currentLastSeq > previous.lastSeq
-            if (canFoldTail) {
-              applyLedgerRecord(previous, 'ledger-reuse')
-              foldEvents(wsId, snap.events, previous.lastSeq, sid, 'scan')
-            } else {
-              // A changed revision with no new tail may still contain a replacement;
-              // rebuild from the complete read instead of trusting lastSeq alone.
-              foldEvents(wsId, snap.events, undefined, sid, 'scan')
-            }
-            const ledger = buildLedgerRecord({ id: sid, header: record.header, events: snap.events }, wsId, 'scan', revision, previous, !sequence.hasInvalid)
-            const canonical = ledger === null ? state.ledgerRecords.get(sid) : (canFoldTail ? storeLedgerRecord(ledger) : replaceLedgerRecord(ledger))
-            if (canonical === ledger) {
-              void persistLedgerRecord(ledger)
-            }
-            const observedLastSeq = state.sessionSeq.get(sid)
-            const nextLastSeq = Math.max(currentLastSeq, observedLastSeq === undefined ? -1 : observedLastSeq)
-            state.sessionSeq.set(sid, nextLastSeq)
-            state.sessionCount.add(sid)
-            if (observedLastSeq === undefined || observedLastSeq <= currentLastSeq) cancelLiveResync(sid)
-            else scheduleLiveResync(sid, wsId, generation)
-          }
-        } catch (err) {
-          if (generation !== state.aggregationGeneration) return
-          state.sync.sessionsFailed += 1
-          state.scan.failed += 1
-          noteSyncError('session-read-failed')
-          const saved = state.ledgerRecords.get(sid)
-          if (saved !== undefined) {
-            applyLedgerRecord(saved, 'ledger-recovery')
-            if (saved.turns.length > 0 || saved.usage.length > 0) state.sync.sessionsRestoredFromLedger += 1
-            state.sessionSeq.set(sid, -1)
-            state.sessionCount.add(sid)
-          } else {
-            state.sessionSeq.set(sid, -1)
-          }
-        } finally {
-          if (generation === state.aggregationGeneration) {
-            state.scan.scanned += 1
-            markStatsChanged('scan')
-          }
-        }
-      })
+      await scanOneSession(sid, record, wsId, generation, snapshots)
       if (!(await safeContextTimeout(0))) {
         state.scan.started = false
         noteSyncError('baseline-yield-unavailable')
@@ -420,6 +489,12 @@ export function createSessionSync(host) {
       markStatsChanged('pricing')
     }
     if (state.disposed || generation !== state.aggregationGeneration) return
+    const temporalReconcile = reconcileTemporalPricing()
+    if (temporalReconcile.reconciled > 0) {
+      await drainLedgerWrites()
+      markStatsChanged('pricing')
+    }
+    if (state.disposed || generation !== state.aggregationGeneration) return
     state.knownSessionIds.clear()
     for (const sid of listedSessionIds) state.knownSessionIds.add(sid)
     state.scan.done = true
@@ -432,13 +507,132 @@ export function createSessionSync(host) {
     if (state.reconcilePending) scheduleReconcileHint()
   }
 
+  function scheduleWorkspaceSync() {
+    if (state.disposed) return
+    if (state.workspaceSyncTimer !== null) return
+    state.workspaceSyncTimer = setTimeout(() => {
+      state.workspaceSyncTimer = null
+      if (!state.disposed) void runWorkspaceSync()
+    }, WORKSPACE_SYNC_DEBOUNCE_MS)
+    if (state.workspaceSyncTimer && typeof state.workspaceSyncTimer.unref === 'function') state.workspaceSyncTimer.unref()
+  }
+  async function runWorkspaceSync() {
+    if (state.disposed) return
+    if (state.workspaceSyncInFlight) {
+      state.workspaceSyncPending = true
+      return
+    }
+    state.workspaceSyncInFlight = true
+    try {
+      await synchronizeWorkspaceRegistry()
+    } catch (err) {
+      console.error('[all-usage] workspace synchronize failed:', err)
+      noteSyncError('workspace-sync-failed')
+    } finally {
+      state.workspaceSyncInFlight = false
+      if (state.workspaceSyncPending) {
+        state.workspaceSyncPending = false
+        scheduleWorkspaceSync()
+      }
+    }
+  }
+  async function synchronizeWorkspaceRegistry() {
+    // The first baseline reads the registry with the latest list, so a probe
+    // arriving before it completes has nothing to add.
+    if (state.disposed || !state.scan.done) return
+    let workspaces
+    try {
+      workspaces = ctx.workspaceRegistry.list()
+    } catch (err) {
+      console.error('[all-usage] workspace list failed:', err)
+      noteSyncError('workspace-list-failed')
+      return
+    }
+    const next = buildWorkspaceSnapshot(workspaces)
+    const removedWs = new Set()
+    for (const id of state.wsMeta.keys()) if (!next.wsMeta.has(id)) removedWs.add(id)
+    const addedWs = new Set()
+    for (const id of next.wsMeta.keys()) if (!state.wsMeta.has(id)) addedWs.add(id)
+    // Reuse path: no membership change — metadata only, zero rescan.
+    if (removedWs.size === 0 && addedWs.size === 0) {
+      installWorkspaceSnapshot(next)
+      return
+    }
+    // Remove path: subtract every session that belonged to a deregistered workspace.
+    if (removedWs.size > 0) {
+      const removedSids = new Set()
+      for (const [sid, record] of state.ledgerRecords) {
+        if (record !== null && record !== undefined && typeof record.workspaceId === 'string' && removedWs.has(record.workspaceId)) removedSids.add(sid)
+      }
+      for (const [sid, id] of state.memberOf) if (removedWs.has(id)) removedSids.add(sid)
+      for (const sid of removedSids) {
+        if (typeof sid !== 'string' || sid === '') continue
+        host.aggregation.removeSession(sid)
+        state.ledgerRecords.delete(sid)
+        state.knownSessionIds.delete(sid)
+        state.sessionCount.delete(sid)
+        state.sessionSeq.delete(sid)
+        state.sessionModel.delete(sid)
+        state.sessionContextTimes.delete(sid)
+        state.memberOf.delete(sid)
+        state.liveResyncPending.delete(sid)
+        cancelLiveResync(sid)
+      }
+      for (const id of removedWs) {
+        state.perWorkspace.delete(id)
+        for (const day of state.byDay.values()) day.byWs.delete(id)
+        for (const day of state.byDayUtc.values()) day.byWs.delete(id)
+      }
+    }
+    installWorkspaceSnapshot(next)
+    // Add path: scan only the sessions that belong to newly registered workspaces.
+    if (addedWs.size === 0) return
+    let records = null
+    try {
+      records = await ctx.sessionQuery.listSessions()
+    } catch (err) {
+      console.error('[all-usage] session list failed:', err)
+      noteSyncError('session-list-failed')
+    }
+    if (!Array.isArray(records)) return
+    state.sync.sessionsTotal = records.length
+    markStatsChanged('scan')
+    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)
+        markStatsChanged('scan')
+      }
+    }
+    for (const record of records) {
+      if (state.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 = workspaceForCwd(cwd)
+      if (sid === undefined || wsId === undefined) continue
+      if (!addedWs.has(wsId)) continue
+      state.knownSessionIds.add(sid)
+      scanOneSession(sid, record, wsId, state.aggregationGeneration, snapshots)
+    }
+  }
+
   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 : state.pathIndex.get(cwd)
+      const wsId = workspaceForCwd(cwd)
       if (sid !== undefined && wsId !== undefined) ids.add(sid)
     }
     return ids
@@ -563,6 +757,18 @@ export function createSessionSync(host) {
   ctx.on('session/disposed', () => {
     if (!state.disposed) scheduleReconcileHint()
   })
+  // Workspace registry probe: DSH emits domain/changed after every durable
+  // workspace-domain write (create/delete/rename/reorder/archive/attach/detach).
+  // On any such change we re-read workspaceRegistry.list() and, when membership
+  // changed, rescan only the affected workspaces — unchanged ones keep their
+  // computed aggregates and ledger untouched.
+  ctx.on('domain/changed', (change) => {
+    if (state.disposed) return
+    if (change === undefined || change === null) return
+    if (change.domain !== 'workspace') return
+    if (change.table !== 'workspaces' && change.table !== '') return
+    scheduleWorkspaceSync()
+  })
 
   return {
     foldEvent,
@@ -580,6 +786,8 @@ export function createSessionSync(host) {
     scheduleNativeBaselineRetry,
     scheduleBaselineRetry,
     runBaseline,
+    synchronizeWorkspaceRegistry,
+    scheduleWorkspaceSync,
     sessionIdsFromRecords,
     reconcileSessions,
     scheduleReconcileHint,

package/lib/usage-core.js

@@ -1,3 +1,10 @@
+/** Canonical comparison key for Windows workspace paths. */
+export function workspacePathKey(value) {
+  if (typeof value !== 'string') return ''
+  const normalized = value.trim().replaceAll('\\', '/').toLowerCase()
+  return normalized.length > 3 ? normalized.replace(/\/+$/, '') : normalized
+}
+
 const TOKEN_FIELDS = Object.freeze({
   input: 'inputTokens',
   output: 'outputTokens',
@@ -107,6 +114,50 @@ export function usageStepKey(sid, data, seq, fallback) {
   return safeSid + ':event:' + (serialized === undefined ? String(fallback === undefined ? '' : fallback) : serialized)
 }
 
+/** Recalculate the billing instant for a re-priced sample, preferring the recorded request time. */
+export function billingInstantOf(item, oldCost) {
+  const oldAt = oldCost != null && Number.isFinite(oldCost.pricingAt) ? oldCost.pricingAt : null
+  const at = Number.isFinite(item.pricingAt) ? item.pricingAt : oldAt !== null ? oldAt : validEventTime(item.time) ? item.time : null
+  const oldSource = oldCost != null && (oldCost.pricingTimeSource === 'request-context' || oldCost.pricingTimeSource === 'usage-event') ? oldCost.pricingTimeSource : null
+  const source = typeof item.pricingTimeSource === 'string' && (item.pricingTimeSource === 'request-context' || item.pricingTimeSource === 'usage-event') ? item.pricingTimeSource : (oldSource || 'usage-event')
+  return { at, source }
+}
+
+/** Bounded context archive shared by the live fold and the persisted ledger. */
+export const MAX_CONTEXT_TIMES = 512
+
+/** Insert-or-refresh a context entry with real LRU eviction (delete + set). */
+export function touchContextTimes(times, key, time) {
+  if (typeof key !== 'string' || key === '') return
+  if (times.has(key)) times.delete(key)
+  times.set(key, time)
+  while (times.size > MAX_CONTEXT_TIMES) times.delete(times.keys().next().value)
+}
+
+/** Stable per-(turn, step) key for the pricing-time context of a request. */
+export function contextTimeKey(turn, step) {
+  const safeTurn = Number.isSafeInteger(turn) && turn >= 0 ? turn : null
+  const safeStep = Number.isSafeInteger(step) && step >= 0 ? step : null
+  if (safeTurn !== null && safeStep !== null) return 'context:' + safeTurn + ':' + safeStep
+  return 'context:__latest__'
+}
+
+/**
+ * Pick the billing instant for a usage event: the request/context time that
+ * matches the same turn/step wins (parallel requests stay per-step), otherwise
+ * the usage event time itself is the auditable fallback.
+ */
+export function pickPricingTime(contextTimes, eventTime, turn, step) {
+  if (contextTimes instanceof Map && validEventTime(eventTime)) {
+    const exact = contextTimes.get(contextTimeKey(turn, step))
+    const candidate = exact !== undefined ? exact : contextTimes.get(contextTimeKey(null, null))
+    if (Number.isFinite(candidate) && candidate <= eventTime) {
+      return { time: candidate, source: 'request-context' }
+    }
+  }
+  return { time: Number.isFinite(eventTime) && eventTime >= 0 ? eventTime : null, source: 'usage-event' }
+}
+
 /** Replace one logical sample; stale lower-seq replays are ignored. */
 /** Event sequence contract: -1 (missing) or a non-negative safe integer. */
 export function normalizeEventSeq(value) {

package/package.json

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