coding-tool-x 3.8.3 → 3.8.5

package/src/server/services/snapshot-cache.js

@@ -147,17 +147,27 @@ function runRefresh(refresh, defer, deferMs) {
 
 function refreshSnapshot(key, refresh, {
   defer = false,
-  deferMs = DEFAULT_BACKGROUND_DELAY_MS,
-  bypassInflight = false
+  deferMs = DEFAULT_BACKGROUND_DELAY_MS
 } = {}) {
-  if (!bypassInflight && inflight.has(key)) {
+  if (inflight.has(key)) {
     return inflight.get(key);
   }
 
-  const startedVersion = bypassInflight ? bumpInvalidationVersion(key) : getInvalidationVersion(key);
+  const startedVersion = getInvalidationVersion(key);
   const promise = runRefresh(refresh, defer, deferMs)
     .then((value) => {
-      const entry = makeEntry(key, value);
+      let nextValue = value;
+      const existing = getEntry(key);
+      if (value && Array.isArray(value.__errors) && existing?.value && typeof existing.value === 'object') {
+        nextValue = { ...existing.value, ...value };
+        for (const failure of value.__errors) {
+          const capability = failure?.capability === 'statistics' ? 'todayStats' : failure?.capability;
+          if (capability && Object.prototype.hasOwnProperty.call(existing.value, capability)) {
+            nextValue[capability] = existing.value[capability];
+          }
+        }
+      }
+      const entry = makeEntry(key, nextValue);
       if (getInvalidationVersion(key) === startedVersion) {
         snapshots.set(key, entry);
         lastErrors.delete(key);
@@ -271,7 +281,7 @@ async function getSnapshot(key, {
       : 0;
 
     if (!entry && Number(coldWaitMs) > 0) {
-      refreshPromise = refreshSnapshot(key, refresh, { bypassInflight: force });
+      refreshPromise = refreshSnapshot(key, refresh);
       const waitResult = await waitForRefresh(refreshPromise, coldWaitMs);
       if (waitResult.entry) {
         entry = waitResult.entry;
@@ -287,7 +297,7 @@ async function getSnapshot(key, {
       }
     } else if (!entry && backgroundOnMiss === false) {
       try {
-        entry = await refreshSnapshot(key, refresh, { bypassInflight: force });
+        entry = await refreshSnapshot(key, refresh);
         expired = false;
       } catch (error) {
         refreshError = error?.message || String(error);
@@ -295,7 +305,7 @@ async function getSnapshot(key, {
         if (!entry) throw error;
       }
     } else {
-      refreshPromise = refreshSnapshot(key, refresh, { defer: !force, deferMs, bypassInflight: force });
+      refreshPromise = refreshSnapshot(key, refresh, { defer: !force, deferMs });
     }
   }
 
@@ -370,6 +380,16 @@ function invalidateSnapshot(keyOrPrefix) {
   }
 }
 
+function dashboardSourceKey(source) {
+  return `dashboard:source:${source}`;
+}
+
+function invalidateDashboardSourceSnapshot(source) {
+  if (source) {
+    invalidateSnapshot(dashboardSourceKey(source));
+  }
+}
+
 function clearSnapshotCache({ deleteFiles = false } = {}) {
   for (const key of inflight.keys()) {
     bumpInvalidationVersion(key);
@@ -392,6 +412,8 @@ module.exports = {
   refreshSnapshot,
   invalidateSnapshot,
   clearSnapshotCache,
+  dashboardSourceKey,
+  invalidateDashboardSourceSnapshot,
   _test: {
     getSnapshotDir,
     getSnapshotPath,

package/src/server/services/speed-test.js

@@ -8,18 +8,18 @@ const https = require('https');
 const http = require('http');
 const { URL } = require('url');
 const { probeModelAvailability } = require('./model-detector');
-const { getEffectiveApiKey: getClaudeEffectiveApiKey } = require('./channels');
-const { getEffectiveApiKey: getCodexEffectiveApiKey } = require('./codex-channels');
-const { getEffectiveApiKey: getGeminiEffectiveApiKey } = require('./gemini-channels');
-const { getEffectiveApiKey: getOpenCodeEffectiveApiKey } = require('./opencode-channels');
-const { getEffectiveApiKey: getOmpEffectiveApiKey } = require('./omp-channels');
-const { createCodexRequest } = require('./codex-wire');
-const { createClaudeRequest, buildClaudeTargetUrl } = require('./claude-wire');
+const { getEffectiveApiKey: getClaudeEffectiveApiKey } = require('../../platforms/drivers/claude/channels-implementation');
+const { getEffectiveApiKey: getCodexEffectiveApiKey } = require('../../platforms/drivers/codex/channels-implementation');
+const { getEffectiveApiKey: getGeminiEffectiveApiKey } = require('../../platforms/drivers/gemini/channels-implementation');
+const { getEffectiveApiKey: getOpenCodeEffectiveApiKey } = require('../../platforms/drivers/opencode/channels-implementation');
+const { getEffectiveApiKey: getOmpEffectiveApiKey } = require('../../platforms/drivers/omp/channels-implementation');
+const { createCodexRequest } = require('../../platforms/drivers/codex/wire');
+const { createClaudeRequest, buildClaudeTargetUrl } = require('../../platforms/drivers/claude/wire');
 const {
   createGeminiRequest,
   buildGeminiTargetUrl,
   shouldUseGeminiCliFormat
-} = require('./gemini-wire');
+} = require('../../platforms/drivers/gemini/wire');
 
 // 测试结果缓存
 const testResultsCache = new Map();

package/src/server/services/sqlite-connection.js

@@ -39,7 +39,17 @@ function openDatabase(filePath, options = {}) {
   });
 
   if (!options.readOnly) {
-    db.exec('PRAGMA foreign_keys = ON');
+    // Keep the per-process SQLite footprint bounded. The session history
+    // database can contain hundreds of thousands of messages, and the
+    // default page cache plus an unbounded WAL made repeated inventories
+    // compete with the Node heap for memory and disk space.
+    db.exec(`
+      PRAGMA foreign_keys = ON;
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA wal_autocheckpoint = 1000;
+      PRAGMA cache_size = -16384;
+    `);
   }
 
   _connections.set(key, db);
@@ -57,8 +67,13 @@ function closeDatabase(filePath) {
   if (!db) {
     return;
   }
-  db.close();
-  _connections.delete(key);
+  try {
+    // A clean shutdown should not leave a multi-gigabyte WAL behind. This is
+    // best effort because another process may still be using the database.
+    try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch (_err) {}
+  } finally {
+    try { db.close(); } finally { _connections.delete(key); }
+  }
 }
 
 /**
@@ -67,6 +82,7 @@ function closeDatabase(filePath) {
 function closeAllDatabases() {
   for (const db of _connections.values()) {
     try {
+      try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch (_err) {}
       db.close();
     } catch (_err) {
       // swallow — best-effort teardown

package/src/server/services/statistics-service.js

@@ -1,11 +1,17 @@
 const fs = require('fs');
 const path = require('path');
 const { PATHS } = require('../../config/paths');
-const { normalizeUsageTokens, resolveActualModel } = require('./proxy-log-helper');
+const { normalizeUsageTokens, resolveActualModel } = require('./usage-log-utils');
 
 // 北京时间辅助（UTC+8），统一所有时间计算
 const CST_OFFSET_MS = 8 * 60 * 60 * 1000;
 
+const pendingEntries = [];
+let flushPromise = null;
+let flushScheduled = false;
+let aggregateStatsCache = null;
+const dailyStatsCache = new Map();
+
 function toCSTDate(ts) {
   // 返回以北京时间解释的 Date 对象各字段（通过偏移 UTC）
   return new Date(new Date(ts).getTime() + CST_OFFSET_MS);
@@ -181,6 +187,111 @@ function appendRequestLog(logEntry) {
   }
 }
 
+function cloneJson(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function getRequestLogPath(timestamp) {
+  const cst = toCSTDate(timestamp);
+  const year = cst.getUTCFullYear();
+  const month = String(cst.getUTCMonth() + 1).padStart(2, '0');
+  const day = String(cst.getUTCDate()).padStart(2, '0');
+  return path.join(PATHS.statistics.requestLogs, `${year}-${month}`, `${day}.jsonl`);
+}
+
+async function appendRequestLogsAsync(entries) {
+  const byPath = new Map();
+  for (const entry of entries) {
+    const filePath = getRequestLogPath(entry.logEntry.timestamp);
+    const group = byPath.get(filePath) || [];
+    group.push(entry);
+    byPath.set(filePath, group);
+  }
+
+  const persisted = [];
+  for (const [filePath, group] of byPath) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.appendFile(
+      filePath,
+      group.map(entry => `${JSON.stringify(entry.logEntry)}\n`).join(''),
+      'utf8'
+    );
+    persisted.push(...group);
+  }
+  return persisted;
+}
+
+async function writeJsonAsync(filePath, value) {
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, JSON.stringify(value, null, 2), 'utf8');
+}
+
+function scheduleStatisticsFlush() {
+  if (flushScheduled) return;
+  flushScheduled = true;
+  queueMicrotask(() => {
+    flushScheduled = false;
+    void flushStatistics();
+  });
+}
+
+async function flushStatistics() {
+  if (flushPromise) return flushPromise;
+  if (pendingEntries.length === 0) {
+    return { flushed: 0, pending: 0 };
+  }
+
+  const batch = pendingEntries.splice(0, pendingEntries.length);
+  const globalSnapshot = aggregateStatsCache ? cloneJson(aggregateStatsCache) : null;
+  const dates = [...new Set(batch.map(entry => entry.date))];
+  const dailySnapshots = new Map(
+    dates.map(date => [date, cloneJson(dailyStatsCache.get(date))])
+  );
+
+  const writer = (async () => {
+    try {
+      const pendingLogEntries = batch.filter(entry => !entry.logPersisted);
+      const persisted = await appendRequestLogsAsync(pendingLogEntries);
+      persisted.forEach(entry => { entry.logPersisted = true; });
+      if (globalSnapshot) {
+        globalSnapshot.lastUpdated = new Date().toISOString();
+        await writeJsonAsync(getStatisticsFilePath(), globalSnapshot);
+      }
+      for (const [date, stats] of dailySnapshots) {
+        if (stats) await writeJsonAsync(getDailyStatsFilePathWithoutCreate(date), stats);
+      }
+      return { flushed: batch.length, pending: pendingEntries.length };
+    } catch (error) {
+      pendingEntries.unshift(...batch);
+      console.error('[Statistics] Failed to flush queued entries:', error.message);
+      return {
+        flushed: 0,
+        pending: pendingEntries.length,
+        error: error.message
+      };
+    }
+  })();
+
+  flushPromise = writer.finally(() => {
+    flushPromise = null;
+    if (pendingEntries.length > 0) scheduleStatisticsFlush();
+  });
+  return flushPromise;
+}
+
+function getDailyStatsFilePathWithoutCreate(date) {
+  return path.join(PATHS.statistics.dailyStats, `${date}.json`);
+}
+
+async function shutdownStatistics() {
+  let result = await flushStatistics();
+  while (result.pending > 0 && !result.error) {
+    result = await flushStatistics();
+  }
+  return result;
+}
+
+
 // 初始化统计对象
 function initStatsObject() {
   return {
@@ -257,11 +368,10 @@ function recordRequest(requestData) {
     if (requestData.redirectedModel) {
       logEntry.redirectedModel = requestData.redirectedModel;
     }
-    appendRequestLog(logEntry);
 
     // 2. 更新总体统计
-    const globalStats = loadStatistics();
-
+    const globalStats = aggregateStatsCache || loadStatistics();
+    aggregateStatsCache = globalStats;
     // 更新全局统计
     globalStats.global.totalRequests += 1;
     globalStats.global.totalTokens += totalTokens;
@@ -277,18 +387,22 @@ function recordRequest(requestData) {
     }
     updateStats(globalStats.byToolType[toolType], tokens, cost);
 
-    // 按工具类型 -> 渠道统计
-    if (!globalStats.byToolType[toolType].channels[channelId]) {
-      globalStats.byToolType[toolType].channels[channelId] = {
-        name: channel,
-        ...initStatsObject(),
-        firstUsed: timestamp,
-        lastUsed: timestamp
-      };
-    } else {
-      globalStats.byToolType[toolType].channels[channelId].lastUsed = timestamp;
+    // Native CLI logs do not always contain a reliable configured-channel id.
+    // Keep aggregate totals in that case instead of creating an "undefined"
+    // channel bucket.
+    if (channelId) {
+      if (!globalStats.byToolType[toolType].channels[channelId]) {
+        globalStats.byToolType[toolType].channels[channelId] = {
+          name: channel,
+          ...initStatsObject(),
+          firstUsed: timestamp,
+          lastUsed: timestamp
+        };
+      } else {
+        globalStats.byToolType[toolType].channels[channelId].lastUsed = timestamp;
+      }
+      updateStats(globalStats.byToolType[toolType].channels[channelId], tokens, cost);
     }
-    updateStats(globalStats.byToolType[toolType].channels[channelId], tokens, cost);
 
     // 按工具类型 -> 模型统计
     if (!globalStats.byToolType[toolType].models[modelKey]) {
@@ -296,19 +410,21 @@ function recordRequest(requestData) {
     }
     updateStats(globalStats.byToolType[toolType].models[modelKey], tokens, cost);
 
-    // 按渠道统计（跨工具）
-    if (!globalStats.byChannel[channelId]) {
-      globalStats.byChannel[channelId] = {
-        toolType,
-        name: channel,
-        ...initStatsObject(),
-        firstUsed: timestamp,
-        lastUsed: timestamp
-      };
-    } else {
-      globalStats.byChannel[channelId].lastUsed = timestamp;
+    // Cross-tool channel totals follow the same rule.
+    if (channelId) {
+      if (!globalStats.byChannel[channelId]) {
+        globalStats.byChannel[channelId] = {
+          toolType,
+          name: channel,
+          ...initStatsObject(),
+          firstUsed: timestamp,
+          lastUsed: timestamp
+        };
+      } else {
+        globalStats.byChannel[channelId].lastUsed = timestamp;
+      }
+      updateStats(globalStats.byChannel[channelId], tokens, cost);
     }
-    updateStats(globalStats.byChannel[channelId], tokens, cost);
 
     // 按模型统计（跨工具）
     if (!globalStats.byModel[modelKey]) {
@@ -319,13 +435,13 @@ function recordRequest(requestData) {
     }
     updateStats(globalStats.byModel[modelKey], tokens, cost);
 
-    saveStatistics(globalStats);
 
     // 3. 更新每日统计（使用北京时间）
     const date = getCSTDateStr(timestamp); // YYYY-MM-DD (CST)
     const hour = getCSTHour(timestamp).toString().padStart(2, '0'); // HH (CST)
 
-    const dailyStats = loadDailyStats(date);
+    const dailyStats = dailyStatsCache.get(date) || loadDailyStats(date);
+    dailyStatsCache.set(date, dailyStats);
 
     // 更新每日汇总
     dailyStats.summary.requests += 1;
@@ -357,17 +473,19 @@ function recordRequest(requestData) {
     }
     updateStats(dailyStats.byToolType[toolType], tokens, cost);
 
-    // 按工具类型 -> 渠道
-    if (!dailyStats.byToolType[toolType].channels) {
-      dailyStats.byToolType[toolType].channels = {};
-    }
-    if (!dailyStats.byToolType[toolType].channels[channelId]) {
-      dailyStats.byToolType[toolType].channels[channelId] = {
-        name: channel,
-        ...initStatsObject()
-      };
+    // 按工具类型 -> 渠道；原生日志没有可靠渠道时只保留平台级统计。
+    if (channelId) {
+      if (!dailyStats.byToolType[toolType].channels) {
+        dailyStats.byToolType[toolType].channels = {};
+      }
+      if (!dailyStats.byToolType[toolType].channels[channelId]) {
+        dailyStats.byToolType[toolType].channels[channelId] = {
+          name: channel,
+          ...initStatsObject()
+        };
+      }
+      updateStats(dailyStats.byToolType[toolType].channels[channelId], tokens, cost);
     }
-    updateStats(dailyStats.byToolType[toolType].channels[channelId], tokens, cost);
 
     // 按工具类型 -> 模型
     if (!dailyStats.byToolType[toolType].models) {
@@ -378,15 +496,17 @@ function recordRequest(requestData) {
     }
     updateStats(dailyStats.byToolType[toolType].models[modelKey], tokens, cost);
 
-    // 按渠道统计
-    if (!dailyStats.byChannel[channelId]) {
-      dailyStats.byChannel[channelId] = {
-        toolType,
-        name: channel,
-        ...initStatsObject()
-      };
+    // 按渠道统计；不创建 undefined 渠道桶。
+    if (channelId) {
+      if (!dailyStats.byChannel[channelId]) {
+        dailyStats.byChannel[channelId] = {
+          toolType,
+          name: channel,
+          ...initStatsObject()
+        };
+      }
+      updateStats(dailyStats.byChannel[channelId], tokens, cost);
     }
-    updateStats(dailyStats.byChannel[channelId], tokens, cost);
 
     // 按模型统计
     if (!dailyStats.byModel[modelKey]) {
@@ -397,10 +517,16 @@ function recordRequest(requestData) {
     }
     updateStats(dailyStats.byModel[modelKey], tokens, cost);
 
-    saveDailyStats(date, dailyStats);
 
     // Invalidate cached trend results that cover this date
     invalidateTrendCacheForDate(date);
+    pendingEntries.push({ logEntry, date });
+    if (pendingEntries.length >= 1000) {
+      console.error('[Statistics] Write queue reached its limit; flushing immediately');
+      void flushStatistics();
+    } else {
+      scheduleStatisticsFlush();
+    }
   } catch (err) {
     console.error('[Statistics] Failed to record request:', err);
   }
@@ -410,14 +536,14 @@ function recordRequest(requestData) {
  * 获取统计数据
  */
 function getStatistics() {
-  return loadStatistics();
+  return aggregateStatsCache ? cloneJson(aggregateStatsCache) : loadStatistics();
 }
 
 /**
  * 获取每日统计
  */
 function getDailyStatistics(date) {
-  return aggregateDailyStatistics(date);
+  return aggregateDailyStatistics(date, dailyStatsCache.get(date) || null);
 }
 
 /**
@@ -425,7 +551,7 @@ function getDailyStatistics(date) {
  */
 function getTodayStatistics() {
   const today = getCSTDateStr(Date.now());
-  return aggregateDailyStatistics(today);
+  return getDailyStatistics(today);
 }
 
 /**
@@ -448,6 +574,35 @@ function extractMetric(stats, metric) {
  * @param {string} groupBy
  * @param {Object} [filters] - optional { toolType, channel, model }
  */
+function addLogEntryToResult(result, entry, groupBy, filters = null) {
+  const actualModel = resolveActualModel(entry.model, entry);
+  if (filters) {
+    if (filters.toolType && entry.toolType !== filters.toolType) return;
+    if (filters.channel && entry.channel !== filters.channel) return;
+    if (filters.model && actualModel !== filters.model) return;
+  }
+
+  let key;
+  if (groupBy === 'model') key = actualModel || 'unknown';
+  else if (groupBy === 'channel') key = entry.channel || entry.channelId || 'unknown';
+  else if (groupBy === 'toolType') key = entry.toolType || 'claude-code';
+  else return;
+
+  if (!result[key]) result[key] = { tokens: { total: 0 }, cost: 0, requests: 0 };
+  result[key].tokens.total += getTokenTotal(entry.tokens);
+  result[key].cost += entry.cost || 0;
+  result[key].requests += 1;
+}
+
+function mergePendingLogEntries(result, dateStr, hour, groupBy, filters = null) {
+  for (const { logEntry } of pendingEntries) {
+    const timestamp = new Date(logEntry.timestamp);
+    if (getCSTDateStr(timestamp) !== dateStr) continue;
+    if (hour !== undefined && getCSTHour(timestamp) !== hour) continue;
+    addLogEntryToResult(result, logEntry, groupBy, filters);
+  }
+}
+
 function readJsonlForHour(year, month, day, hour, groupBy, filters) {
   const filePath = getRequestLogFilePath(year, month, day);
   const result = {};
@@ -488,6 +643,8 @@ function readJsonlForHour(year, month, day, hour, groupBy, filters) {
     console.error('Failed to read JSONL for hour:', err);
   }
 
+  const dateStr = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+  mergePendingLogEntries(result, dateStr, hour, groupBy, filters);
   return result;
 }
 
@@ -536,6 +693,8 @@ function readJsonlForDay(year, month, day, groupBy, filters) {
     console.error('Failed to read JSONL for day:', err);
   }
 
+  const dateStr = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+  mergePendingLogEntries(result, dateStr, undefined, groupBy, filters);
   return result;
 }
 
@@ -629,7 +788,22 @@ const TOOL_PREFIXES = {
 function getTokenTotal(tokens) {
   if (typeof tokens === 'number') return tokens;
   if (tokens && typeof tokens === 'object') {
-    if (typeof tokens.total === 'number') return tokens.total;
+    if (typeof tokens.total === 'number' && tokens.total > 0) return tokens.total;
+
+    // Token detail fields overlap: cached/reasoning tokens are usually
+    // sub-counts of input/output. The canonical shape stores cached input
+    // separately, so include it once and never add reasoning independently.
+    const usageKeys = ['input', 'output', 'cacheCreation', 'cacheRead', 'cached'];
+    if (usageKeys.some(key => typeof tokens[key] === 'number')) {
+      const input = typeof tokens.input === 'number' ? tokens.input : 0;
+      const output = typeof tokens.output === 'number' ? tokens.output : 0;
+      const cacheCreation = typeof tokens.cacheCreation === 'number' ? tokens.cacheCreation : 0;
+      const cacheRead = typeof tokens.cacheRead === 'number'
+        ? tokens.cacheRead
+        : (typeof tokens.cached === 'number' ? tokens.cached : 0);
+      return input + output + cacheCreation + cacheRead;
+    }
+
     return Object.entries(tokens).reduce((sum, [key, value]) => {
       if (key === 'total') return sum;
       return typeof value === 'number' ? sum + value : sum;
@@ -725,7 +899,7 @@ function hasStatsData(stats = {}) {
   return requests > 0 || cost > 0 || totalTokens > 0;
 }
 
-function aggregateDailyStatistics(dateStr) {
+function aggregateDailyStatistics(dateStr, sharedStatsOverride = null) {
   const aggregated = {
     date: dateStr,
     summary: {
@@ -739,7 +913,7 @@ function aggregateDailyStatistics(dateStr) {
     byModel: {}
   };
 
-  const sharedStats = loadDailyStats(dateStr);
+  const sharedStats = sharedStatsOverride || loadDailyStats(dateStr);
   const sharedSummaryEntry = createEmptyEntry();
   mergeStatsEntry(sharedSummaryEntry, {
     requests: sharedStats.summary?.requests || 0,
@@ -814,7 +988,7 @@ function aggregateDailyStatistics(dateStr) {
 function mergeAllToolsDailyStats(dateStr, groupBy) {
   const merged = {};
 
-  const aggregated = aggregateDailyStatistics(dateStr);
+  const aggregated = aggregateDailyStatistics(dateStr, dailyStatsCache.get(dateStr) || null);
   if (!aggregated) return merged;
 
   if (groupBy === 'toolType') {
@@ -891,6 +1065,13 @@ function getAvailableFilters(startDate, endDate) {
     }
   }
 
+for (const { logEntry, date } of pendingEntries) {
+  if (date < startDate || date > endDate) continue;
+  if (logEntry.toolType) toolTypes.add(logEntry.toolType);
+  if (logEntry.channel) channels.add(logEntry.channel);
+  const actualModel = resolveActualModel(logEntry.model, logEntry);
+  if (actualModel) models.add(actualModel);
+}
   if (includeProxyLogs) {
     for (const entry of loadProxyLogs()) {
       if (!entry || entry.type === 'action' || entry.status === 'error') continue;
@@ -1029,7 +1210,7 @@ async function getTrendStatistics({ startDate, endDate, granularity = 'day', ste
             if (activeFilters) {
               byDimension = readJsonlForHour(year, month, day, hh, groupBy, activeFilters);
             } else if (groupBy === 'toolType') {
-              const dailyStats = aggregateDailyStatistics(dateStr);
+              const dailyStats = aggregateDailyStatistics(dateStr, dailyStatsCache.get(dateStr) || null);
               const hourData = dailyStats?.hourly?.[hhStr];
               for (const [toolType, toolStats] of Object.entries(hourData?.byToolType || {})) {
                 if (!hasStatsData(toolStats)) continue;
@@ -1095,5 +1276,7 @@ module.exports = {
   getDailyStatistics,
   getTodayStatistics,
   getTrendStatistics,
-  getAvailableFilters
+  getAvailableFilters,
+  flushStatistics,
+  shutdownStatistics
 };