codex-devtools 0.1.11 → 0.2.1

package/dist-electron/main/chunks/{CodexServiceContext-CRkTP14W.cjs → CodexServiceContext-DaxLI918.cjs}

@@ -1,5 +1,6 @@
 "use strict";
 const fs = require("node:fs");
+const node_crypto = require("node:crypto");
 const path = require("node:path");
 const node_buffer = require("node:buffer");
 const os = require("node:os");
@@ -34,6 +35,12 @@ const createLogger = (scope) => {
     debug: (message, ...args) => console.debug(prefix, message, ...args)
   };
 };
+const DEFAULT_CODEX_DEVTOOLS_CONFIG_PATH = path__namespace.join(
+  os__namespace.homedir(),
+  ".config",
+  "codex-devtools",
+  "config.json"
+);
 const DEFAULT_CONFIG = {
   general: {
     launchAtLogin: false,
@@ -66,7 +73,7 @@ function deepMerge(target, source) {
   return output;
 }
 class ConfigManager {
-  constructor(configPath = path__namespace.join(os__namespace.homedir(), ".config", "codex-devtools", "config.json")) {
+  constructor(configPath = DEFAULT_CODEX_DEVTOOLS_CONFIG_PATH) {
     this.configPath = configPath;
     this.config = this.loadConfig();
   }
@@ -117,68 +124,68 @@ class ConfigManager {
     fs__namespace.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf8");
   }
 }
-function isRecord(value) {
+function isRecord$2(value) {
   return typeof value === "object" && value !== null;
 }
-function isString(value) {
+function isString$2(value) {
   return typeof value === "string";
 }
 function hasString(obj, key) {
-  return isString(obj[key]);
+  return isString$2(obj[key]);
 }
 function hasOptionalString(obj, key) {
-  return !(key in obj) || isString(obj[key]);
+  return !(key in obj) || isString$2(obj[key]);
 }
 function hasOptionalRecord(obj, key) {
-  return !(key in obj) || isRecord(obj[key]);
+  return !(key in obj) || isRecord$2(obj[key]);
 }
 function getContentBlockText(block) {
   if (!("text" in block)) {
     return "";
   }
-  return isString(block.text) ? block.text : "";
+  return isString$2(block.text) ? block.text : "";
 }
 function isReasoningSummaryText(value) {
-  return isRecord(value) && hasString(value, "text");
+  return isRecord$2(value) && hasString(value, "text");
 }
 function reasoningSummaryItemToText(item) {
-  return isString(item) ? item : item.text;
+  return isString$2(item) ? item : item.text;
 }
 function reasoningSummaryToText(summary) {
   return summary.map(reasoningSummaryItemToText);
 }
 function isContentBlockInputText(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "input_text" && hasString(value, "text");
 }
 function isContentBlockOutputText(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "output_text" && hasString(value, "text");
 }
 function isContentBlockInputImage(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "input_image" && hasString(value, "image_url");
 }
 function isContentBlockUnknown(value) {
-  if (!isRecord(value) || !hasString(value, "type")) {
+  if (!isRecord$2(value) || !hasString(value, "type")) {
     return false;
   }
   if (value.type === "input_text" || value.type === "output_text" || value.type === "input_image") {
     return false;
   }
-  return !("text" in value) || isString(value.text);
+  return !("text" in value) || isString$2(value.text);
 }
 function isContentBlock(value) {
   return isContentBlockInputText(value) || isContentBlockOutputText(value) || isContentBlockInputImage(value) || isContentBlockUnknown(value);
 }
 function isMessagePayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   if (value.type !== "message" || value.role !== "developer" && value.role !== "user" && value.role !== "assistant") {
@@ -190,70 +197,70 @@ function isMessagePayload(value) {
   return value.content.every(isContentBlock);
 }
 function isFunctionCallPayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "function_call" && hasString(value, "name") && hasString(value, "arguments") && hasString(value, "call_id");
 }
 function isFunctionCallOutputPayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "function_call_output" && hasString(value, "call_id") && hasString(value, "output");
 }
 function isReasoningPayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   if (value.type !== "reasoning" || !Array.isArray(value.summary)) {
     return false;
   }
-  if (!value.summary.every((item) => isString(item) || isReasoningSummaryText(item))) {
+  if (!value.summary.every((item) => isString$2(item) || isReasoningSummaryText(item))) {
     return false;
   }
-  return !("encrypted_content" in value) || isString(value.encrypted_content) || value.encrypted_content === null;
+  return !("encrypted_content" in value) || isString$2(value.encrypted_content) || value.encrypted_content === null;
 }
 function isResponseItemPayload(value) {
   return isMessagePayload(value) || isFunctionCallPayload(value) || isFunctionCallOutputPayload(value) || isReasoningPayload(value);
 }
 function isTokenUsage(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return typeof value.input_tokens === "number" && typeof value.cached_input_tokens === "number" && typeof value.output_tokens === "number" && typeof value.reasoning_output_tokens === "number" && typeof value.total_tokens === "number";
 }
 function isTokenCountPayload(value) {
-  if (!isRecord(value) || value.type !== "token_count") {
+  if (!isRecord$2(value) || value.type !== "token_count") {
     return false;
   }
   if (value.info === null) {
     return true;
   }
-  if (!isRecord(value.info)) {
+  if (!isRecord$2(value.info)) {
     return false;
   }
   return isTokenUsage(value.info.total_token_usage) && isTokenUsage(value.info.last_token_usage) && typeof value.info.model_context_window === "number";
 }
 function isAgentReasoningPayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "agent_reasoning" && hasString(value, "text");
 }
 function isAgentMessagePayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "agent_message" && hasString(value, "message");
 }
 function isUserMessagePayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "user_message" && hasString(value, "message");
 }
 function isContextCompactedPayload(value) {
-  if (!isRecord(value)) {
+  if (!isRecord$2(value)) {
     return false;
   }
   return value.type === "context_compacted";
@@ -262,10 +269,10 @@ function isEventMsgPayload(value) {
   return isTokenCountPayload(value) || isAgentReasoningPayload(value) || isAgentMessagePayload(value) || isUserMessagePayload(value) || isContextCompactedPayload(value);
 }
 function isSessionMetaEntry(value) {
-  if (!isRecord(value) || value.type !== "session_meta" || !hasString(value, "timestamp")) {
+  if (!isRecord$2(value) || value.type !== "session_meta" || !hasString(value, "timestamp")) {
     return false;
   }
-  if (!isRecord(value.payload)) {
+  if (!isRecord$2(value.payload)) {
     return false;
   }
   if (!hasOptionalString(value.payload, "id") || !hasOptionalString(value.payload, "cwd") || !hasOptionalString(value.payload, "originator") || !hasOptionalString(value.payload, "cli_version") || !hasOptionalString(value.payload, "model_provider") || !hasOptionalString(value.payload, "model")) {
@@ -273,14 +280,14 @@ function isSessionMetaEntry(value) {
   }
   if ("base_instructions" in value.payload) {
     const baseInstructions = value.payload.base_instructions;
-    if (!isString(baseInstructions) && !isRecord(baseInstructions)) {
+    if (!isString$2(baseInstructions) && !isRecord$2(baseInstructions)) {
       return false;
     }
   }
   if (!hasOptionalRecord(value.payload, "git")) {
     return false;
   }
-  if (isRecord(value.payload.git)) {
+  if (isRecord$2(value.payload.git)) {
     if (!hasOptionalString(value.payload.git, "commit_hash") || !hasOptionalString(value.payload.git, "branch") || !hasOptionalString(value.payload.git, "repository_url")) {
       return false;
     }
@@ -288,55 +295,55 @@ function isSessionMetaEntry(value) {
   return hasString(value.payload, "id") || hasString(value.payload, "cwd");
 }
 function isResponseItemEntry(value) {
-  if (!isRecord(value) || value.type !== "response_item" || !hasString(value, "timestamp")) {
+  if (!isRecord$2(value) || value.type !== "response_item" || !hasString(value, "timestamp")) {
     return false;
   }
   return isResponseItemPayload(value.payload);
 }
 function isTurnContextEntry(value) {
-  if (!isRecord(value) || value.type !== "turn_context" || !hasString(value, "timestamp")) {
+  if (!isRecord$2(value) || value.type !== "turn_context" || !hasString(value, "timestamp")) {
     return false;
   }
-  if (!isRecord(value.payload)) {
+  if (!isRecord$2(value.payload)) {
     return false;
   }
   if (!hasOptionalString(value.payload, "turn_id") || !hasOptionalString(value.payload, "cwd") || !hasOptionalString(value.payload, "approval_policy") || !hasOptionalString(value.payload, "model") || !hasOptionalString(value.payload, "personality") || !hasOptionalString(value.payload, "effort") || !hasOptionalString(value.payload, "summary") || !hasOptionalString(value.payload, "user_instructions")) {
     return false;
   }
   const sandboxPolicy = value.payload.sandbox_policy;
-  if ("sandbox_policy" in value.payload && !(isString(sandboxPolicy) || isRecord(sandboxPolicy))) {
+  if ("sandbox_policy" in value.payload && !(isString$2(sandboxPolicy) || isRecord$2(sandboxPolicy))) {
     return false;
   }
   const collaborationMode = value.payload.collaboration_mode;
-  if ("collaboration_mode" in value.payload && !(isString(collaborationMode) || isRecord(collaborationMode))) {
+  if ("collaboration_mode" in value.payload && !(isString$2(collaborationMode) || isRecord$2(collaborationMode))) {
     return false;
   }
   const truncationPolicy = value.payload.truncation_policy;
-  if ("truncation_policy" in value.payload && !(isString(truncationPolicy) || isRecord(truncationPolicy))) {
+  if ("truncation_policy" in value.payload && !(isString$2(truncationPolicy) || isRecord$2(truncationPolicy))) {
     return false;
   }
   return hasString(value.payload, "cwd") || hasString(value.payload, "model");
 }
 function isEventMsgEntry(value) {
-  if (!isRecord(value) || value.type !== "event_msg" || !hasString(value, "timestamp")) {
+  if (!isRecord$2(value) || value.type !== "event_msg" || !hasString(value, "timestamp")) {
     return false;
   }
   return isEventMsgPayload(value.payload);
 }
 function isCompactedEntry(value) {
-  if (!isRecord(value) || value.type !== "compacted" || !hasString(value, "timestamp")) {
+  if (!isRecord$2(value) || value.type !== "compacted" || !hasString(value, "timestamp")) {
     return false;
   }
-  return isRecord(value.payload);
+  return isRecord$2(value.payload);
 }
 function isCompactionEntry(value) {
-  if (!isRecord(value) || value.type !== "compaction" || !hasString(value, "timestamp")) {
+  if (!isRecord$2(value) || value.type !== "compaction" || !hasString(value, "timestamp")) {
     return false;
   }
-  if ("payload" in value && !isRecord(value.payload)) {
+  if ("payload" in value && !isRecord$2(value.payload)) {
     return false;
   }
-  if ("encrypted_content" in value && !(isString(value.encrypted_content) || value.encrypted_content === null)) {
+  if ("encrypted_content" in value && !(isString$2(value.encrypted_content) || value.encrypted_content === null)) {
     return false;
   }
   return true;
@@ -354,6 +361,40 @@ const EMPTY_CODEX_SESSION_METRICS = {
   toolCallCount: 0,
   duration: 0
 };
+function diffTokenUsage(previous, current) {
+  const delta = {
+    input_tokens: current.input_tokens - previous.input_tokens,
+    cached_input_tokens: current.cached_input_tokens - previous.cached_input_tokens,
+    output_tokens: current.output_tokens - previous.output_tokens,
+    reasoning_output_tokens: current.reasoning_output_tokens - previous.reasoning_output_tokens,
+    total_tokens: current.total_tokens - previous.total_tokens
+  };
+  const normalized = {
+    input_tokens: Math.max(delta.input_tokens, 0),
+    cached_input_tokens: Math.max(delta.cached_input_tokens, 0),
+    output_tokens: Math.max(delta.output_tokens, 0),
+    reasoning_output_tokens: Math.max(delta.reasoning_output_tokens, 0),
+    total_tokens: Math.max(delta.total_tokens, 0)
+  };
+  const hasAnyPositive = normalized.input_tokens > 0 || normalized.cached_input_tokens > 0 || normalized.output_tokens > 0 || normalized.reasoning_output_tokens > 0 || normalized.total_tokens > 0;
+  return hasAnyPositive ? normalized : null;
+}
+function isSameTokenUsage(left, right) {
+  return left.input_tokens === right.input_tokens && left.cached_input_tokens === right.cached_input_tokens && left.output_tokens === right.output_tokens && left.reasoning_output_tokens === right.reasoning_output_tokens && left.total_tokens === right.total_tokens;
+}
+function resolveTokenUsage(previousTotalUsage, currentTotalUsage, fallbackUsage) {
+  if (!previousTotalUsage) {
+    return fallbackUsage;
+  }
+  const delta = diffTokenUsage(previousTotalUsage, currentTotalUsage);
+  if (delta) {
+    return delta;
+  }
+  if (isSameTokenUsage(previousTotalUsage, currentTotalUsage)) {
+    return null;
+  }
+  return fallbackUsage;
+}
 const AGENTS_HEADING_PATTERN = /^#?\s*AGENTS\.md instructions\b/i;
 const AGENTS_INSTRUCTIONS_BLOCK_PATTERN = /<INSTRUCTIONS>[\s\S]*<\/INSTRUCTIONS>/i;
 const ENVIRONMENT_CONTEXT_WRAPPER_PATTERN = /^<environment_context>[\s\S]*<\/environment_context>$/i;
@@ -737,10 +778,10 @@ function pickPreferredEquivalentUserContent(pending, incoming) {
   }
   return pending;
 }
-function normalizeModel$2(model) {
+function normalizeModel$3(model) {
   return model?.trim() ?? "";
 }
-function normalizeReasoningEffort$2(effort) {
+function normalizeReasoningEffort$3(effort) {
   const value = effort?.trim();
   return value ? value : "unknown";
 }
@@ -997,6 +1038,7 @@ class CodexChunkBuilder {
     let pendingUser = null;
     let lastSeenModelUsage = null;
     let lastSeenCollaborationMode = "";
+    let previousTotalUsage = null;
     const flushAIChunk = () => {
       if (!currentAI) {
         return;
@@ -1077,11 +1119,11 @@ class CodexChunkBuilder {
         continue;
       }
       if (isTurnContextEntry(entry)) {
-        const model = normalizeModel$2(entry.payload.model);
+        const model = normalizeModel$3(entry.payload.model);
         if (model) {
           const usage = {
             model,
-            reasoningEffort: normalizeReasoningEffort$2(entry.payload.effort)
+            reasoningEffort: normalizeReasoningEffort$3(entry.payload.effort)
           };
           if (lastSeenModelUsage === null) {
             lastSeenModelUsage = usage;
@@ -1251,30 +1293,33 @@ class CodexChunkBuilder {
         addReasoningSection(ai, "event", [entry.payload.text]);
         continue;
       }
-      if (isEventMsgEntry(entry) && isTokenCountPayload(entry.payload)) {
-        this.accumulateMetricsFromTokenEvent(ai.metrics, entry);
-        this.assignTokenUsageToPendingTool(ai, entry);
+      if (isEventMsgEntry(entry) && isTokenCountPayload(entry.payload) && entry.payload.info) {
+        const currentTotalUsage = entry.payload.info.total_token_usage;
+        const usage = resolveTokenUsage(
+          previousTotalUsage,
+          currentTotalUsage,
+          entry.payload.info.last_token_usage
+        );
+        previousTotalUsage = currentTotalUsage;
+        if (!usage) {
+          continue;
+        }
+        this.accumulateMetricsFromTokenUsage(ai.metrics, usage);
+        this.assignTokenUsageToPendingTool(ai, usage);
       }
     }
     flushPendingEventUser();
     flushAIChunk();
     return chunks;
   }
-  accumulateMetricsFromTokenEvent(target, entry) {
-    if (!isTokenCountPayload(entry.payload) || !entry.payload.info) {
-      return;
-    }
-    const usage = entry.payload.info.last_token_usage;
+  accumulateMetricsFromTokenUsage(target, usage) {
     target.inputTokens = (target.inputTokens ?? 0) + usage.input_tokens;
     target.cachedTokens = (target.cachedTokens ?? 0) + usage.cached_input_tokens;
     target.outputTokens = (target.outputTokens ?? 0) + usage.output_tokens;
     target.reasoningTokens = (target.reasoningTokens ?? 0) + usage.reasoning_output_tokens;
     target.totalTokens = (target.totalTokens ?? 0) + usage.total_tokens;
   }
-  assignTokenUsageToPendingTool(ai, entry) {
-    if (!isTokenCountPayload(entry.payload) || !entry.payload.info) {
-      return;
-    }
+  assignTokenUsageToPendingTool(ai, usage) {
     if (ai.pendingUsageToolIndex === null) {
       return;
     }
@@ -1283,20 +1328,399 @@ class CodexChunkBuilder {
       ai.pendingUsageToolIndex = null;
       return;
     }
-    const usage = entry.payload.info.last_token_usage;
     if (tool.tokenUsage) {
       tool.tokenUsage.inputTokens += usage.input_tokens;
+      tool.tokenUsage.cachedInputTokens += usage.cached_input_tokens;
       tool.tokenUsage.outputTokens += usage.output_tokens;
     } else {
       tool.tokenUsage = {
         inputTokens: usage.input_tokens,
+        cachedInputTokens: usage.cached_input_tokens,
         outputTokens: usage.output_tokens
       };
     }
     ai.pendingUsageToolIndex = null;
   }
 }
-const logger$2 = createLogger("Main:jsonl");
+function normalizeRateKey(model) {
+  return model.trim().toLowerCase();
+}
+function createZeroTokenTotals() {
+  return {
+    totalTokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedTokens: 0,
+    reasoningTokens: 0
+  };
+}
+function addTokenTotals(target, source) {
+  target.totalTokens += source.totalTokens;
+  target.inputTokens += source.inputTokens;
+  target.outputTokens += source.outputTokens;
+  target.cachedTokens += source.cachedTokens;
+  target.reasoningTokens += source.reasoningTokens;
+}
+function tokenUsageToTotals(usage) {
+  return {
+    totalTokens: usage.total_tokens,
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cachedTokens: usage.cached_input_tokens,
+    reasoningTokens: usage.reasoning_output_tokens
+  };
+}
+function parseTimestamp(timestamp) {
+  const value = new Date(timestamp);
+  return Number.isNaN(value.getTime()) ? null : value;
+}
+function localDateKey(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function localHour(date) {
+  return date.getHours();
+}
+function ensureDailyBucket(buckets, date) {
+  const existing = buckets.get(date);
+  if (existing) {
+    return existing;
+  }
+  const next = {
+    date,
+    eventCount: 0,
+    ...createZeroTokenTotals()
+  };
+  buckets.set(date, next);
+  return next;
+}
+function ensureHourlyBucket(buckets, hour) {
+  const existing = buckets.get(hour);
+  if (existing) {
+    return existing;
+  }
+  const next = {
+    hour,
+    eventCount: 0,
+    ...createZeroTokenTotals()
+  };
+  buckets.set(hour, next);
+  return next;
+}
+function ensureModelBucket(buckets, model, reasoningEffort) {
+  const key = `${normalizeRateKey(model)}::${normalizeReasoningEffort$2(reasoningEffort)}`;
+  const existing = buckets.get(key);
+  if (existing) {
+    return existing;
+  }
+  const next = {
+    model,
+    reasoningEffort,
+    ...createZeroTokenTotals()
+  };
+  buckets.set(key, next);
+  return next;
+}
+function estimateUsageCostUsd(tokens, rate) {
+  const nonReasoningOutput = Math.max(tokens.outputTokens - tokens.reasoningTokens, 0);
+  const outputCost = nonReasoningOutput / 1e6 * rate.outputUsdPer1M;
+  const reasoningCost = tokens.reasoningTokens / 1e6 * rate.reasoningOutputUsdPer1M;
+  return tokens.inputTokens / 1e6 * rate.inputUsdPer1M + tokens.cachedTokens / 1e6 * rate.cachedInputUsdPer1M + outputCost + reasoningCost;
+}
+function buildRateLookup(rateCard) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const rate of rateCard.models) {
+    lookup.set(normalizeRateKey(rate.model), rate);
+  }
+  return lookup;
+}
+function buildHourlyResult(hourly) {
+  const result = [];
+  for (let hour = 0; hour <= 23; hour += 1) {
+    const current = hourly.get(hour);
+    if (!current) {
+      result.push({
+        hour,
+        eventCount: 0,
+        sessionCount: 0,
+        ...createZeroTokenTotals()
+      });
+      continue;
+    }
+    result.push({
+      hour,
+      eventCount: current.eventCount,
+      sessionCount: current.sessions.size,
+      totalTokens: current.totalTokens,
+      inputTokens: current.inputTokens,
+      outputTokens: current.outputTokens,
+      cachedTokens: current.cachedTokens,
+      reasoningTokens: current.reasoningTokens
+    });
+  }
+  return result;
+}
+function normalizeModel$2(model) {
+  const trimmed = model?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : "unknown-model";
+}
+function normalizeReasoningEffort$2(reasoningEffort) {
+  const trimmed = reasoningEffort?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : "unknown";
+}
+function buildSessionStatsRecord(parsed, revision, nowIso) {
+  const dailyBuckets = /* @__PURE__ */ new Map();
+  const hourlyBuckets = /* @__PURE__ */ new Map();
+  const modelBuckets = /* @__PURE__ */ new Map();
+  const tokens = createZeroTokenTotals();
+  let eventCount = 0;
+  let currentModel = normalizeModel$2(parsed.session.model || parsed.sessionMeta?.payload.model);
+  let currentReasoningEffort = "unknown";
+  let previousTotalUsage = null;
+  for (const modelUsage of parsed.session.modelUsages) {
+    if (modelUsage.model) {
+      currentModel = normalizeModel$2(modelUsage.model);
+      currentReasoningEffort = normalizeReasoningEffort$2(modelUsage.reasoningEffort);
+      break;
+    }
+  }
+  for (const entry of parsed.entries) {
+    if (isTurnContextEntry(entry)) {
+      if (entry.payload.model) {
+        currentModel = normalizeModel$2(entry.payload.model);
+      }
+      currentReasoningEffort = normalizeReasoningEffort$2(entry.payload.effort);
+      continue;
+    }
+    if (!isEventMsgEntry(entry) || !isTokenCountPayload(entry.payload) || !entry.payload.info) {
+      continue;
+    }
+    const timestamp = parseTimestamp(entry.timestamp);
+    const currentTotal = entry.payload.info.total_token_usage;
+    const usage = resolveTokenUsage(previousTotalUsage, currentTotal, entry.payload.info.last_token_usage);
+    previousTotalUsage = currentTotal;
+    if (!usage) {
+      continue;
+    }
+    const usageTotals = tokenUsageToTotals(usage);
+    addTokenTotals(tokens, usageTotals);
+    const modelTotals = ensureModelBucket(modelBuckets, currentModel, currentReasoningEffort);
+    addTokenTotals(modelTotals, usageTotals);
+    if (!timestamp) {
+      continue;
+    }
+    const dateBucket = ensureDailyBucket(dailyBuckets, localDateKey(timestamp));
+    addTokenTotals(dateBucket, usageTotals);
+    const hourBucket = ensureHourlyBucket(hourlyBuckets, localHour(timestamp));
+    addTokenTotals(hourBucket, usageTotals);
+  }
+  for (const classifiedEntry of parsed.classifiedEntries) {
+    const timestamp = parseTimestamp(classifiedEntry.entry.timestamp);
+    if (!timestamp) {
+      continue;
+    }
+    eventCount += 1;
+    const dateBucket = ensureDailyBucket(dailyBuckets, localDateKey(timestamp));
+    dateBucket.eventCount += 1;
+    const hourBucket = ensureHourlyBucket(hourlyBuckets, localHour(timestamp));
+    hourBucket.eventCount += 1;
+  }
+  const lastActivity = parsed.entries[parsed.entries.length - 1]?.timestamp ?? parsed.session.startTime;
+  return {
+    tokenComputationVersion: 4,
+    sessionId: parsed.session.id,
+    filePath: parsed.session.filePath,
+    revision,
+    archived: false,
+    cwd: parsed.session.cwd,
+    startTime: parsed.session.startTime,
+    lastActivity,
+    modelUsages: parsed.session.modelUsages,
+    eventCount,
+    turnCount: parsed.metrics.turnCount,
+    toolCallCount: parsed.metrics.toolCallCount,
+    durationMs: parsed.metrics.duration,
+    tokens,
+    modelTokenTotals: Array.from(modelBuckets.values()).sort((a, b) => b.totalTokens - a.totalTokens),
+    dailyBuckets: Array.from(dailyBuckets.values()).sort((a, b) => a.date.localeCompare(b.date)),
+    hourlyBuckets: Array.from(hourlyBuckets.values()).sort((a, b) => a.hour - b.hour),
+    lastSeenAt: nowIso
+  };
+}
+function aggregateStatsSummary(records, scope, rateCard) {
+  const scopedRecords = records.filter((record) => {
+    if (scope.type === "all") {
+      return true;
+    }
+    return record.cwd === scope.cwd;
+  });
+  const daily = /* @__PURE__ */ new Map();
+  const hourly = /* @__PURE__ */ new Map();
+  const modelBreakdown = /* @__PURE__ */ new Map();
+  const rateLookup = buildRateLookup(rateCard);
+  const unpricedModels = /* @__PURE__ */ new Set();
+  const totals = {
+    sessions: 0,
+    archivedSessions: 0,
+    eventCount: 0,
+    durationMs: 0,
+    estimatedCostUsd: 0,
+    ...createZeroTokenTotals()
+  };
+  const costCoverage = {
+    pricedTokens: 0,
+    unpricedTokens: 0
+  };
+  for (const record of scopedRecords) {
+    totals.sessions += 1;
+    if (record.archived) {
+      totals.archivedSessions += 1;
+    }
+    totals.eventCount += record.eventCount;
+    totals.durationMs += record.durationMs;
+    addTokenTotals(totals, record.tokens);
+    for (const bucket of record.dailyBuckets) {
+      const existing = daily.get(bucket.date) ?? {
+        date: bucket.date,
+        eventCount: 0,
+        sessions: /* @__PURE__ */ new Set(),
+        ...createZeroTokenTotals()
+      };
+      existing.eventCount += bucket.eventCount;
+      addTokenTotals(existing, bucket);
+      existing.sessions.add(record.sessionId);
+      daily.set(bucket.date, existing);
+    }
+    for (const bucket of record.hourlyBuckets) {
+      const existing = hourly.get(bucket.hour) ?? {
+        hour: bucket.hour,
+        eventCount: 0,
+        sessions: /* @__PURE__ */ new Set(),
+        ...createZeroTokenTotals()
+      };
+      existing.eventCount += bucket.eventCount;
+      addTokenTotals(existing, bucket);
+      existing.sessions.add(record.sessionId);
+      hourly.set(bucket.hour, existing);
+    }
+    for (const modelTotals of record.modelTokenTotals) {
+      const rate = rateLookup.get(normalizeRateKey(modelTotals.model));
+      const modelKey = `${normalizeRateKey(modelTotals.model)}::${normalizeReasoningEffort$2(modelTotals.reasoningEffort)}`;
+      const existing = modelBreakdown.get(modelKey) ?? {
+        model: modelTotals.model,
+        reasoningEffort: modelTotals.reasoningEffort,
+        estimatedCostUsd: 0,
+        sessions: /* @__PURE__ */ new Set(),
+        archivedSessions: /* @__PURE__ */ new Set(),
+        ...createZeroTokenTotals()
+      };
+      addTokenTotals(existing, modelTotals);
+      existing.sessions.add(record.sessionId);
+      if (record.archived) {
+        existing.archivedSessions.add(record.sessionId);
+      }
+      if (rate) {
+        const usageCost = estimateUsageCostUsd(modelTotals, rate);
+        existing.estimatedCostUsd += usageCost;
+        totals.estimatedCostUsd += usageCost;
+        costCoverage.pricedTokens += modelTotals.totalTokens;
+      } else {
+        costCoverage.unpricedTokens += modelTotals.totalTokens;
+        unpricedModels.add(modelTotals.model);
+      }
+      modelBreakdown.set(modelKey, existing);
+    }
+  }
+  const dailyPoints = Array.from(daily.values()).map((bucket) => ({
+    date: bucket.date,
+    eventCount: bucket.eventCount,
+    sessionCount: bucket.sessions.size,
+    totalTokens: bucket.totalTokens,
+    inputTokens: bucket.inputTokens,
+    outputTokens: bucket.outputTokens,
+    cachedTokens: bucket.cachedTokens,
+    reasoningTokens: bucket.reasoningTokens
+  })).sort((a, b) => a.date.localeCompare(b.date));
+  const hourlyPoints = buildHourlyResult(hourly);
+  const models = Array.from(modelBreakdown.values()).map((model) => ({
+    model: model.model,
+    reasoningEffort: model.reasoningEffort,
+    sessionCount: model.sessions.size,
+    archivedSessionCount: model.archivedSessions.size,
+    estimatedCostUsd: Number(model.estimatedCostUsd.toFixed(6)),
+    totalTokens: model.totalTokens,
+    inputTokens: model.inputTokens,
+    outputTokens: model.outputTokens,
+    cachedTokens: model.cachedTokens,
+    reasoningTokens: model.reasoningTokens
+  })).sort((a, b) => b.totalTokens - a.totalTokens);
+  const reasoningMap = /* @__PURE__ */ new Map();
+  for (const model of modelBreakdown.values()) {
+    const existing = reasoningMap.get(model.reasoningEffort) ?? {
+      reasoningEffort: model.reasoningEffort,
+      estimatedCostUsd: 0,
+      sessions: /* @__PURE__ */ new Set(),
+      ...createZeroTokenTotals()
+    };
+    for (const sessionId of model.sessions) {
+      existing.sessions.add(sessionId);
+    }
+    existing.estimatedCostUsd += model.estimatedCostUsd;
+    addTokenTotals(existing, model);
+    reasoningMap.set(model.reasoningEffort, existing);
+  }
+  const reasoningEfforts = Array.from(reasoningMap.values()).map((reasoning) => ({
+    reasoningEffort: reasoning.reasoningEffort,
+    sessionCount: reasoning.sessions.size,
+    estimatedCostUsd: Number(reasoning.estimatedCostUsd.toFixed(6)),
+    totalTokens: reasoning.totalTokens,
+    inputTokens: reasoning.inputTokens,
+    outputTokens: reasoning.outputTokens,
+    cachedTokens: reasoning.cachedTokens,
+    reasoningTokens: reasoning.reasoningTokens
+  })).sort((a, b) => b.totalTokens - a.totalTokens);
+  const topDays = [...dailyPoints].sort((a, b) => b.eventCount - a.eventCount || b.totalTokens - a.totalTokens).slice(0, 5).map((day) => ({
+    date: day.date,
+    eventCount: day.eventCount,
+    sessionCount: day.sessionCount,
+    totalTokens: day.totalTokens,
+    outputTokens: day.outputTokens
+  }));
+  const topHours = [...hourlyPoints].sort((a, b) => b.eventCount - a.eventCount || b.totalTokens - a.totalTokens).slice(0, 5).map((hour) => ({
+    hour: hour.hour,
+    eventCount: hour.eventCount,
+    sessionCount: hour.sessionCount,
+    totalTokens: hour.totalTokens,
+    outputTokens: hour.outputTokens
+  }));
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "local",
+    scope,
+    totals: {
+      ...totals,
+      estimatedCostUsd: Number(totals.estimatedCostUsd.toFixed(6))
+    },
+    daily: dailyPoints,
+    hourly: hourlyPoints,
+    topDays,
+    topHours,
+    models,
+    reasoningEfforts,
+    costCoverage: {
+      pricedTokens: costCoverage.pricedTokens,
+      unpricedTokens: costCoverage.unpricedTokens,
+      unpricedModels: Array.from(unpricedModels.values()).sort((a, b) => a.localeCompare(b))
+    },
+    rates: {
+      updatedAt: rateCard.updatedAt,
+      source: rateCard.source
+    }
+  };
+}
+const logger$4 = createLogger("Main:jsonl");
 const defaultParser = (value) => value;
 function waitForStreamClose(stream) {
   if (stream.closed) {
@@ -1343,7 +1767,7 @@ async function streamJsonlFile(filePath, options) {
       } catch (error) {
         options.onError?.(error, line, lineNumber);
         if (!options.onError) {
-          logger$2.warn(`Failed to parse JSONL line ${lineNumber} in ${filePath}`, error);
+          logger$4.warn(`Failed to parse JSONL line ${lineNumber} in ${filePath}`, error);
         }
       }
     }
@@ -1384,7 +1808,7 @@ async function readFirstJsonlEntry(filePath, parser) {
           break;
         }
       } catch (error) {
-        logger$2.warn(`Failed to parse JSONL line ${lineNumber} in ${filePath}`, error);
+        logger$4.warn(`Failed to parse JSONL line ${lineNumber} in ${filePath}`, error);
       }
     }
   } finally {
@@ -1392,7 +1816,7 @@ async function readFirstJsonlEntry(filePath, parser) {
   }
   return firstEntry;
 }
-const logger$1 = createLogger("Service:CodexSessionScanner");
+const logger$3 = createLogger("Service:CodexSessionScanner");
 function isWithinDateRange(timestamp, options) {
   const current = new Date(timestamp).getTime();
   if (Number.isNaN(current)) {
@@ -1438,7 +1862,7 @@ class CodexSessionScanner {
         (value) => isSessionMetaEntry(value) ? value : null
       );
       if (!metaEntry) {
-        logger$1.warn(`Skipping session file without valid session_meta: ${filePath}`);
+        logger$3.warn(`Skipping session file without valid session_meta: ${filePath}`);
         continue;
       }
       if (!isWithinDateRange(metaEntry.timestamp, options)) {
@@ -1575,6 +1999,7 @@ class CodexSessionParser {
     let firstTimestamp = null;
     let lastTimestamp = null;
     let firstTurnContextModel = null;
+    let previousTotalUsage = null;
     const modelUsages = [];
     const modelUsageKeys = /* @__PURE__ */ new Set();
     for (const entry of entries) {
@@ -1615,7 +2040,12 @@ class CodexSessionParser {
       if (isEventMsgEntry(entry)) {
         eventMessages.push(entry);
         if (isTokenCountPayload(entry.payload) && entry.payload.info) {
-          const usage = entry.payload.info.last_token_usage;
+          const currentTotal = entry.payload.info.total_token_usage;
+          const usage = resolveTokenUsage(previousTotalUsage, currentTotal, entry.payload.info.last_token_usage);
+          previousTotalUsage = currentTotal;
+          if (!usage) {
+            continue;
+          }
           metrics.inputTokens += usage.input_tokens;
           metrics.cachedTokens += usage.cached_input_tokens;
           metrics.outputTokens += usage.output_tokens;
@@ -1713,7 +2143,7 @@ class DataCache {
     return `${cwdHash}/${sessionId}`;
   }
 }
-const logger = createLogger("Service:FileWatcher");
+const logger$2 = createLogger("Service:FileWatcher");
 const DEBOUNCE_MS = 100;
 class FileWatcher extends node_events.EventEmitter {
   constructor(sessionsPath = path__namespace.join(os__namespace.homedir(), ".codex", "sessions")) {
@@ -1739,7 +2169,7 @@ class FileWatcher extends node_events.EventEmitter {
         }
       );
     } catch (error) {
-      logger.error(`Failed to start watcher for ${this.sessionsPath}`, error);
+      logger$2.error(`Failed to start watcher for ${this.sessionsPath}`, error);
     }
   }
   stop() {
@@ -1787,10 +2217,179 @@ class FileWatcher extends node_events.EventEmitter {
     return fs__namespace.existsSync(targetPath) ? "created" : "deleted";
   }
 }
-const DETAIL_CACHE_PREFIX = "detail-v2";
-const CHUNKS_CACHE_PREFIX = "chunks-v2";
+const logger$1 = createLogger("Service:ModelRatesStore");
+const RATES_VERSION = 1;
+const BUNDLED_DEFAULT_RATES = [
+  { model: "gpt-5.2", inputUsdPer1M: 1.75, cachedInputUsdPer1M: 0.175, outputUsdPer1M: 14, reasoningOutputUsdPer1M: 14 },
+  { model: "gpt-5.1", inputUsdPer1M: 1.25, cachedInputUsdPer1M: 0.125, outputUsdPer1M: 10, reasoningOutputUsdPer1M: 10 },
+  { model: "gpt-5", inputUsdPer1M: 1.25, cachedInputUsdPer1M: 0.125, outputUsdPer1M: 10, reasoningOutputUsdPer1M: 10 },
+  { model: "gpt-5-mini", inputUsdPer1M: 0.25, cachedInputUsdPer1M: 0.025, outputUsdPer1M: 2, reasoningOutputUsdPer1M: 2 },
+  { model: "gpt-5-nano", inputUsdPer1M: 0.05, cachedInputUsdPer1M: 5e-3, outputUsdPer1M: 0.4, reasoningOutputUsdPer1M: 0.4 },
+  { model: "gpt-5.2-codex", inputUsdPer1M: 1.75, cachedInputUsdPer1M: 0.175, outputUsdPer1M: 14, reasoningOutputUsdPer1M: 14 },
+  { model: "gpt-5.1-codex-max", inputUsdPer1M: 1.25, cachedInputUsdPer1M: 0.125, outputUsdPer1M: 10, reasoningOutputUsdPer1M: 10 },
+  { model: "gpt-5.1-codex", inputUsdPer1M: 1.25, cachedInputUsdPer1M: 0.125, outputUsdPer1M: 10, reasoningOutputUsdPer1M: 10 },
+  { model: "gpt-5-codex", inputUsdPer1M: 1.25, cachedInputUsdPer1M: 0.125, outputUsdPer1M: 10, reasoningOutputUsdPer1M: 10 },
+  { model: "gpt-5.1-codex-mini", inputUsdPer1M: 0.25, cachedInputUsdPer1M: 0.025, outputUsdPer1M: 2, reasoningOutputUsdPer1M: 2 },
+  { model: "codex-mini-latest", inputUsdPer1M: 1.5, cachedInputUsdPer1M: 0.375, outputUsdPer1M: 6, reasoningOutputUsdPer1M: 6 }
+];
+const DEFAULT_RATE_CARD = {
+  updatedAt: null,
+  source: "bundled-defaults",
+  models: BUNDLED_DEFAULT_RATES,
+  warnings: ["Bundled rates may be outdated. Pricing refresh is currently disabled."]
+};
+function isRecord$1(value) {
+  return typeof value === "object" && value !== null;
+}
+function isString$1(value) {
+  return typeof value === "string";
+}
+function isFiniteNumber$1(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isCodexModelRate(value) {
+  return isRecord$1(value) && isString$1(value.model) && isFiniteNumber$1(value.inputUsdPer1M) && isFiniteNumber$1(value.cachedInputUsdPer1M) && isFiniteNumber$1(value.outputUsdPer1M) && isFiniteNumber$1(value.reasoningOutputUsdPer1M);
+}
+function isRatesFile(value) {
+  return isRecord$1(value) && isFiniteNumber$1(value.version) && (value.updatedAt === null || isString$1(value.updatedAt)) && (value.source === null || isString$1(value.source)) && Array.isArray(value.models) && value.models.every(isCodexModelRate) && Array.isArray(value.warnings) && value.warnings.every(isString$1);
+}
+function cloneRateCard(card) {
+  return structuredClone(card);
+}
+class ModelRatesStore {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async getRateCard() {
+    const file = await this.readRateFile();
+    return {
+      updatedAt: file.updatedAt,
+      source: file.source,
+      models: file.models,
+      warnings: file.warnings
+    };
+  }
+  async refreshFromPricingPage() {
+    const current = await this.getRateCard();
+    return {
+      ...current,
+      warnings: [...current.warnings, "Pricing refresh is disabled in this build."],
+      refreshed: false
+    };
+  }
+  async readRateFile() {
+    try {
+      const raw = await fs.promises.readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!isRatesFile(parsed) || parsed.version !== RATES_VERSION) {
+        return {
+          version: RATES_VERSION,
+          updatedAt: DEFAULT_RATE_CARD.updatedAt,
+          source: DEFAULT_RATE_CARD.source,
+          models: cloneRateCard(DEFAULT_RATE_CARD).models,
+          warnings: [...DEFAULT_RATE_CARD.warnings]
+        };
+      }
+      return parsed;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        logger$1.warn("Failed to load model rates, falling back to bundled defaults", error);
+      }
+      return {
+        version: RATES_VERSION,
+        updatedAt: DEFAULT_RATE_CARD.updatedAt,
+        source: DEFAULT_RATE_CARD.source,
+        models: cloneRateCard(DEFAULT_RATE_CARD).models,
+        warnings: [...DEFAULT_RATE_CARD.warnings]
+      };
+    }
+  }
+}
+const logger = createLogger("Service:StatsSnapshotStore");
+const SNAPSHOT_VERSION = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isTokenTotals(value) {
+  return isRecord(value) && isFiniteNumber(value.totalTokens) && isFiniteNumber(value.inputTokens) && isFiniteNumber(value.outputTokens) && isFiniteNumber(value.cachedTokens) && isFiniteNumber(value.reasoningTokens);
+}
+function isDailyBucket(value) {
+  return isRecord(value) && isString(value.date) && isFiniteNumber(value.eventCount) && isTokenTotals(value);
+}
+function isHourlyBucket(value) {
+  return isRecord(value) && isFiniteNumber(value.hour) && isFiniteNumber(value.eventCount) && isTokenTotals(value);
+}
+function isModelTotals(value) {
+  return isRecord(value) && isString(value.model) && isString(value.reasoningEffort) && isTokenTotals(value);
+}
+function isSessionModelUsage(value) {
+  return isRecord(value) && isString(value.model) && isString(value.reasoningEffort);
+}
+function isSessionRecord(value) {
+  return isRecord(value) && (!("tokenComputationVersion" in value) || isFiniteNumber(value.tokenComputationVersion)) && isString(value.sessionId) && isString(value.filePath) && isString(value.revision) && typeof value.archived === "boolean" && isString(value.cwd) && isString(value.startTime) && isString(value.lastActivity) && isFiniteNumber(value.eventCount) && isFiniteNumber(value.turnCount) && isFiniteNumber(value.toolCallCount) && isFiniteNumber(value.durationMs) && Array.isArray(value.modelUsages) && value.modelUsages.every(isSessionModelUsage) && isTokenTotals(value.tokens) && Array.isArray(value.modelTokenTotals) && value.modelTokenTotals.every(isModelTotals) && Array.isArray(value.dailyBuckets) && value.dailyBuckets.every(isDailyBucket) && Array.isArray(value.hourlyBuckets) && value.hourlyBuckets.every(isHourlyBucket) && isString(value.lastSeenAt);
+}
+function isSnapshotFile(value) {
+  return isRecord(value) && isFiniteNumber(value.version) && Array.isArray(value.sessions) && value.sessions.every(isSessionRecord);
+}
+function cloneSessions(rows) {
+  return structuredClone(rows);
+}
+class StatsSnapshotStore {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async getSessions() {
+    const snapshot = await this.readSnapshot();
+    return cloneSessions(snapshot.sessions);
+  }
+  async saveSessions(rows) {
+    const snapshot = {
+      version: SNAPSHOT_VERSION,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sessions: cloneSessions(rows)
+    };
+    const directory = path__namespace.dirname(this.filePath);
+    await fs.promises.mkdir(directory, { recursive: true });
+    const tempPath = `${this.filePath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.promises.writeFile(tempPath, JSON.stringify(snapshot, null, 2), "utf8");
+    await fs.promises.rename(tempPath, this.filePath);
+  }
+  async readSnapshot() {
+    try {
+      const raw = await fs.promises.readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!isSnapshotFile(parsed) || parsed.version !== SNAPSHOT_VERSION) {
+        return {
+          version: SNAPSHOT_VERSION,
+          updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+          sessions: []
+        };
+      }
+      return parsed;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        logger.warn("Failed to read stats snapshot, using empty snapshot", error);
+      }
+      return {
+        version: SNAPSHOT_VERSION,
+        updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+        sessions: []
+      };
+    }
+  }
+}
+const DETAIL_CACHE_PREFIX = "detail-v3";
+const CHUNKS_CACHE_PREFIX = "chunks-v4";
 const SESSIONS_CACHE_PREFIX = "sessions";
+const STATS_CACHE_PREFIX = "stats-v3";
 const UNKNOWN_REVISION = "unknown-revision";
+const TOKEN_COMPUTATION_VERSION = 4;
 function hasCompactionSignals(entries) {
   return entries.some(
     (entry) => isCompactedEntry(entry) || isCompactionEntry(entry) || isEventMsgEntry(entry) && isContextCompactedPayload(entry.payload)
@@ -1857,15 +2456,53 @@ function buildProjectsFromSessions(sessions) {
     (a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime()
   );
 }
+function normalizeStatsScope(scope) {
+  if (!scope || scope.type === "all") {
+    return { type: "all" };
+  }
+  const cwd = scope.cwd?.trim();
+  if (!cwd) {
+    return { type: "all" };
+  }
+  return {
+    type: "project",
+    cwd
+  };
+}
+function serializeStatsScope(scope) {
+  if (scope.type === "all") {
+    return "all";
+  }
+  return `project:${scope.cwd}`;
+}
+function buildStatsSessionSignature(sessions, revisionByFilePath) {
+  const hash = node_crypto.createHash("sha1");
+  const sortedSessions = [...sessions].sort(
+    (left, right) => left.filePath.localeCompare(right.filePath) || left.id.localeCompare(right.id)
+  );
+  for (const session of sortedSessions) {
+    hash.update(session.id);
+    hash.update("\0");
+    hash.update(session.filePath);
+    hash.update("\0");
+    hash.update(revisionByFilePath.get(session.filePath) ?? UNKNOWN_REVISION);
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+}
 class CodexServiceContext {
   constructor(options = {}) {
     const sessionsPath = options.sessionsPath ?? process.env.CODEX_SESSIONS_PATH;
+    const configPath = options.configPath ?? DEFAULT_CODEX_DEVTOOLS_CONFIG_PATH;
     this.scanner = new CodexSessionScanner(sessionsPath);
     this.parser = new CodexSessionParser();
     this.chunkBuilder = new CodexChunkBuilder();
     this.dataCache = new DataCache(options.cacheSize ?? 200, options.cacheTtlMinutes ?? 10);
     this.watcher = new FileWatcher(sessionsPath);
-    this.configManager = new ConfigManager(options.configPath);
+    this.configManager = new ConfigManager(configPath);
+    const metadataDirectory = path__namespace.dirname(configPath);
+    this.statsSnapshotStore = new StatsSnapshotStore(path__namespace.join(metadataDirectory, "stats-snapshot.json"));
+    this.modelRatesStore = new ModelRatesStore(path__namespace.join(metadataDirectory, "stats-rates.json"));
     this.removeFileChangeListener = this.watcher.onFileChange(() => {
       this.dataCache.clear();
     });
@@ -1983,6 +2620,33 @@ class CodexServiceContext {
       results
     };
   }
+  async getModelRates() {
+    return this.modelRatesStore.getRateCard();
+  }
+  async refreshModelRates() {
+    const refreshed = await this.modelRatesStore.refreshFromPricingPage();
+    this.dataCache.clear();
+    return refreshed;
+  }
+  async getStats(scope = { type: "all" }) {
+    const normalizedScope = normalizeStatsScope(scope);
+    const rates = await this.getModelRates();
+    const sessions = await this.scanner.scanSessions();
+    const revisionByFilePath = await this.getSessionRevisionLookup(sessions);
+    const sessionSignature = buildStatsSessionSignature(sessions, revisionByFilePath);
+    const cacheKey = DataCache.buildKey(
+      STATS_CACHE_PREFIX,
+      `${serializeStatsScope(normalizedScope)}:${rates.updatedAt ?? "never"}:${sessionSignature}`
+    );
+    const cached = this.dataCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const reconciledRecords = await this.reconcileStatsSnapshot(sessions, revisionByFilePath);
+    const summary = aggregateStatsSummary(reconciledRecords, normalizedScope, rates);
+    this.dataCache.set(cacheKey, summary);
+    return summary;
+  }
   getConfig() {
     return this.configManager.getConfig();
   }
@@ -1999,6 +2663,75 @@ class CodexServiceContext {
       value
     );
   }
+  async reconcileStatsSnapshot(currentSessions, revisionByFilePath) {
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const existingRecords = await this.statsSnapshotStore.getSessions();
+    const existingBySessionId = new Map(existingRecords.map((record) => [record.sessionId, record]));
+    const nextRecords = [];
+    const activeSessionIds = /* @__PURE__ */ new Set();
+    for (const session of currentSessions) {
+      activeSessionIds.add(session.id);
+      const revision = revisionByFilePath.get(session.filePath) ?? UNKNOWN_REVISION;
+      const existing = existingBySessionId.get(session.id);
+      if (existing && existing.revision === revision && existing.tokenComputationVersion === TOKEN_COMPUTATION_VERSION) {
+        nextRecords.push({
+          ...existing,
+          archived: false,
+          revision,
+          filePath: session.filePath,
+          cwd: session.cwd,
+          startTime: session.startTime,
+          modelUsages: session.modelUsages.length > 0 ? session.modelUsages : existing.modelUsages,
+          lastSeenAt: nowIso
+        });
+        continue;
+      }
+      let detail = null;
+      try {
+        detail = await this.getSessionDetail(session.id);
+      } catch {
+        detail = null;
+      }
+      if (!detail) {
+        if (existing) {
+          nextRecords.push({
+            ...existing,
+            archived: false,
+            revision,
+            filePath: session.filePath,
+            cwd: session.cwd,
+            startTime: session.startTime,
+            lastSeenAt: nowIso
+          });
+        }
+        continue;
+      }
+      const nextRecord = buildSessionStatsRecord(detail, revision, nowIso);
+      nextRecord.archived = false;
+      nextRecords.push(nextRecord);
+    }
+    for (const record of existingRecords) {
+      if (activeSessionIds.has(record.sessionId)) {
+        continue;
+      }
+      nextRecords.push({
+        ...record,
+        archived: true
+      });
+    }
+    nextRecords.sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
+    await this.statsSnapshotStore.saveSessions(nextRecords);
+    return nextRecords;
+  }
+  async getSessionRevisionLookup(sessions) {
+    const revisions = await Promise.all(
+      sessions.map(async (session) => {
+        const revision = await this.getSessionFileRevision(session.filePath);
+        return [session.filePath, revision];
+      })
+    );
+    return new Map(revisions);
+  }
   async findSessionById(sessionId) {
     const sessions = await this.getAllSessions();
     const match = sessions.find((session) => session.id === sessionId);