codexmeter 1.0.0 → 1.0.2

package/server/ingest.js

@@ -4,22 +4,19 @@ import {
   normalizeCwd, deriveRepoKey, deriveRepoLabel,
   classifyAgentFamily, isSubagent, normalizeModelName,
 } from './normalize.js';
-import { initPricing, priceSession } from './cost-catalog.js';
+import { calculateCostFromUsage, initPricing, priceSession } from './cost-catalog.js';
 import { buildAggregates, buildSessionView } from './aggregator.js';
 import { createDayKeyFormatter } from './day-key.js';
 import { createLiveAggregateState, createEmptyLivePatch, applySessionToLiveState, buildLiveBootstrap, buildLivePatch } from './live-state.js';
 import { createRolloutWorkerPool } from './rollout-worker-pool.js';
+import { beginReplayCapture, createReplayCaptureState, failReplayCapture, getReplaySnapshot, recordReplayEvent, resetReplayCapture } from './export-replay.js';
+import { OVERVIEW_INGEST_ANIMATION } from '../src/utils/animationsDefault.js';
 
 const LIVE_FRAME_INTERVAL_MS = 50;
 const LIVE_DAYS_PER_SECOND = 6;
-const LIVE_DAY_CADENCE_MS = Math.round(1000 / LIVE_DAYS_PER_SECOND);
+const LIVE_OVERVIEW_CADENCE_MS = Math.round(1000 / 10);
 const LIVE_DAY_KEYS_PER_EMIT = 1;
-const LIVE_SURFACE_CADENCE_MS = {
-  overview: LIVE_FRAME_INTERVAL_MS * 2,
-  rankings: LIVE_FRAME_INTERVAL_MS * 3,
-  daily: LIVE_DAY_CADENCE_MS,
-  heatmap: LIVE_DAY_CADENCE_MS,
-};
+const LIVE_SESSION_REORDER_BUFFER = 160;
 
 export function createIngestState() {
   return {
@@ -43,9 +40,11 @@ export function createIngestState() {
     live_subscribers: new Set(),
     live_pump_timer: null,
     live_pending_patch: createEmptyLivePatch(),
+    live_session_buffer: [],
     live_progress_dirty: false,
     live_last_emit_at: 0,
-    live_last_surface_emit_at: { overview: 0, rankings: 0, daily: 0, heatmap: 0 },
+    live_last_overview_emit_at: 0,
+    replay_capture: createReplayCaptureState(),
   };
 }
 
@@ -60,6 +59,12 @@ export async function runIngest(codexHome, state, opts = {}) {
     state.live_state = createLiveAggregateState(tz);
     state.phase = 'inventory';
     state.percent = 0;
+    beginReplayCapture(state.replay_capture, state.ingest_id, {
+      ingest_id: state.ingest_id,
+      seq: 0,
+      progress: progressPayload(state),
+      data: buildLiveBootstrap(state.live_state),
+    });
     queueLiveProgress(state);
     broadcastBootstrap(state);
 
@@ -98,6 +103,9 @@ export async function runIngest(codexHome, state, opts = {}) {
         model_name: null,
         reasoning_effort: null,
         usage_total: null,
+        usage_by_day: null,
+        has_usage_by_day: false,
+        live_sort_ts: null,
         active_by_day: null,
         agent_role: t.agent_role,
         agent_nickname: t.agent_nickname,
@@ -132,7 +140,7 @@ export async function runIngest(codexHome, state, opts = {}) {
 
     state.needs_enrichment = candidates.length;
     state.percent = candidates.length > 0 ? 0.08 : 0.90;
-    const BATCH_SIZE = opts.batchSize || 100;
+    const BATCH_SIZE = opts.batchSize || 40;
     const ROOT_REFRESH_EVERY = opts.rootRefreshEvery || 1000;
     let lastRootRefreshCount = 0;
 
@@ -160,12 +168,20 @@ export async function runIngest(codexHome, state, opts = {}) {
           if (data.reasoning_effort) s.reasoning_effort = data.reasoning_effort;
           if (data.parent_thread_id) s.parent_thread_id = data.parent_thread_id;
           if (data.usage_total) s.usage_total = data.usage_total;
+          if (data.usage_by_day) {
+            s.usage_by_day = buildUsageByDayMetrics(s.model_name, data.usage_by_day);
+            s.has_usage_by_day = s.usage_by_day.length > 0;
+          }
+          if (data.first_usage_timestamp) {
+            s.live_sort_ts = Math.floor(data.first_usage_timestamp / 1000);
+          }
           if (data.active_seconds && data.active_seconds > 0) {
             s.elapsed_seconds = data.active_seconds;
             s.active_by_day = data.active_by_day || null;
           }
         }
         finalizeSessionMetrics(s, toDayKey);
+        s.live_sort_day = deriveLiveSortDay(s, toDayKey);
         s.materialized = true;
       }
 
@@ -177,8 +193,14 @@ export async function runIngest(codexHome, state, opts = {}) {
         assignRootThreadIds(sessions);
         lastRootRefreshCount = state.enriched;
       }
+      const liveReady = bufferLiveSessionsForPresentation(state, batch);
+      if (state.live_session_buffer[0]?.live_sort_day) {
+        state.current_date_bucket = state.live_session_buffer[0].live_sort_day;
+      } else if (liveReady[0]?.live_sort_day) {
+        state.current_date_bucket = liveReady[0].live_sort_day;
+      }
       const livePatch = createEmptyLivePatch();
-      for (const session of batch) {
+      for (const session of liveReady) {
         applySessionToLiveState(state.live_state, session, livePatch);
       }
       queueLivePatch(state, livePatch);
@@ -197,6 +219,11 @@ export async function runIngest(codexHome, state, opts = {}) {
     }
 
     assignRootThreadIds(sessions);
+    const finalLivePatch = createEmptyLivePatch();
+    for (const session of flushBufferedLiveSessions(state)) {
+      applySessionToLiveState(state.live_state, session, finalLivePatch);
+    }
+    queueLivePatch(state, finalLivePatch);
 
     state.phase = 'aggregation';
     state.percent = state.needs_enrichment > 0 ? 0.95 : 0.90;
@@ -216,6 +243,7 @@ export async function runIngest(codexHome, state, opts = {}) {
     if (!isCurrentRun()) return;
     state.error = err.message;
     state.phase = 'error';
+    failReplayCapture(state.replay_capture);
     console.error('Ingest error:', err);
     flushLive(state, 'ingest-error');
   } finally {
@@ -247,9 +275,11 @@ export function restartIngest(codexHome, state, opts = {}) {
   state.live_state = null;
   state.live_seq = 0;
   state.live_pending_patch = createEmptyLivePatch();
+  state.live_session_buffer = [];
   state.live_progress_dirty = false;
   state.live_last_emit_at = 0;
-  state.live_last_surface_emit_at = { overview: 0, rankings: 0, daily: 0, heatmap: 0 };
+  state.live_last_overview_emit_at = 0;
+  resetReplayCapture(state.replay_capture);
 
   return runIngest(codexHome, state, opts);
 }
@@ -352,6 +382,64 @@ function finalizeSessionMetrics(session, toDayKey) {
   }
 }
 
+function buildUsageByDayMetrics(modelName, usageByDay) {
+  const entries = [];
+  for (const [dayKey, usage] of Object.entries(usageByDay || {})) {
+    const tokens = (usage?.input_tokens || 0) + (usage?.output_tokens || 0);
+    const cost = calculateCostFromUsage(modelName, usage);
+    entries.push({
+      day: dayKey,
+      tokens,
+      cost,
+    });
+  }
+  entries.sort((a, b) => a.day.localeCompare(b.day));
+  return entries;
+}
+
+function deriveLiveSortDay(session, toDayKey) {
+  if (session.has_usage_by_day && session.usage_by_day?.length) {
+    let best = session.usage_by_day[0];
+    for (const entry of session.usage_by_day) {
+      if ((entry.tokens || 0) > (best.tokens || 0)) {
+        best = entry;
+        continue;
+      }
+      if ((entry.tokens || 0) === (best.tokens || 0) && String(entry.day) > String(best.day)) {
+        best = entry;
+      }
+    }
+    return best?.day || null;
+  }
+  if (session.started_at) {
+    return toDayKey(session.started_at * 1000);
+  }
+  return null;
+}
+
+function compareLiveSessionOrder(a, b) {
+  const dayCompare = String(a.live_sort_day || '9999-12-31').localeCompare(String(b.live_sort_day || '9999-12-31'));
+  if (dayCompare !== 0) return dayCompare;
+  const liveTsCompare = (a.live_sort_ts || a.started_at || 0) - (b.live_sort_ts || b.started_at || 0);
+  if (liveTsCompare !== 0) return liveTsCompare;
+  return String(a.thread_id || '').localeCompare(String(b.thread_id || ''));
+}
+
+function bufferLiveSessionsForPresentation(state, sessions) {
+  if (!sessions.length) return [];
+  state.live_session_buffer.push(...sessions);
+  state.live_session_buffer.sort(compareLiveSessionOrder);
+  const flushCount = Math.max(0, state.live_session_buffer.length - LIVE_SESSION_REORDER_BUFFER);
+  if (flushCount <= 0) return [];
+  return state.live_session_buffer.splice(0, flushCount);
+}
+
+function flushBufferedLiveSessions(state) {
+  if (!state.live_session_buffer.length) return [];
+  state.live_session_buffer.sort(compareLiveSessionOrder);
+  return state.live_session_buffer.splice(0, state.live_session_buffer.length);
+}
+
 function queueLiveProgress(state) {
   state.live_progress_dirty = true;
   ensureLivePump(state);
@@ -364,13 +452,14 @@ function queueLivePatch(state, patch) {
 }
 
 function ensureLivePump(state) {
-  if (state.live_pump_timer || !state.live_subscribers.size) return;
+  if (state.live_pump_timer) return;
+  if (!state.live_subscribers.size && !state.replay_capture.active) return;
   state.live_pump_timer = setInterval(() => flushLive(state), LIVE_FRAME_INTERVAL_MS);
 }
 
 function stopLivePumpIfIdle(state) {
   if (!state.live_pump_timer) return;
-  if (state.live_subscribers.size) return;
+  if (state.live_subscribers.size || state.replay_capture.active) return;
   clearInterval(state.live_pump_timer);
   state.live_pump_timer = null;
   finalizeWithoutSubscribers(state);
@@ -378,6 +467,7 @@ function stopLivePumpIfIdle(state) {
 
 function finalizeWithoutSubscribers(state) {
   if (state.live_subscribers.size) return;
+  if (state.replay_capture.active) return;
   if (!state.presentation_complete_pending) return;
   state.phase = 'complete';
   state.percent = 1;
@@ -388,7 +478,7 @@ function finalizeWithoutSubscribers(state) {
 }
 
 function flushLive(state, forcedEvent = null) {
-  if (!state.live_subscribers.size) {
+  if (!state.live_subscribers.size && !state.replay_capture.active) {
     state.live_pending_patch = createEmptyLivePatch();
     state.live_progress_dirty = false;
     stopLivePumpIfIdle(state);
@@ -428,12 +518,16 @@ function flushLive(state, forcedEvent = null) {
     payload.data = buildLiveBootstrap(state.live_state);
   }
 
-  broadcastLive(state, event, payload);
+  recordReplayEvent(state.replay_capture, event, payload);
+  if (state.live_subscribers.size) {
+    broadcastLive(state, event, payload);
+  }
   state.live_last_emit_at = Date.now();
   state.live_progress_dirty = shouldEmitComplete ? false : (event === 'progress' ? false : state.live_progress_dirty);
   if (forcedEvent) {
     state.live_pending_patch = createEmptyLivePatch();
   }
+  stopLivePumpIfIdle(state);
 }
 
 function broadcastLive(state, event, payload) {
@@ -475,41 +569,48 @@ function takeFlushablePatch(state) {
   const now = Date.now();
   const sent = createEmptyLivePatch();
 
-  if (state.live_pending_patch.overview.size > 0 && readyForSurface(state, 'overview', now)) {
-    moveSet(state.live_pending_patch.overview, sent.overview);
-    state.live_last_surface_emit_at.overview = now;
-  }
-
-  const rankingsDirty =
+  const overviewDirty =
+    state.live_pending_patch.overview.size > 0 ||
     state.live_pending_patch.repos.total.size > 0 || state.live_pending_patch.repos.d7.size > 0 || state.live_pending_patch.repos.d30.size > 0 ||
     state.live_pending_patch.models.total.size > 0 || state.live_pending_patch.models.d7.size > 0 || state.live_pending_patch.models.d30.size > 0 ||
-    state.live_pending_patch.families.total.size > 0 || state.live_pending_patch.families.d7.size > 0 || state.live_pending_patch.families.d30.size > 0;
+    state.live_pending_patch.families.total.size > 0 || state.live_pending_patch.families.d7.size > 0 || state.live_pending_patch.families.d30.size > 0 ||
+    state.live_pending_patch.daily.size > 0 || state.live_pending_patch.heatmap.size > 0;
 
-  if (rankingsDirty && readyForSurface(state, 'rankings', now)) {
-    moveRangeSets(state.live_pending_patch.repos, sent.repos);
-    moveRangeSets(state.live_pending_patch.models, sent.models);
-    moveRangeSets(state.live_pending_patch.families, sent.families);
-    state.live_last_surface_emit_at.rankings = now;
+  if (!overviewDirty || !readyForOverview(state, now)) {
+    return sent;
   }
 
-  const dayDirty = state.live_pending_patch.daily.size > 0 || state.live_pending_patch.heatmap.size > 0;
-  if (dayDirty && readyForSurface(state, 'daily', now)) {
-    const nextDayKeys = takeNextChronologicalDayKeys(
-      state.live_pending_patch.daily,
-      state.live_pending_patch.heatmap,
-      LIVE_DAY_KEYS_PER_EMIT
-    );
-    moveSpecificKeys(state.live_pending_patch.daily, sent.daily, nextDayKeys);
-    moveSpecificKeys(state.live_pending_patch.heatmap, sent.heatmap, nextDayKeys);
-    state.live_last_surface_emit_at.daily = now;
-    state.live_last_surface_emit_at.heatmap = now;
-  }
+  moveSet(state.live_pending_patch.overview, sent.overview);
+  moveRangeSets(state.live_pending_patch.repos, sent.repos);
+  moveRangeSets(state.live_pending_patch.models, sent.models);
+  moveRangeSets(state.live_pending_patch.families, sent.families);
+
+  const nextDayKeys = takeNextChronologicalDayKeys(
+    state.live_pending_patch.daily,
+    state.live_pending_patch.heatmap,
+    LIVE_DAY_KEYS_PER_EMIT
+  );
+  moveSpecificKeys(state.live_pending_patch.daily, sent.daily, nextDayKeys);
+  moveSpecificKeys(state.live_pending_patch.heatmap, sent.heatmap, nextDayKeys);
+  state.live_last_overview_emit_at = now;
 
   return sent;
 }
 
-function readyForSurface(state, surfaceKey, now) {
-  return (now - state.live_last_surface_emit_at[surfaceKey]) >= LIVE_SURFACE_CADENCE_MS[surfaceKey];
+function readyForOverview(state, now) {
+  return (now - state.live_last_overview_emit_at) >= getOverviewCadenceMs(state);
+}
+
+function getOverviewCadenceMs(state) {
+  const tail = OVERVIEW_INGEST_ANIMATION.tail;
+  const tailStartPercent = Math.min(Math.max(tail?.startPercent ?? 0.95, 0), 0.999);
+  const tailHz = Number.isFinite(tail?.overviewHz) && tail.overviewHz > 0 ? tail.overviewHz : 5;
+  const tailCadenceMs = Math.round(1000 / tailHz);
+
+  if (tail?.enabled && (state.presentation_complete_pending || (state.percent || 0) >= tailStartPercent)) {
+    return tailCadenceMs;
+  }
+  return LIVE_OVERVIEW_CADENCE_MS;
 }
 
 function moveSet(from, to) {
@@ -581,6 +682,10 @@ export function detachLiveSubscriber(state, res) {
   stopLivePumpIfIdle(state);
 }
 
+export function getLatestReplay(state) {
+  return getReplaySnapshot(state.replay_capture);
+}
+
 function broadcastBootstrap(state) {
   if (!state.live_subscribers.size) return;
   const payload = {

package/server/live-state.js

@@ -217,7 +217,10 @@ function applyDailyBucket(dayMap, session, toDayKey, dirtySet) {
     const startDay = toDayKey(startMs);
     const endDay = toDayKey(endMs - 1);
 
-    if (startDay === endDay) {
+    if (session.has_usage_by_day) {
+      addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKey, session, dirtySet);
+      addUsageByDay(dayMap, session, dirtySet);
+    } else if (startDay === endDay) {
       addToDay(dayMap, startDay, session, 1.0);
       dirtySet.add(startDay);
     } else {
@@ -247,7 +250,21 @@ function applyDailyBucket(dayMap, session, toDayKey, dirtySet) {
 }
 
 function applyHeatmapBucket(dayMap, session, toDayKey, dirtySet) {
-  if (session.started_at) {
+  if (session.has_usage_by_day) {
+    for (const usageDay of session.usage_by_day || []) {
+      const dayKey = usageDay.day;
+      const day = ensureHeatmapDay(dayMap, dayKey);
+      day.tokens += usageDay.tokens || 0;
+      if (usageDay.cost !== null) day.cost += usageDay.cost;
+      dirtySet.add(dayKey);
+    }
+    if (session.started_at) {
+      const startDay = toDayKey(session.started_at * 1000);
+      const day = ensureHeatmapDay(dayMap, startDay);
+      day.sessions += 1;
+      dirtySet.add(startDay);
+    }
+  } else if (session.started_at) {
     const dayKey = toDayKey(session.started_at * 1000);
     const day = ensureHeatmapDay(dayMap, dayKey);
     day.tokens += session.tokens_used || 0;
@@ -265,6 +282,48 @@ function applyHeatmapBucket(dayMap, session, toDayKey, dirtySet) {
   }
 }
 
+function addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKey, session, dirtySet) {
+  if (startDay === endDay) {
+    addPresenceToDay(dayMap, startDay, session, 1.0);
+    dirtySet.add(startDay);
+    return;
+  }
+
+  let cursor = dayStartMs(startDay);
+  while (cursor < endMs) {
+    const nextDay = cursor + 86400000;
+    const overlapStart = Math.max(cursor, startMs);
+    const overlapEnd = Math.min(nextDay, endMs);
+    const fraction = (overlapEnd - overlapStart) / totalDur;
+    if (fraction > 0) {
+      const dayKey = toDayKey(cursor);
+      addPresenceToDay(dayMap, dayKey, session, fraction);
+      dirtySet.add(dayKey);
+    }
+    cursor = nextDay;
+  }
+}
+
+function addPresenceToDay(dayMap, dayKey, session, fraction) {
+  const day = ensureDay(dayMap, dayKey);
+  if (fraction > 0.001) day.sessions += 1;
+}
+
+function addUsageByDay(dayMap, session, dirtySet) {
+  for (const usageDay of session.usage_by_day || []) {
+    const dayKey = usageDay.day;
+    const day = ensureDay(dayMap, dayKey);
+    day.tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) day.cost += usageDay.cost;
+
+    const modelKey = session.model_name || 'unknown';
+    if (!day.by_model[modelKey]) day.by_model[modelKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+    day.by_model[modelKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) day.by_model[modelKey].cost += usageDay.cost;
+    dirtySet.add(dayKey);
+  }
+}
+
 function addToDay(dayMap, dayKey, session, fraction) {
   const day = ensureDay(dayMap, dayKey);
   day.tokens += (session.tokens_used || 0) * fraction;

package/server/rollout-reader.js

@@ -15,9 +15,11 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
     model_name: null,
     reasoning_effort: null,
     first_timestamp: null,
+    first_usage_timestamp: null,
     last_timestamp: null,
     active_seconds: null,
     active_by_day: null,
+    usage_by_day: null,
     parent_thread_id: null,
     usage_total: null,
   };
@@ -28,6 +30,11 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
     let prevTimestamp = null;
     let activeMs = 0;
     const activeByDay = new Map();
+    const usageByDay = new Map();
+    let lastInputTokens = 0;
+    let lastCachedInputTokens = 0;
+    let lastOutputTokens = 0;
+    let hasSeenUsage = false;
     for (const line of content.split(/\r?\n/)) {
       if (!line.trim()) continue;
 
@@ -58,13 +65,46 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
         if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') {
           const usage = obj.payload.info?.total_token_usage;
           if (usage) {
+            const inputTokens = usage.input_tokens || 0;
+            const cachedInputTokens = usage.cached_input_tokens || 0;
+            const outputTokens = usage.output_tokens || 0;
+            const reasoningOutputTokens = usage.reasoning_output_tokens || 0;
+            const totalTokens = usage.total_tokens || 0;
+
             result.usage_total = {
-              input_tokens: usage.input_tokens || 0,
-              cached_input_tokens: usage.cached_input_tokens || 0,
-              output_tokens: usage.output_tokens || 0,
-              reasoning_output_tokens: usage.reasoning_output_tokens || 0,
-              total_tokens: usage.total_tokens || 0,
+              input_tokens: inputTokens,
+              cached_input_tokens: cachedInputTokens,
+              output_tokens: outputTokens,
+              reasoning_output_tokens: reasoningOutputTokens,
+              total_tokens: totalTokens,
             };
+
+            const usageDelta = hasSeenUsage
+              ? {
+                  input_tokens: Math.max(inputTokens - lastInputTokens, 0),
+                  cached_input_tokens: Math.max(cachedInputTokens - lastCachedInputTokens, 0),
+                  output_tokens: Math.max(outputTokens - lastOutputTokens, 0),
+                }
+              : {
+                  input_tokens: inputTokens,
+                  cached_input_tokens: cachedInputTokens,
+                  output_tokens: outputTokens,
+                };
+
+            hasSeenUsage = true;
+            lastInputTokens = inputTokens;
+            lastCachedInputTokens = cachedInputTokens;
+            lastOutputTokens = outputTokens;
+            if (obj.timestamp && hasUsage(usageDelta)) {
+              const ts = new Date(obj.timestamp).getTime();
+              if (!isNaN(ts)) {
+                if (!result.first_usage_timestamp || ts < result.first_usage_timestamp) {
+                  result.first_usage_timestamp = ts;
+                }
+                const dayKey = toDayKey(ts);
+                mergeUsageTotals(usageByDay, dayKey, usageDelta);
+              }
+            }
           }
         }
 
@@ -100,9 +140,51 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
       result.active_by_day = activeByDaySeconds;
       result.active_seconds = Object.values(activeByDaySeconds).reduce((sum, seconds) => sum + seconds, 0);
     }
+    if (usageByDay.size > 0) {
+      result.usage_by_day = Object.fromEntries(usageByDay);
+    }
   } catch {
     return null;
   }
 
   return result;
 }
+
+function normalizeUsageTotals(usage) {
+  return {
+    input_tokens: usage.input_tokens || 0,
+    cached_input_tokens: usage.cached_input_tokens || 0,
+    output_tokens: usage.output_tokens || 0,
+    reasoning_output_tokens: usage.reasoning_output_tokens || 0,
+    total_tokens: usage.total_tokens || 0,
+  };
+}
+
+function subtractUsageTotals(current, previous) {
+  return {
+    input_tokens: Math.max((current.input_tokens || 0) - (previous.input_tokens || 0), 0),
+    cached_input_tokens: Math.max((current.cached_input_tokens || 0) - (previous.cached_input_tokens || 0), 0),
+    output_tokens: Math.max((current.output_tokens || 0) - (previous.output_tokens || 0), 0),
+    reasoning_output_tokens: Math.max((current.reasoning_output_tokens || 0) - (previous.reasoning_output_tokens || 0), 0),
+    total_tokens: Math.max((current.total_tokens || 0) - (previous.total_tokens || 0), 0),
+  };
+}
+
+function hasUsage(usage) {
+  return !!usage && (
+    usage.input_tokens > 0 ||
+    usage.cached_input_tokens > 0 ||
+    usage.output_tokens > 0
+  );
+}
+
+function mergeUsageTotals(target, dayKey, usage) {
+  let previous = target.get(dayKey);
+  if (!previous) {
+    previous = { input_tokens: 0, cached_input_tokens: 0, output_tokens: 0 };
+    target.set(dayKey, previous);
+  }
+  previous.input_tokens += usage.input_tokens || 0;
+  previous.cached_input_tokens += usage.cached_input_tokens || 0;
+  previous.output_tokens += usage.output_tokens || 0;
+}