dsh-all-usage 1.1.8 → 1.1.10

package/lib/ledger.js

@@ -1,6 +1,24 @@
 import { calculateCost, normalizeCostSnapshot } from './pricing.js'
 import { billingInstantOf, contextTimeKey, extractUsageEvent, normalizeUsageValues as usageValues, pickPricingTime, touchContextTimes, upsertUsageSample as upsertUsageSampleState, usageStepKey } from './usage-core.js'
 
+// Usage recorded for workspaces that left the registry is summed into one
+// bucket. The ledger's promise is that flushed usage survives deletion, and a
+// row per dead workspace would grow the dashboard without adding information.
+const RETIRED_WORKSPACE_ID = 'retired:deleted'
+
+// Re-attribute a record (and its turns/usage items) to another workspace id.
+// Only the in-memory copy is retargeted: the persisted row keeps its original
+// workspace id and cwd, so the mapping stays reversible.
+function retargetLedgerRecord(record, workspaceId = RETIRED_WORKSPACE_ID) {
+  if (record === null || record === undefined) return record
+  return {
+    ...record,
+    workspaceId,
+    turns: Array.isArray(record.turns) ? record.turns.map((turn) => ({ ...turn, workspaceId })) : record.turns,
+    usage: Array.isArray(record.usage) ? record.usage.map((item) => ({ ...item, workspaceId })) : record.usage,
+  }
+}
+
 const LEDGER_VERSION = 3
 const PREVIOUS_LEDGER_VERSION = 2
 const LEGACY_LEDGER_VERSION = 1
@@ -495,6 +513,7 @@ export function createLedger(host) {
     nextLedgerRevision,
     ledgerEventKey,
     sessionEvents,
+    retargetLedgerRecord,
     buildLedgerRecord,
     normalizeLedgerRecord,
     prepareLedgerRecord,
@@ -509,4 +528,4 @@ export function createLedger(host) {
   }
 }
 
-export { LEDGER_VERSION, PREVIOUS_LEDGER_VERSION, LEGACY_LEDGER_VERSION, LEDGER_SHARD_COUNT, ledgerShardIndex }
+export { LEDGER_VERSION, PREVIOUS_LEDGER_VERSION, LEGACY_LEDGER_VERSION, LEDGER_SHARD_COUNT, RETIRED_WORKSPACE_ID, ledgerShardIndex, retargetLedgerRecord }

package/lib/plugin.js

@@ -2,7 +2,7 @@ import { randomBytes } from 'node:crypto'
 import { createAggregation } from './aggregation.js'
 import { createBalance } from './balance.js'
 import { registerRoutes } from './http.js'
-import { createLedger } from './ledger.js'
+import { RETIRED_WORKSPACE_ID, createLedger } from './ledger.js'
 import { createPricingRuntime } from './pricing-runtime.js'
 import { createSessionSync } from './session-sync.js'
 import { createCostAccumulator, createEmptyPricingState } from './pricing.js'
@@ -20,6 +20,10 @@ function apply(ctx) {
   }
   const state = {
     wsMeta: new Map(),
+    // True once recorded usage from a vanished workspace was moved into the
+    // shared "deleted" bucket; the bucket row is only advertised when it holds
+    // something.
+    retiredBucketUsed: false,
     pathIndex: new Map(),
     memberOf: new Map(),
     byDay: new Map(),
@@ -66,6 +70,14 @@ function apply(ctx) {
       sessionsSkippedByRevision: 0,
       sessionsRestoredFromLedger: 0,
       sessionsFailed: 0,
+      // Cumulative registry-probe diagnostics. They deliberately survive a
+      // baseline reset so the status endpoint can show whether the
+      // `domain/changed` fast path fires at all on this host.
+      workspaceProbeEvents: 0,
+      workspaceSyncRuns: 0,
+      workspaceSyncAdded: 0,
+      workspaceSyncRemoved: 0,
+      workspaceSyncDeferred: 0,
     },
     ledgerRecords: new Map(),
     queryCache: new Map(),
@@ -101,6 +113,8 @@ function apply(ctx) {
     reconcileInFlight: false,
     reconcileTimer: null,
     workspaceSyncTimer: null,
+    workspaceSyncDeferred: false,
+    workspaceProbeTimer: null,
     workspaceSyncInFlight: false,
     workspaceSyncPending: false,
   }
@@ -168,6 +182,11 @@ function apply(ctx) {
       sessionsSkippedByRevision: state.sync.sessionsSkippedByRevision,
       sessionsRestoredFromLedger: state.sync.sessionsRestoredFromLedger,
       sessionsFailed: state.sync.sessionsFailed,
+      workspaceProbeEvents: state.sync.workspaceProbeEvents,
+      workspaceSyncRuns: state.sync.workspaceSyncRuns,
+      workspaceSyncAdded: state.sync.workspaceSyncAdded,
+      workspaceSyncRemoved: state.sync.workspaceSyncRemoved,
+      workspaceSyncDeferred: state.sync.workspaceSyncDeferred,
     }
   }
   Object.assign(host, { commitPendingStats, markStatsChanged, resetSyncState, beginSync, noteSyncError, syncSnapshot })
@@ -223,7 +242,7 @@ function apply(ctx) {
     if (typeof wsId !== 'string' || wsId.length === 0 || wsId.length > 256) return { ok: false, message: 'invalid-workspace', aliases: Object.assign({}, state.aliases) }
     if (typeof raw !== 'string') return { ok: false, message: 'invalid-alias', aliases: Object.assign({}, state.aliases) }
     const alias = raw.trim().slice(0, 80)
-    if (!state.wsMeta.has(wsId)) return { ok: false, message: 'unknown-workspace', aliases: Object.assign({}, state.aliases) }
+    if (!state.wsMeta.has(wsId) && !(state.retiredBucketUsed && wsId === RETIRED_WORKSPACE_ID)) return { ok: false, message: 'unknown-workspace', aliases: Object.assign({}, state.aliases) }
     const previous = typeof state.aliases[wsId] === 'string' ? state.aliases[wsId] : ''
     if (alias === previous) return { ok: true, aliases: Object.assign({}, state.aliases) }
     if (alias === '') delete state.aliases[wsId]
@@ -273,6 +292,7 @@ function apply(ctx) {
   state.pricingReady = host.pricing.loadPricing().then(() => { host.pricing.schedulePricingSync() })
   void host.sessionSync.runBaseline()
   host.sessionSync.scheduleReconcileTimer()
+  host.sessionSync.scheduleWorkspaceProbeTimer()
   state.aliasesReady = loadAliases()
 }
 

package/lib/session-sync.js

@@ -1,8 +1,13 @@
+import { RETIRED_WORKSPACE_ID, retargetLedgerRecord } from './ledger.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
+// The registry event is a fast path, not a guarantee: a change that lands while a
+// baseline runs used to be dropped outright, and a missed event left the plugin
+// stale until the next restart. The (in-memory) registry list is polled as well.
+const WORKSPACE_PROBE_INTERVAL_MS = 30000
 
 export function createSessionSync(host) {
   const { ctx, state } = host
@@ -153,6 +158,25 @@ export function createSessionSync(host) {
     if (typeof cwd !== 'string' || cwd === '') return undefined
     return state.pathIndex.get(workspacePathKey(cwd))
   }
+  // DSH 0.1.5 replaced \`sessionPersistence.listSnapshots()\` with \`list()\`; both
+  // return per-session \`{ header, revision }\` rows. Without a revision the
+  // ledger-reuse fast path never fires, so every baseline re-reads every log.
+  async function loadSessionRevisions() {
+    const source = sessionPersistence
+    if (source === undefined || source === null) return null
+    const read = typeof source.list === 'function'
+      ? () => source.list()
+      : (typeof source.listSnapshots === 'function' ? () => source.listSnapshots() : null)
+    if (read === null) return null
+    const rows = await read()
+    if (!Array.isArray(rows)) return null
+    const revisions = 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') revisions.set(rid, row.revision)
+    }
+    return revisions
+  }
   function wsForLiveSession(session, sid) {
     let wsId = state.memberOf.get(sid)
     if (wsId !== undefined) return wsId
@@ -405,24 +429,18 @@ export function createSessionSync(host) {
     if (state.disposed || generation !== state.aggregationGeneration) return
     // v1.0.8: cheap per-session change signal (header line + stat, no full-log read)
     let snapshots = null
-    if (sessionPersistence !== undefined && typeof sessionPersistence.listSnapshots === 'function') {
-      try {
-        const rows = await sessionPersistence.listSnapshots()
-        if (state.disposed || generation !== state.aggregationGeneration) return
-        if (Array.isArray(rows)) {
-          state.sync.persistenceSnapshotsAvailable = true
-          snapshots = new Map()
-          for (const row of rows) {
-            const rid = row && row.header && typeof row.header.id === 'string' ? row.header.id : undefined
-            if (rid !== undefined && row && typeof row.revision === 'string') snapshots.set(rid, row.revision)
-          }
-        }
-      } catch (err) {
-        console.error('[all-usage] session persistence snapshots unavailable:', err)
-        if (state.disposed || generation !== state.aggregationGeneration) return
-        state.sync.persistenceSnapshotsAvailable = false
-        markStatsChanged('scan')
+    try {
+      const revisions = await loadSessionRevisions()
+      if (state.disposed || generation !== state.aggregationGeneration) return
+      if (revisions !== null) {
+        state.sync.persistenceSnapshotsAvailable = true
+        snapshots = revisions
       }
+    } catch (err) {
+      console.error('[all-usage] session persistence snapshots unavailable:', err)
+      if (state.disposed || generation !== state.aggregationGeneration) return
+      state.sync.persistenceSnapshotsAvailable = false
+      markStatsChanged('scan')
     }
     if (state.disposed || generation !== state.aggregationGeneration) return
     if (setupFailed || !Array.isArray(records)) {
@@ -445,15 +463,19 @@ export function createSessionSync(host) {
     }
     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
+        // Recorded usage survives deletion. A session whose workspace, cwd or
+        // log is gone still counts from its ledger row; only legacy synthetic
+        // rows, which never belonged to a registered workspace, stay excluded.
         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
+        // Usage from a workspace that is no longer registered is summed into the
+        // shared deleted bucket, so history survives without a row per dead
+        // workspace. The stored row keeps its original workspace id and cwd.
+        const retired = typeof record.workspaceId !== 'string' || !state.wsMeta.has(record.workspaceId)
+        const carriesUsage = record.turns.length > 0 || record.usage.length > 0
+        // An empty row must not advertise a bucket that holds nothing.
+        if (retired && carriesUsage) state.retiredBucketUsed = true
+        applyLedgerRecord(retired ? retargetLedgerRecord(record) : record, retired ? 'ledger-retired' : 'ledger-recovery')
+        if (carriesUsage) state.sync.sessionsRestoredFromLedger += 1
       }
     }
     if (state.sync.sessionsRestoredFromLedger > 0) markStatsChanged('scan')
@@ -499,6 +521,10 @@ export function createSessionSync(host) {
     state.knownSessionIds.clear()
     for (const sid of listedSessionIds) state.knownSessionIds.add(sid)
     state.scan.done = true
+    if (state.workspaceSyncDeferred) {
+      state.workspaceSyncDeferred = false
+      scheduleWorkspaceSync()
+    }
     state.sync.lastCompletedAt = Date.now()
     if (state.sync.sessionsFailed === 0) {
       state.sync.lastErrorAt = 0
@@ -524,6 +550,7 @@ export function createSessionSync(host) {
       return
     }
     state.workspaceSyncInFlight = true
+    state.sync.workspaceSyncRuns += 1
     try {
       await synchronizeWorkspaceRegistry()
     } catch (err) {
@@ -538,9 +565,15 @@ export function createSessionSync(host) {
     }
   }
   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
+    if (state.disposed) return
+    // A registry change that lands while a baseline is running used to be
+    // dropped outright, which is why a new workspace could stay invisible until
+    // the next restart. Remember it and re-run once the scan settles.
+    if (!state.scan.done) {
+      state.workspaceSyncDeferred = true
+      state.sync.workspaceSyncDeferred += 1
+      return
+    }
     let workspaces
     try {
       workspaces = ctx.workspaceRegistry.list()
@@ -554,36 +587,40 @@ export function createSessionSync(host) {
     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)
+    state.sync.workspaceSyncAdded += addedWs.size
+    state.sync.workspaceSyncRemoved += removedWs.size
     // 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.
+    // Retire path: a deregistered workspace keeps everything it recorded. The
+    // ledger's promise is that flushed usage survives deletion, so sessions are
+    // re-applied under the shared deleted bucket instead of being subtracted and
+    // dropped. New sessions still cannot enter the workspace: pathIndex only
+    // ever carries registered workspaces, so workspaceForCwd() no longer
+    // resolves its cwd and the scan skips it.
     if (removedWs.size > 0) {
-      const removedSids = new Set()
+      const retiredSids = 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)
+        if (record === null || record === undefined || !removedWs.has(record.workspaceId)) continue
+        retiredSids.add(sid)
       }
-      for (const [sid, id] of state.memberOf) if (removedWs.has(id)) removedSids.add(sid)
-      for (const sid of removedSids) {
+      for (const [sid, id] of state.memberOf) if (removedWs.has(id)) retiredSids.add(sid)
+      let moved = 0
+      for (const sid of retiredSids) {
         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)
+        // Re-key the live aggregate first: usage folded from the feed but not yet
+        // persisted has no ledger row to replay, and a session the registry no
+        // longer lists is never re-scanned afterwards.
+        moved += host.aggregation.retargetSession(sid, RETIRED_WORKSPACE_ID)
+        const record = state.ledgerRecords.get(sid)
+        // Keep the in-memory record aligned with the aggregate; the persisted row
+        // keeps its original workspace id and cwd, so recovery re-derives this.
+        if (record !== undefined && (record.turns.length > 0 || record.usage.length > 0)) moved += 1
+        if (record !== undefined) state.ledgerRecords.set(sid, retargetLedgerRecord(record))
       }
+      if (moved > 0) state.retiredBucketUsed = true
     }
     installWorkspaceSnapshot(next)
     // Add path: scan only the sessions that belong to newly registered workspaces.
@@ -599,20 +636,10 @@ export function createSessionSync(host) {
     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')
-      }
+    try {
+      snapshots = await loadSessionRevisions()
+    } catch (err) {
+      console.error('[all-usage] session persistence snapshots unavailable:', err)
     }
     for (const record of records) {
       if (state.disposed) return
@@ -691,6 +718,20 @@ export function createSessionSync(host) {
     }, RECONCILE_INTERVAL_MS)
     if (state.reconcileTimer && typeof state.reconcileTimer.unref === 'function') state.reconcileTimer.unref()
   }
+  // Belt and braces for the registry probe: the event fast path can be missed
+  // (dropped while scanning, or never delivered), and unlike the event this
+  // cannot silently leave the workspace list stale until a restart.
+  function scheduleWorkspaceProbeTimer() {
+    if (state.disposed || state.workspaceProbeTimer !== null) return
+    state.workspaceProbeTimer = setTimeout(() => {
+      state.workspaceProbeTimer = null
+      if (!state.disposed) {
+        void runWorkspaceSync()
+        scheduleWorkspaceProbeTimer()
+      }
+    }, WORKSPACE_PROBE_INTERVAL_MS)
+    if (state.workspaceProbeTimer && typeof state.workspaceProbeTimer.unref === 'function') state.workspaceProbeTimer.unref()
+  }
 
   // ---------- live feed ----------
   ctx.on('session/event', (session, event) => {
@@ -768,6 +809,7 @@ export function createSessionSync(host) {
     if (change === undefined || change === null) return
     if (change.domain !== 'workspace') return
     if (change.table !== 'workspaces' && change.table !== '') return
+    state.sync.workspaceProbeEvents += 1
     scheduleWorkspaceSync()
   })
 
@@ -793,6 +835,7 @@ export function createSessionSync(host) {
     reconcileSessions,
     scheduleReconcileHint,
     scheduleReconcileTimer,
+    scheduleWorkspaceProbeTimer,
     markLedgerDirty
   }
 }

package/package.json

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