dsh-all-usage 1.1.8 → 1.1.9

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(),
@@ -223,7 +227,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]

package/lib/session-sync.js

@@ -1,3 +1,4 @@
+import { RETIRED_WORKSPACE_ID, retargetLedgerRecord } from './ledger.js'
 import { contextTimeKey, extractUsageEvent, pickPricingTime, touchContextTimes, workspacePathKey } from './usage-core.js'
 
 const RECONCILE_INTERVAL_MS = 120000
@@ -445,15 +446,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')
@@ -559,31 +564,33 @@ export function createSessionSync(host) {
       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.

package/package.json

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