dsh-all-usage 1.1.3 → 1.1.4

package/lib/http.js

@@ -220,7 +220,7 @@ export function registerRoutes(host) {
         // before mutating it: an early POST would otherwise be skipped because
         // pricingUnit is still null and then overwritten by the loaded state.
         await Promise.all([state.pricingReady, state.ledgerReady])
-        const result = updatePricingState(args.pricing || args, args.backfill === true)
+        const result = updatePricingState(args.pricing || args, args.backfill === true, args.repriceTemporal === true)
         await persistPricing()
         await drainLedgerWrites()
         sendJson(res, 200, { ok: true, backfill: result, pricing: pricingSnapshot() })

package/lib/ledger.js

@@ -1,5 +1,5 @@
 import { calculateCost, normalizeCostSnapshot } from './pricing.js'
-import { extractUsageEvent, normalizeUsageValues as usageValues, upsertUsageSample as upsertUsageSampleState, usageStepKey } from './usage-core.js'
+import { billingInstantOf, contextTimeKey, extractUsageEvent, normalizeUsageValues as usageValues, pickPricingTime, touchContextTimes, upsertUsageSample as upsertUsageSampleState, usageStepKey } from './usage-core.js'
 
 const LEDGER_VERSION = 3
 const PREVIOUS_LEDGER_VERSION = 2
@@ -189,13 +189,24 @@ export function createLedger(host) {
     const usage = canFoldTail ? new Map((previousRecord.usage || []).map((item) => [item.key, { ...item }])) : new Map()
     const previousUsage = new Map(Array.isArray(previousRecord && previousRecord.usage) ? previousRecord.usage.map((item) => [item.key, item]) : [])
     let currentIdentity = canFoldTail ? coerceIdentity(previousRecord.lastIdentity) : makeIdentity(null, null, null, null)
+    // Request-context instants are kept per turn/step so parallel requests each
+    // carry their own billing time while scanning the persisted log.  When the
+    // tail is folded onto a persisted record, the previous context archive seeds
+    // the map so an open request whose context arrived in the previous batch
+    // still bills its usage with the matching request instant after a restart.
+    const contextTimes = canFoldTail ? new Map(Array.isArray(previousRecord.contextTimes) ? previousRecord.contextTimes.map((entry) => [entry.key, entry.time]) : []) : new Map()
     const startIndex = canFoldTail ? previousRecord.lastSeq + 1 : 0
     for (let index = startIndex; index < events.length; index += 1) {
       const event = events[index]
       if (event === null || typeof event !== 'object') continue
       if (canFoldTail && event.seq <= previousRecord.lastSeq) continue
       const data = event.data
-      if (event.type === 'request/context' || event.type === 'request/header') {
+      if (event.type === 'request/context') {
+        currentIdentity = identityFromRoute(data, currentIdentity)
+        if (validEventTime(event.time)) touchContextTimes(contextTimes, contextTimeKey(data && data.turn, data && data.step), event.time)
+        continue
+      }
+      if (event.type === 'request/header') {
         currentIdentity = identityFromRoute(data, currentIdentity)
         continue
       }
@@ -211,6 +222,7 @@ export function createLedger(host) {
       if (usageEvent === null) continue
       const identity = usageEvent.kind === 'message' ? identityFromMessage(data, currentIdentity) : currentIdentity
       const key = usageStepKey(sid, data, event.seq)
+      const pricing = pickPricingTime(contextTimes, event.time, usageEvent.turn, usageEvent.step)
       const result = upsertUsageSample(usage, {
         key,
         seq: validLedgerSeq(event.seq) ? event.seq : -1,
@@ -221,10 +233,12 @@ export function createLedger(host) {
         turn: usageEvent.turn,
         step: usageEvent.step,
         values: usageEvent.values,
+        pricingAt: pricing.time,
+        pricingTimeSource: pricing.source,
       }, { costPrevious: previousUsage.get(key) })
       if (result.accepted && usageEvent.kind === 'message') currentIdentity = identity
     }
-    return { version: LEDGER_VERSION, sessionId: sid, workspaceId, lastSeq, source, updatedAt: nextLedgerRevision(), lastRevision: typeof revision === 'string' ? revision : undefined, sourceRevision: typeof revision === 'string' ? revision : undefined, lastIdentity: currentIdentity, turns: Array.from(turns.values()), usage: Array.from(usage.values()) }
+    return { version: LEDGER_VERSION, sessionId: sid, workspaceId, lastSeq, source, updatedAt: nextLedgerRevision(), lastRevision: typeof revision === 'string' ? revision : undefined, sourceRevision: typeof revision === 'string' ? revision : undefined, lastIdentity: currentIdentity, contextTimes: Array.from(contextTimes.entries()).map(([key, time]) => ({ key, time })), turns: Array.from(turns.values()), usage: Array.from(usage.values()) }
   }
   function normalizeLedgerRecord(raw, key) {
     if (raw === null || typeof raw !== 'object' || (raw.version !== LEDGER_VERSION && raw.version !== PREVIOUS_LEDGER_VERSION && raw.version !== LEGACY_LEDGER_VERSION) || typeof raw.sessionId !== 'string' || raw.sessionId !== key) return null
@@ -256,9 +270,16 @@ export function createLedger(host) {
     }
     const updatedAt = Number.isFinite(raw.updatedAt) ? raw.updatedAt : 0
     state.ledgerRevision = Math.max(Number.isFinite(state.ledgerRevision) ? state.ledgerRevision : 0, updatedAt)
+    const contextMap = new Map()
+    if (Array.isArray(raw.contextTimes)) {
+      for (const entry of raw.contextTimes) {
+        if (entry === null || typeof entry !== 'object' || typeof entry.key !== 'string' || !entry.key.startsWith('context:') || entry.key.length > 128 || !validEventTime(entry.time)) continue
+        touchContextTimes(contextMap, entry.key, entry.time)
+      }
+    }
     const lastUsage = Array.from(usageMap.values()).at(-1)
     const lastIdentity = coerceIdentity(raw.lastIdentity || raw.sourceRevisionIdentity || (lastUsage && lastUsage.identity))
-    const normalizedRecord = { version: LEDGER_VERSION, sessionId: raw.sessionId, workspaceId: raw.workspaceId, lastSeq: validLedgerSeq(raw.lastSeq) ? raw.lastSeq : -1, source: raw.source === 'flush' ? 'flush' : 'scan', updatedAt, lastRevision: typeof raw.lastRevision === 'string' ? raw.lastRevision : (typeof raw.sourceRevision === 'string' ? raw.sourceRevision : undefined), sourceRevision: typeof raw.sourceRevision === 'string' ? raw.sourceRevision : (typeof raw.lastRevision === 'string' ? raw.lastRevision : undefined), lastIdentity, turns: Array.from(turnMap.values()), usage: Array.from(usageMap.values()) }
+    const normalizedRecord = { version: LEDGER_VERSION, sessionId: raw.sessionId, workspaceId: raw.workspaceId, lastSeq: validLedgerSeq(raw.lastSeq) ? raw.lastSeq : -1, source: raw.source === 'flush' ? 'flush' : 'scan', updatedAt, lastRevision: typeof raw.lastRevision === 'string' ? raw.lastRevision : (typeof raw.sourceRevision === 'string' ? raw.sourceRevision : undefined), sourceRevision: typeof raw.sourceRevision === 'string' ? raw.sourceRevision : (typeof raw.lastRevision === 'string' ? raw.lastRevision : undefined), lastIdentity, contextTimes: Array.from(contextMap.entries()).map(([key, time]) => ({ key, time })), turns: Array.from(turnMap.values()), usage: Array.from(usageMap.values()) }
     if (rebuildReason !== undefined) normalizedRecord.rebuildRequired = rebuildReason
     Object.defineProperty(normalizedRecord, 'needsUpgrade', { value: needsUpgrade, enumerable: false, writable: true })
     return normalizedRecord
@@ -275,7 +296,8 @@ export function createLedger(host) {
       }
       if (cost !== null && cost.pricingMode === 'official-model') { item.cost = cost; continue }
       const identity = item.identity || identityFromLegacy(item.modelId)
-      item.cost = calculateCost(item.values, resolveCurrentPricing(identity))
+      const billing = billingInstantOf(item, cost)
+      item.cost = calculateCost(item.values, resolveCurrentPricing(identity), billing.at, billing.source)
       changed = true
     }
     if (changed) {
@@ -292,6 +314,11 @@ export function createLedger(host) {
     if (record === null || record === undefined) return
     prepareLedgerRecord(record)
     if (record.lastIdentity !== undefined) state.sessionModel.set(record.sessionId, record.lastIdentity)
+    if (Array.isArray(record.contextTimes)) {
+      const times = new Map()
+      for (const entry of record.contextTimes) if (entry && typeof entry.key === 'string' && Number.isFinite(entry.time)) times.set(entry.key, entry.time)
+      state.sessionContextTimes.set(record.sessionId, times)
+    }
     for (const turn of record.turns) addTurn(turn.workspaceId, turn.time, record.sessionId, turn.turn, turn.identity, materialization, turn.seq)
     for (const item of record.usage) {
       const identity = item.identity || identityFromLegacy(item.modelId)

package/lib/plugin.js

@@ -31,6 +31,7 @@ function apply(ctx) {
     usageByLocalDate: new Map(),
     usageByUtcDate: new Map(),
     sessionModel: new Map(),
+    sessionContextTimes: new Map(),
     totals: { turns: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, cost: createCostAccumulator() },
     sessionCount: new Set(),
     sessionSeq: new Map(),

package/lib/pricing-runtime.js

@@ -1,4 +1,5 @@
-import { COST_SCHEMA_VERSION, calculateCost, fetchModelsDevCatalog, normalizeCostSnapshot, normalizePricingState, officialProviderIds, serializeCostAggregate, serializePricingState } from './pricing.js'
+import { COST_SCHEMA_VERSION, calculateCost, fetchModelsDevCatalog, normalizeCostSnapshot, normalizePricingState, officialProviderIds, serializeCostAggregate, serializePricingState, temporalPlanFor } from './pricing.js'
+import { billingInstantOf } from './usage-core.js'
 
 const LEDGER_VERSION = 3
 
@@ -83,6 +84,8 @@ export function createPricingRuntime(host) {
         tieredInvalid: resolved.tieredInvalid === true,
         inputTokenSemantics: resolved.inputTokenSemantics || 'fresh',
         multiplier: resolved.multiplier || '1',
+        ...(resolved.temporalRoute !== undefined && resolved.temporalRoute !== null ? { temporalRoute: resolved.temporalRoute } : {}),
+        ...(resolved.temporalProfile && Array.isArray(resolved.temporalProfile.policies) && resolved.temporalProfile.policies.length > 0 ? { temporalPolicyId: String(resolved.temporalProfile.policies[0].policyId || ''), temporalTimezone: resolved.temporalProfile.policies[0].timezone === 'UTC' ? 'UTC' : null } : {}),
       })
       if (rows.length >= 500) break
     }
@@ -187,12 +190,13 @@ export function createPricingRuntime(host) {
       })
       state.pricingResolutionCache.clear()
       const backfill = backfillUnpricedCosts()
-      // Only catalog changes or newly priced usage can alter computed costs; a
-      // successful sync with an unchanged catalog must not invalidate the query
-      // snapshot, scoped caches, or records cursors. The sync-health bump still
-      // rebuilds the snapshot cache so lastSuccessAt is not stale on the next
-      // full response.
-      if (String(result.catalog.catalogHash || '') !== previousHash || backfill.priced > 0) markStatsChanged('pricing')
+      const temporal = reconcileTemporalPricing()
+      // Only catalog changes, newly priced usage, or temporal snapshot
+      // reconciliation can alter computed costs; a successful sync with an
+      // unchanged catalog must not invalidate the query snapshot, scoped caches,
+      // or records cursors. The sync-health bump still rebuilds the snapshot
+      // cache so lastSuccessAt is not stale on the next full response.
+      if (String(result.catalog.catalogHash || '') !== previousHash || backfill.priced > 0 || temporal.reconciled > 0) markStatsChanged('pricing')
       else markStatsChanged('sync-health')
       await persistPricing()
       await drainLedgerWrites()
@@ -210,8 +214,24 @@ export function createPricingRuntime(host) {
       const oldCost = normalizeCostSnapshot(item.cost)
       if (oldCost !== null && oldCost.pricingMode === 'official-model' && oldCost.status === 'priced') continue
       considered += 1
-      const next = calculateCost(item.values, resolveCurrentPricing(item.identity || item.modelId))
-      if (next.status !== 'priced') continue
+      const billing = billingInstantOf(item, oldCost)
+      const next = calculateCost(item.values, resolveCurrentPricing(item.identity || item.modelId), billing.at, billing.source)
+      const temporalFailClosed = next.status === 'unsupported' && typeof next.reason === 'string' && next.reason.startsWith('temporal-')
+      // A valid fallback (priced) or a deterministic fail-closed verdict
+      // (unsupported: history gap / invalid config) replaces the previous state;
+      // merely unresolved pricing stays untouched.
+      if (next.status !== 'priced' && !temporalFailClosed) continue
+      if (oldCost !== null && oldCost.status === next.status && oldCost.total === next.total && oldCost.baseTotal === next.baseTotal) {
+        if (item.cost !== next) {
+          item.cost = next
+          const record = state.ledgerRecords.get(item.sid)
+          if (record !== undefined) {
+            const stored = record.usage.find((candidate) => candidate.key === item.key)
+            if (stored !== undefined) { stored.cost = next; touched.add(record) }
+          }
+        }
+        continue
+      }
       if (oldCost !== null) {
         adjustCostOnly(item, oldCost, -1)
         adjustQueryCost(item, oldCost, -1)
@@ -242,7 +262,109 @@ export function createPricingRuntime(host) {
     }
     return { considered, priced, remaining }
   }
-  function updatePricingState(raw, backfill) {
+  function costSnapshotEquivalent(left, right) {
+    if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object') return false
+    if (left.status !== right.status || left.currency !== right.currency || left.pricingModel !== right.pricingModel || left.providerId !== right.providerId || left.inputTokenSemantics !== right.inputTokenSemantics || left.multiplier !== right.multiplier || left.billableInputTokens !== right.billableInputTokens || left.billableOutputTokens !== right.billableOutputTokens || left.baseTotal !== right.baseTotal || left.total !== right.total || left.reason !== right.reason || left.tiered !== right.tiered || left.contextTokens !== right.contextTokens || left.pricingAt !== right.pricingAt || left.pricingTimeSource !== right.pricingTimeSource || left.pricingBand !== right.pricingBand || left.pricingPolicyId !== right.pricingPolicyId || left.pricingPolicyHash !== right.pricingPolicyHash || left.pricingTimezone !== right.pricingTimezone || left.temporalApplicable !== right.temporalApplicable || left.temporalExemptReason !== right.temporalExemptReason) return false
+    for (const key of ['input', 'output', 'cacheRead', 'cacheWrite']) {
+      if (left.breakdown !== null && left.breakdown !== undefined && right.breakdown !== null && right.breakdown !== undefined) {
+        if (left.breakdown[key] !== right.breakdown[key]) return false
+      }
+      if (left.rates[key] !== right.rates[key] || right.rates[key] === undefined) return false
+    }
+    const leftTier = left.selectedTier || null
+    const rightTier = right.selectedTier || null
+    if (leftTier === null !== (rightTier === null)) return false
+    if (leftTier !== null && (leftTier.type !== rightTier.type || leftTier.size !== rightTier.size)) return false
+    return true
+  }
+  /**
+   * Controlled DeepSeek temporal reconciliation with auditable-history semantics:
+   * legacy v1 snapshots of first-party DeepSeek routes are migrated against the
+   * usage instant once; already-priced v2 snapshots are NEVER rewritten by a
+   * catalog refresh (their policy hash intentionally excludes live rates) and
+   * only a user-explicit repricing (repriceTemporal) recomputes them. Anything
+   * that cannot be verified keeps its previous value (never guess a price).
+   * Routes that are not first-party DeepSeek are never touched.
+   */
+  function snapshotPolicyMatches(rawCost, resolved) {
+    const exemptReason = rawCost.temporalExemptReason
+    const route = resolved.temporalRoute
+    if (exemptReason === 'route-not-official') return route !== 'official' && route !== 'mapped'
+    if (exemptReason === 'no-temporal-profile' && resolved.temporalProfile === undefined && resolved.temporalConfigInvalid !== true) return true
+    if (typeof rawCost.pricingPolicyId !== 'string' || typeof rawCost.pricingPolicyHash !== 'string') return false
+    const policies = resolved.temporalProfile && Array.isArray(resolved.temporalProfile.policies) ? resolved.temporalProfile.policies : []
+    if (!policies.some((policy) => policy.policyId === rawCost.pricingPolicyId && policy.policyHash === rawCost.pricingPolicyHash)) return false
+    // The snapshot's billing instant must still be covered by (and consistent
+    // with) its own policy: an archive that shrank or moved the window leaves
+    // the snapshot inside a gap, which must fail closed instead of staying priced.
+    const plan = temporalPlanFor(resolved, rawCost.pricingAt)
+    if (plan.status !== 'applied') return false
+    return plan.policyHash === rawCost.pricingPolicyHash && plan.band === rawCost.pricingBand
+  }
+
+  function reconcileTemporalPricing(options = {}) {
+    const force = options.force === true
+    let considered = 0
+    let reconciled = 0
+    const touched = new Set()
+    for (const item of state.usageByStep.values()) {
+      const rawCost = item.cost
+      if (rawCost === null || rawCost === undefined || typeof rawCost !== 'object' || rawCost.pricingMode !== 'official-model') continue
+      const identity = coerceIdentity(item.identity || item.modelId)
+      const resolved = resolveCurrentPricing(identity)
+      const route = resolved.temporalRoute
+      if (route !== 'official' && route !== 'mapped') continue
+      const legacyShape = rawCost.schemaVersion !== COST_SCHEMA_VERSION || rawCost.pricingTimeSource === null || rawCost.pricingTimeSource === undefined || rawCost.pricingTimeSource === 'legacy-unknown'
+      if (!legacyShape && !force) {
+        // Priced snapshots stay auditable only while their policy (or exempt
+        // verdict) still matches the current archive; snapshots priced under a
+        // retired policy (e.g. an earlier effective instant) are migrated once.
+        if (rawCost.status === 'priced' && snapshotPolicyMatches(rawCost, resolved)) continue
+        if (rawCost.status !== 'priced') continue
+      }
+      considered += 1
+      const oldCost = normalizeCostSnapshot(rawCost)
+      const billing = billingInstantOf(item, oldCost)
+      const next = calculateCost(item.values, resolved, billing.at, billing.source)
+      if (costSnapshotEquivalent(oldCost, next)) {
+        if (rawCost !== next) {
+          item.cost = next
+          const record = state.ledgerRecords.get(item.sid)
+          if (record !== undefined) {
+            const stored = record.usage.find((candidate) => candidate.key === item.key)
+            if (stored !== undefined) { stored.cost = next; touched.add(record) }
+          }
+          reconciled += 1
+        }
+        continue
+      }
+      if (oldCost !== null) {
+        adjustCostOnly(item, oldCost, -1)
+        adjustQueryCost(item, oldCost, -1)
+      }
+      item.cost = next
+      adjustCostOnly(item, next, 1)
+      adjustQueryCost(item, next, 1)
+      const record = state.ledgerRecords.get(item.sid)
+      if (record !== undefined) {
+        const stored = record.usage.find((candidate) => candidate.key === item.key)
+        if (stored !== undefined) { stored.cost = next; touched.add(record) }
+      }
+      reconciled += 1
+    }
+    for (const record of touched) {
+      record.version = LEDGER_VERSION
+      record.updatedAt = nextLedgerRevision()
+      // Reconciliation must not clear a mixed-workspace upgrade flag: stay
+      // unfoldable until a rebuild normalizes every historical item.
+      const stillMixed = record.turns.some((turn) => turn && turn.workspaceId !== record.workspaceId) || record.usage.some((item) => item && item.workspaceId !== record.workspaceId)
+      record.needsUpgrade = stillMixed
+      void persistLedgerRecord(record)
+    }
+    return { considered, reconciled }
+  }
+
+  function updatePricingState(raw, backfill, repriceTemporal = false) {
     const input = raw && typeof raw === 'object' && raw.pricing && typeof raw.pricing === 'object' ? raw.pricing : raw
     const current = serializePricingState(state.pricingState)
     const merged = { ...current, ...(input && typeof input === 'object' ? input : {}) }
@@ -250,9 +372,10 @@ export function createPricingRuntime(host) {
     state.pricingState = normalizePricingState(merged)
     state.pricingResolutionCache.clear()
     const result = backfill === true ? backfillUnpricedCosts() : { considered: 0, priced: 0, remaining: state.totals.cost.unpricedCalls + state.totals.cost.ambiguousCalls + state.totals.cost.unsupportedCalls }
+    const temporal = reconcileTemporalPricing({ force: repriceTemporal === true })
     markStatsChanged('pricing')
     schedulePricingSync()
-    return result
+    return { ...result, temporalReconciled: temporal.reconciled }
   }
   function schedulePricingSync() {
     if (state.pricingSyncTimer !== null) { clearTimeout(state.pricingSyncTimer); state.pricingSyncTimer = null }
@@ -276,6 +399,7 @@ export function createPricingRuntime(host) {
     persistPricing,
     syncPricing,
     backfillUnpricedCosts,
+    reconcileTemporalPricing,
     updatePricingState,
     schedulePricingSync
   }