vibestats 1.3.13 → 1.4.1

package/dist/index.js

@@ -902,9 +902,9 @@ function buildActivityHeatmapLines(graph, options) {
 
 // src/anthropic-sources.ts
 import { execFile } from "child_process";
-import { promises as fs } from "fs";
-import { homedir } from "os";
-import { basename, join } from "path";
+import { promises as fs2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, join as join2 } from "path";
 import { promisify } from "util";
 
 // src/shared/async.ts
@@ -934,12 +934,168 @@ async function mapWithConcurrency(items, concurrency, worker) {
   return results;
 }
 
+// src/usage/cache.ts
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var USAGE_CACHE_SCHEMA_VERSION = 1;
+var USAGE_CACHE_FILENAME = "usage-entries-v1.json";
+var CACHE_LOCK_TIMEOUT_MS = 2e3;
+var CACHE_LOCK_RETRY_MS = 25;
+var CACHE_LOCK_STALE_MS = 3e4;
+var cacheWriteQueue = Promise.resolve();
+function getUsageCacheDir() {
+  return process.env.VIBESTATS_CACHE_DIR || join(homedir(), ".vibestats", "cache");
+}
+function getUsageCachePath() {
+  return join(getUsageCacheDir(), USAGE_CACHE_FILENAME);
+}
+function shouldUsePersistentUsageCache(options = {}) {
+  return options.useCache !== false;
+}
+function createMissingFingerprint(path) {
+  return {
+    path,
+    size: -1,
+    mtimeMs: -1
+  };
+}
+async function getSourceFingerprint(path) {
+  try {
+    const stats = await fs.stat(path);
+    if (!stats.isFile()) return null;
+    return {
+      path,
+      size: stats.size,
+      mtimeMs: Math.trunc(stats.mtimeMs)
+    };
+  } catch {
+    return null;
+  }
+}
+function fingerprintMatches(left, right) {
+  return Boolean(left && left.path === right.path && left.size === right.size && left.mtimeMs === right.mtimeMs);
+}
+function dependencyFingerprintsMatch(cached, current) {
+  if ((cached?.length || 0) !== current.length) return false;
+  for (let index = 0; index < current.length; index++) {
+    if (!fingerprintMatches(cached?.[index], current[index])) return false;
+  }
+  return true;
+}
+function getCachedUsageValue(cache, key, fingerprint, dependencyFingerprints = []) {
+  const record = cache.entries[key];
+  if (!record) return null;
+  if (!fingerprintMatches(record.fingerprint, fingerprint)) return null;
+  if (!dependencyFingerprintsMatch(record.dependencyFingerprints, dependencyFingerprints)) return null;
+  return record.value;
+}
+function setCachedUsageValue(cache, key, kind, fingerprint, value, dependencyFingerprints = []) {
+  cache.entries[key] = {
+    kind,
+    fingerprint,
+    dependencyFingerprints,
+    value,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createEmptyUsageCache() {
+  return {
+    schemaVersion: USAGE_CACHE_SCHEMA_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entries: {}
+  };
+}
+function isUsageCache(value) {
+  const candidate = value;
+  return candidate?.schemaVersion === USAGE_CACHE_SCHEMA_VERSION && candidate.entries !== null && typeof candidate.entries === "object";
+}
+async function readUsageCacheFile() {
+  try {
+    const content = await fs.readFile(getUsageCachePath(), "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isUsageCache(parsed)) return createEmptyUsageCache();
+    return parsed;
+  } catch {
+    return createEmptyUsageCache();
+  }
+}
+async function readUsageCacheForLookup(options = {}) {
+  if (!shouldUsePersistentUsageCache(options) || options.refreshCache) {
+    return createEmptyUsageCache();
+  }
+  return readUsageCacheFile();
+}
+async function writeUsageCacheFile(cache) {
+  const cachePath = getUsageCachePath();
+  await fs.mkdir(dirname(cachePath), { recursive: true });
+  const tmpPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
+  cache.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs.writeFile(tmpPath, `${JSON.stringify(cache, null, 2)}
+`, "utf-8");
+  await fs.rename(tmpPath, cachePath);
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+async function withUsageCacheLock(task) {
+  const lockPath = `${getUsageCachePath()}.lock`;
+  await fs.mkdir(dirname(lockPath), { recursive: true });
+  const start = Date.now();
+  let lockHandle = null;
+  while (!lockHandle) {
+    try {
+      lockHandle = await fs.open(lockPath, "wx");
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST" || Date.now() - start >= CACHE_LOCK_TIMEOUT_MS) {
+        return;
+      }
+      try {
+        const lockStats = await fs.stat(lockPath);
+        if (Date.now() - lockStats.mtimeMs > CACHE_LOCK_STALE_MS) {
+          await fs.unlink(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      await sleep(CACHE_LOCK_RETRY_MS);
+    }
+  }
+  try {
+    await task();
+  } finally {
+    try {
+      await lockHandle.close();
+    } catch {
+    }
+    try {
+      await fs.unlink(lockPath);
+    } catch {
+    }
+  }
+}
+async function updateUsageCache(options, mutator) {
+  if (!shouldUsePersistentUsageCache(options)) return;
+  cacheWriteQueue = cacheWriteQueue.then(() => withUsageCacheLock(async () => {
+    const cache = await readUsageCacheFile();
+    mutator(cache);
+    await writeUsageCacheFile(cache);
+  })).catch(() => {
+  });
+  await cacheWriteQueue;
+}
+
 // src/anthropic-sources.ts
 var execFileAsync = promisify(execFile);
 var SQLITE_SEPARATOR = "";
 var SQLITE_MAX_BUFFER = 64 * 1024 * 1024;
 var FILE_PARSE_CONCURRENCY = getRecommendedConcurrency();
 var anthropicEntryCache = /* @__PURE__ */ new Map();
+var CLAUDE_JSONL_CACHE_KIND = "claude-jsonl";
+var FACTORY_SETTINGS_CACHE_KIND = "factory-settings";
+var OPENCODE_DB_CACHE_KIND = "opencode-db";
 function toLocalDateString(isoTimestamp) {
   const date = new Date(isoTimestamp);
   const year = date.getFullYear();
@@ -949,7 +1105,7 @@ function toLocalDateString(isoTimestamp) {
 }
 async function pathExists(path) {
   try {
-    await fs.access(path);
+    await fs2.access(path);
     return true;
   } catch {
     return false;
@@ -957,7 +1113,7 @@ async function pathExists(path) {
 }
 async function safeRealpath(path) {
   try {
-    return await fs.realpath(path);
+    return await fs2.realpath(path);
   } catch {
     return path;
   }
@@ -967,17 +1123,17 @@ async function findFiles(dir, matcher, visited = /* @__PURE__ */ new Set(), resu
   const realPath = await safeRealpath(dir);
   if (visited.has(realPath)) return result;
   visited.add(realPath);
-  let entries2;
+  let entries;
   try {
-    entries2 = await fs.readdir(dir);
+    entries = await fs2.readdir(dir);
   } catch {
     return result;
   }
-  for (const entry of entries2) {
-    const fullPath = join(dir, entry);
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry);
     let stat;
     try {
-      stat = await fs.stat(fullPath);
+      stat = await fs2.stat(fullPath);
     } catch {
       continue;
     }
@@ -1019,36 +1175,99 @@ function calculateKnownCost(modelName, inputTokens, outputTokens, cacheWriteToke
 function entryTotalTokens(entry) {
   return entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens;
 }
+function getPersistentCacheKey(kind, filePath) {
+  return `${kind}:${filePath}`;
+}
+function isPathWithin(path, root) {
+  const normalizedRoot = root.endsWith("/") ? root : `${root}/`;
+  return path === root || path.startsWith(normalizedRoot);
+}
+function toCachedAnthropicEntry(entry) {
+  return {
+    timestamp: entry.timestamp,
+    rawModel: entry.rawModel,
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheWriteTokens: entry.cacheWriteTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    explicitCost: entry.explicitCost,
+    messageCount: entry.messageCount,
+    sourceKey: entry.sourceKey,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId
+  };
+}
+function rehydrateAnthropicEntry(entry) {
+  return {
+    date: toLocalDateString(entry.timestamp),
+    timestamp: entry.timestamp,
+    rawModel: entry.rawModel,
+    model: getModelDisplayName(entry.rawModel),
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheWriteTokens: entry.cacheWriteTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    cost: calculateKnownCost(
+      entry.rawModel,
+      entry.inputTokens,
+      entry.outputTokens,
+      entry.cacheWriteTokens,
+      entry.cacheReadTokens,
+      entry.explicitCost
+    ),
+    messageCount: entry.messageCount,
+    source: "claude",
+    sourceKey: entry.sourceKey,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId
+  };
+}
+function rehydrateAnthropicEntries(entries) {
+  return entries.map(rehydrateAnthropicEntry);
+}
+function cacheAnthropicEntries(entries) {
+  return entries.map((entry) => toCachedAnthropicEntry(entry));
+}
+async function getOpenCodeDependencyFingerprints(dbPath) {
+  const walPath = `${dbPath}-wal`;
+  const shmPath = `${dbPath}-shm`;
+  return [
+    await getSourceFingerprint(walPath) || createMissingFingerprint(walPath),
+    await getSourceFingerprint(shmPath) || createMissingFingerprint(shmPath)
+  ];
+}
 async function resolveProjectDir(projectsDir, cwd) {
   let current = cwd;
   while (current && current !== "/") {
     const encoded = current.replace(/\//g, "-");
-    const candidate = join(projectsDir, encoded);
+    const candidate = join2(projectsDir, encoded);
     if (await pathExists(candidate)) return candidate;
-    const parent = join(current, "..");
+    const parent = join2(current, "..");
     if (parent === current) break;
     current = parent;
   }
   return null;
 }
 function getClaudeDir() {
-  return process.env.CLAUDE_HOME || join(homedir(), ".claude");
+  return process.env.CLAUDE_HOME || join2(homedir2(), ".claude");
 }
 function getOpenCodeDbPath() {
   if (process.env.OPENCODE_DB_PATH) {
     return process.env.OPENCODE_DB_PATH;
   }
-  return join(homedir(), ".local", "share", "opencode", "opencode.db");
+  return join2(homedir2(), ".local", "share", "opencode", "opencode.db");
 }
 function getFactorySessionsDir() {
   if (process.env.FACTORY_SESSIONS_DIR) {
     return process.env.FACTORY_SESSIONS_DIR;
   }
-  return join(homedir(), ".factory", "sessions");
+  return join2(homedir2(), ".factory", "sessions");
 }
 async function claudeCompatibleDataExists() {
   const [claudeProjects, opencodeDb, factorySessions] = await Promise.all([
-    pathExists(join(getClaudeDir(), "projects")),
+    pathExists(join2(getClaudeDir(), "projects")),
     pathExists(getOpenCodeDbPath()),
     pathExists(getFactorySessionsDir())
   ]);
@@ -1060,12 +1279,14 @@ function getAnthropicEntryCacheKey(options) {
     opencodeDbPath: getOpenCodeDbPath(),
     factorySessionsDir: getFactorySessionsDir(),
     projectFilter: options.projectFilter || "",
-    families: options.families || []
+    families: options.families || [],
+    useCache: options.useCache !== false,
+    refreshCache: options.refreshCache === true
   });
 }
 async function parseClaudeProjectFile(filePath) {
   try {
-    const content = await fs.readFile(filePath, "utf-8");
+    const content = await fs2.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const fallbackSessionId = basename(filePath, ".jsonl");
     const isSubagentFile = filePath.includes("/subagents/");
@@ -1116,27 +1337,70 @@ async function parseClaudeProjectFile(filePath) {
     return [];
   }
 }
-async function parseClaudeProjectEntries(projectFilter) {
+async function parseClaudeProjectEntries(projectFilter, cacheOptions = {}) {
   const claudeDir = getClaudeDir();
-  const projectsDir = join(claudeDir, "projects");
+  const projectsDir = join2(claudeDir, "projects");
   if (!await pathExists(projectsDir)) return [];
   let searchDir = projectsDir;
   if (projectFilter) {
     const resolved = await resolveProjectDir(projectsDir, projectFilter);
-    if (!resolved) return entries;
+    if (!resolved) return [];
     searchDir = resolved;
   }
   const jsonlFiles = await findFiles(searchDir, (entry) => entry.endsWith(".jsonl"));
+  const persistentCache = await readUsageCacheForLookup(cacheOptions);
+  const retainedKeys = /* @__PURE__ */ new Set();
+  const updates = [];
   const parsedFiles = await mapWithConcurrency(
     jsonlFiles,
     FILE_PARSE_CONCURRENCY,
-    (filePath) => parseClaudeProjectFile(filePath)
+    async (filePath) => {
+      const fingerprint = await getSourceFingerprint(filePath);
+      if (!fingerprint) return [];
+      const key = getPersistentCacheKey(CLAUDE_JSONL_CACHE_KIND, filePath);
+      retainedKeys.add(key);
+      const cached = getCachedUsageValue(persistentCache, key, fingerprint);
+      if (cached) {
+        return rehydrateAnthropicEntries(cached);
+      }
+      const entries = await parseClaudeProjectFile(filePath);
+      updates.push({ key, fingerprint, value: cacheAnthropicEntries(entries) });
+      return entries;
+    }
   );
+  await updateUsageCache(cacheOptions, (cache) => {
+    for (const [key, record] of Object.entries(cache.entries)) {
+      if (record.kind === CLAUDE_JSONL_CACHE_KIND && isPathWithin(record.fingerprint.path, searchDir) && !retainedKeys.has(key)) {
+        delete cache.entries[key];
+      }
+    }
+    for (const update of updates) {
+      setCachedUsageValue(cache, update.key, CLAUDE_JSONL_CACHE_KIND, update.fingerprint, update.value);
+    }
+  });
   return parsedFiles.flat();
 }
-async function parseOpenCodeEntries() {
+async function parseOpenCodeEntries(cacheOptions = {}) {
   const dbPath = getOpenCodeDbPath();
-  if (!await pathExists(dbPath)) return [];
+  const key = getPersistentCacheKey(OPENCODE_DB_CACHE_KIND, dbPath);
+  const fingerprint = await getSourceFingerprint(dbPath);
+  if (!fingerprint) {
+    await updateUsageCache(cacheOptions, (cache) => {
+      delete cache.entries[key];
+    });
+    return [];
+  }
+  const dependencyFingerprints = await getOpenCodeDependencyFingerprints(dbPath);
+  const persistentCache = await readUsageCacheForLookup(cacheOptions);
+  const cached = getCachedUsageValue(
+    persistentCache,
+    key,
+    fingerprint,
+    dependencyFingerprints
+  );
+  if (cached) {
+    return rehydrateAnthropicEntries(cached);
+  }
   const sql = `
     SELECT
       COALESCE(m.id, ''),
@@ -1165,7 +1429,7 @@ async function parseOpenCodeEntries() {
   } catch {
     return [];
   }
-  const entries2 = [];
+  const entries = [];
   for (const line of stdout.split("\n")) {
     if (!line.trim()) continue;
     const [
@@ -1190,7 +1454,7 @@ async function parseOpenCodeEntries() {
     const cacheReadTokens = Number(cacheReadText) || 0;
     const explicitCost = Number(costText) || 0;
     const sessionKind = parentId ? "subagent" : "main";
-    entries2.push({
+    entries.push({
       date: toLocalDateString(timestamp),
       timestamp,
       rawModel,
@@ -1200,6 +1464,7 @@ async function parseOpenCodeEntries() {
       cacheWriteTokens,
       cacheReadTokens,
       cost: calculateKnownCost(rawModel, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, explicitCost),
+      explicitCost,
       messageCount: 1,
       source: "claude",
       sourceKey: "opencode",
@@ -1208,7 +1473,17 @@ async function parseOpenCodeEntries() {
       subagentId: sessionKind === "subagent" ? messageId || sessionId : void 0
     });
   }
-  return entries2;
+  await updateUsageCache(cacheOptions, (cache) => {
+    setCachedUsageValue(
+      cache,
+      key,
+      OPENCODE_DB_CACHE_KIND,
+      fingerprint,
+      cacheAnthropicEntries(entries),
+      dependencyFingerprints
+    );
+  });
+  return entries;
 }
 async function readFactorySessionMeta(sessionFilePath) {
   let messageCount = 0;
@@ -1216,7 +1491,7 @@ async function readFactorySessionMeta(sessionFilePath) {
   let sessionKind = "main";
   let subagentId;
   try {
-    const content = await fs.readFile(sessionFilePath, "utf-8");
+    const content = await fs2.readFile(sessionFilePath, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -1242,13 +1517,33 @@ async function readFactorySessionMeta(sessionFilePath) {
   }
   return { messageCount: Math.max(messageCount, 1), timestamp, sessionKind, subagentId };
 }
-async function parseFactoryEntries() {
+async function parseFactoryEntries(cacheOptions = {}) {
   const sessionsDir = getFactorySessionsDir();
   if (!await pathExists(sessionsDir)) return [];
   const settingsFiles = await findFiles(sessionsDir, (entry) => entry.endsWith(".settings.json"));
+  const persistentCache = await readUsageCacheForLookup(cacheOptions);
+  const retainedKeys = /* @__PURE__ */ new Set();
+  const updates = [];
   const parsedFiles = await mapWithConcurrency(settingsFiles, FILE_PARSE_CONCURRENCY, async (settingsPath) => {
+    const fingerprint = await getSourceFingerprint(settingsPath);
+    if (!fingerprint) return null;
+    const sessionFilePath = settingsPath.replace(/\.settings\.json$/, ".jsonl");
+    const dependencyFingerprints = [
+      await getSourceFingerprint(sessionFilePath) || createMissingFingerprint(sessionFilePath)
+    ];
+    const key = getPersistentCacheKey(FACTORY_SETTINGS_CACHE_KIND, settingsPath);
+    retainedKeys.add(key);
+    const cached = getCachedUsageValue(
+      persistentCache,
+      key,
+      fingerprint,
+      dependencyFingerprints
+    );
+    if (cached) {
+      return rehydrateAnthropicEntries(cached);
+    }
     try {
-      const settings = JSON.parse(await fs.readFile(settingsPath, "utf-8"));
+      const settings = JSON.parse(await fs2.readFile(settingsPath, "utf-8"));
       const usage = settings.tokenUsage;
       const configuredModel = settings.model;
       if (!usage || !configuredModel) return null;
@@ -1259,12 +1554,11 @@ async function parseFactoryEntries() {
       const outputTokens = (usage.outputTokens || 0) + (usage.thinkingTokens || 0);
       const totalTokens = inputTokens + outputTokens + cacheWriteTokens + cacheReadTokens;
       if (totalTokens === 0) return null;
-      const sessionFilePath = settingsPath.replace(/\.settings\.json$/, ".jsonl");
       const sessionId = basename(settingsPath, ".settings.json");
       const meta = await readFactorySessionMeta(sessionFilePath);
       const timestamp = settings.providerLockTimestamp || meta.timestamp;
       if (!timestamp) return null;
-      return {
+      const entry = {
         date: toLocalDateString(timestamp),
         timestamp,
         rawModel,
@@ -1281,11 +1575,35 @@ async function parseFactoryEntries() {
         sessionKind: meta.sessionKind,
         subagentId: meta.subagentId
       };
+      updates.push({
+        key,
+        fingerprint,
+        dependencyFingerprints,
+        value: cacheAnthropicEntries([entry])
+      });
+      return entry;
     } catch {
       return null;
     }
   });
-  return parsedFiles.filter((entry) => entry !== null);
+  await updateUsageCache(cacheOptions, (cache) => {
+    for (const [key, record] of Object.entries(cache.entries)) {
+      if (record.kind === FACTORY_SETTINGS_CACHE_KIND && isPathWithin(record.fingerprint.path, sessionsDir) && !retainedKeys.has(key)) {
+        delete cache.entries[key];
+      }
+    }
+    for (const update of updates) {
+      setCachedUsageValue(
+        cache,
+        update.key,
+        FACTORY_SETTINGS_CACHE_KIND,
+        update.fingerprint,
+        update.value,
+        update.dependencyFingerprints
+      );
+    }
+  });
+  return parsedFiles.flat().filter((entry) => entry !== null);
 }
 async function collectAnthropicUsageEntries(options = {}) {
   const cacheKey = getAnthropicEntryCacheKey(options);
@@ -1295,22 +1613,22 @@ async function collectAnthropicUsageEntries(options = {}) {
   }
   const loadPromise = (async () => {
     const [claudeEntries, opencodeEntries, factoryEntries] = await Promise.all([
-      parseClaudeProjectEntries(options.projectFilter),
-      parseOpenCodeEntries(),
-      parseFactoryEntries()
+      parseClaudeProjectEntries(options.projectFilter, options),
+      parseOpenCodeEntries(options),
+      parseFactoryEntries(options)
     ]);
-    const entries2 = [...claudeEntries, ...opencodeEntries, ...factoryEntries];
+    const entries = [...claudeEntries, ...opencodeEntries, ...factoryEntries];
     if (!options.families || options.families.length === 0) {
-      return entries2;
+      return entries;
     }
-    return entries2.filter((entry) => matchesModelFamilies(entry.rawModel, options.families));
+    return entries.filter((entry) => matchesModelFamilies(entry.rawModel, options.families));
   })();
   anthropicEntryCache.set(cacheKey, loadPromise);
   return loadPromise;
 }
 async function loadClaudeStatsFromJsonl(options = {}) {
-  const entries2 = await collectAnthropicUsageEntries(options);
-  if (entries2.length === 0) {
+  const entries = await collectAnthropicUsageEntries(options);
+  if (entries.length === 0) {
     return null;
   }
   const modelUsage = /* @__PURE__ */ new Map();
@@ -1321,7 +1639,7 @@ async function loadClaudeStatsFromJsonl(options = {}) {
   const hourCounts = {};
   let firstTimestamp = null;
   let totalMessages = 0;
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const existing = modelUsage.get(entry.rawModel) ?? {
       inputTokens: 0,
       outputTokens: 0,
@@ -1386,13 +1704,14 @@ async function loadClaudeStatsFromJsonl(options = {}) {
 }
 
 // src/codex-loader.ts
-import { promises as fs2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { promises as fs3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 var FILE_PARSE_CONCURRENCY2 = getRecommendedConcurrency();
 var codexParseCache = /* @__PURE__ */ new Map();
+var CODEX_JSONL_CACHE_KIND = "codex-jsonl";
 function getCodexDir() {
-  return process.env.CODEX_HOME || join2(homedir2(), ".codex");
+  return process.env.CODEX_HOME || join3(homedir3(), ".codex");
 }
 function toLocalDateString2(isoTimestamp) {
   const date = new Date(isoTimestamp);
@@ -1403,7 +1722,7 @@ function toLocalDateString2(isoTimestamp) {
 }
 async function pathExists2(path) {
   try {
-    await fs2.access(path);
+    await fs3.access(path);
     return true;
   } catch {
     return false;
@@ -1412,24 +1731,24 @@ async function pathExists2(path) {
 async function codexDataExists() {
   const codexDir = getCodexDir();
   if (!await pathExists2(codexDir)) return false;
-  const sessionsDir = join2(codexDir, "sessions");
-  const archivedDir = join2(codexDir, "archived_sessions");
+  const sessionsDir = join3(codexDir, "sessions");
+  const archivedDir = join3(codexDir, "archived_sessions");
   return await pathExists2(sessionsDir) || await pathExists2(archivedDir);
 }
 async function findJsonlFiles(dir) {
   const files = [];
   if (!await pathExists2(dir)) return files;
-  let entries2;
+  let entries;
   try {
-    entries2 = await fs2.readdir(dir);
+    entries = await fs3.readdir(dir);
   } catch {
     return files;
   }
-  for (const entry of entries2) {
-    const fullPath = join2(dir, entry);
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry);
     let stat;
     try {
-      stat = await fs2.stat(fullPath);
+      stat = await fs3.stat(fullPath);
     } catch {
       continue;
     }
@@ -1441,15 +1760,110 @@ async function findJsonlFiles(dir) {
   }
   return files;
 }
-function getCodexParseCacheKey(families) {
+function getPersistentCacheKey2(kind, filePath) {
+  return `${kind}:${filePath}`;
+}
+function isPathWithin2(path, root) {
+  const normalizedRoot = root.endsWith("/") ? root : `${root}/`;
+  return path === root || path.startsWith(normalizedRoot);
+}
+function toCachedCodexUsageEntry(entry) {
+  return {
+    timestamp: entry.timestamp,
+    rawModel: entry.rawModel,
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    reasoningTokens: entry.reasoningTokens,
+    messageCount: entry.messageCount,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId
+  };
+}
+function rehydrateCodexUsageEntry(entry) {
+  const pricing = getCodexModelPricing(entry.rawModel);
+  return {
+    date: toLocalDateString2(entry.timestamp),
+    timestamp: entry.timestamp,
+    model: getCodexModelDisplayName(entry.rawModel),
+    rawModel: entry.rawModel,
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    reasoningTokens: entry.reasoningTokens,
+    cost: entry.inputTokens * pricing.input / 1e6 + entry.outputTokens * pricing.output / 1e6 + entry.cacheReadTokens * pricing.cachedInput / 1e6,
+    messageCount: entry.messageCount,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId,
+    source: "codex",
+    sourceKey: "codex"
+  };
+}
+function toCachedParsedCodexFile(parsed) {
+  return {
+    session: parsed.session,
+    rawEntries: parsed.rawEntries.map(toCachedCodexUsageEntry)
+  };
+}
+function rehydrateParsedCodexFile(cached) {
+  return {
+    session: cached.session,
+    rawEntries: cached.rawEntries.map(rehydrateCodexUsageEntry)
+  };
+}
+function filterParsedCodexFileByFamilies(parsed, families) {
+  if (!families || families.length === 0) {
+    return parsed;
+  }
+  const filteredPerModelUsage = {};
+  const summedUsage = {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0
+  };
+  let primaryModel = parsed.session.model;
+  let maxTokens = 0;
+  for (const [model, usage] of Object.entries(parsed.session.perModelUsage || {})) {
+    if (!matchesModelFamilies(model, families)) continue;
+    filteredPerModelUsage[model] = usage;
+    summedUsage.input_tokens += usage.input_tokens;
+    summedUsage.cached_input_tokens += usage.cached_input_tokens;
+    summedUsage.output_tokens += usage.output_tokens;
+    summedUsage.reasoning_output_tokens += usage.reasoning_output_tokens;
+    summedUsage.total_tokens += usage.total_tokens;
+    if (usage.total_tokens > maxTokens) {
+      maxTokens = usage.total_tokens;
+      primaryModel = model;
+    }
+  }
+  if (Object.keys(filteredPerModelUsage).length === 0) {
+    return null;
+  }
+  return {
+    session: {
+      ...parsed.session,
+      model: primaryModel,
+      tokenUsage: summedUsage,
+      perModelUsage: filteredPerModelUsage
+    },
+    rawEntries: parsed.rawEntries.filter((entry) => matchesModelFamilies(entry.rawModel, families))
+  };
+}
+function getCodexParseCacheKey(options) {
   return JSON.stringify({
     codexDir: getCodexDir(),
-    families: families || []
+    families: options.families || [],
+    useCache: options.useCache !== false,
+    refreshCache: options.refreshCache === true
   });
 }
 async function parseSessionFile(filePath, families) {
   try {
-    const content = await fs2.readFile(filePath, "utf-8");
+    const content = await fs3.readFile(filePath, "utf-8");
     const lines = content.trim().split("\n");
     let sessionMeta = null;
     let currentModel = "gpt-5";
@@ -1568,28 +1982,66 @@ async function parseSessionFile(filePath, families) {
   }
 }
 async function collectParsedCodexFiles(options = {}) {
-  const cacheKey = getCodexParseCacheKey(options.families);
+  const cacheKey = getCodexParseCacheKey(options);
   const cached = codexParseCache.get(cacheKey);
   if (cached) {
     return cached;
   }
   const loadPromise = (async () => {
     const codexDir = getCodexDir();
-    const sessionsDir = join2(codexDir, "sessions");
-    const archivedDir = join2(codexDir, "archived_sessions");
+    const sessionsDir = join3(codexDir, "sessions");
+    const archivedDir = join3(codexDir, "archived_sessions");
     const [sessionFiles, archivedFiles] = await Promise.all([
       findJsonlFiles(sessionsDir),
       findJsonlFiles(archivedDir)
     ]);
     const jsonlFiles = [...sessionFiles, ...archivedFiles];
     if (jsonlFiles.length === 0) {
+      await updateUsageCache(options, (cache) => {
+        for (const [key, record] of Object.entries(cache.entries)) {
+          if (record.kind === CODEX_JSONL_CACHE_KIND && (isPathWithin2(record.fingerprint.path, sessionsDir) || isPathWithin2(record.fingerprint.path, archivedDir))) {
+            delete cache.entries[key];
+          }
+        }
+      });
       return [];
     }
+    const persistentCache = await readUsageCacheForLookup(options);
+    const retainedKeys = /* @__PURE__ */ new Set();
+    const updates = [];
     const parsedFiles = await mapWithConcurrency(
       jsonlFiles,
       FILE_PARSE_CONCURRENCY2,
-      (file) => parseSessionFile(file, options.families)
+      async (file) => {
+        const fingerprint = await getSourceFingerprint(file);
+        if (!fingerprint) return null;
+        const key = getPersistentCacheKey2(CODEX_JSONL_CACHE_KIND, file);
+        retainedKeys.add(key);
+        const cached2 = getCachedUsageValue(persistentCache, key, fingerprint);
+        if (cached2) {
+          const parsed2 = rehydrateParsedCodexFile(cached2);
+          return filterParsedCodexFileByFamilies(parsed2, options.families);
+        }
+        const parsed = await parseSessionFile(file, options.families);
+        if (parsed) {
+          const fullParsed = options.families && options.families.length > 0 ? await parseSessionFile(file) : parsed;
+          if (fullParsed) {
+            updates.push({ key, fingerprint, value: toCachedParsedCodexFile(fullParsed) });
+          }
+        }
+        return parsed;
+      }
     );
+    await updateUsageCache(options, (cache) => {
+      for (const [key, record] of Object.entries(cache.entries)) {
+        if (record.kind === CODEX_JSONL_CACHE_KIND && (isPathWithin2(record.fingerprint.path, sessionsDir) || isPathWithin2(record.fingerprint.path, archivedDir)) && !retainedKeys.has(key)) {
+          delete cache.entries[key];
+        }
+      }
+      for (const update of updates) {
+        setCachedUsageValue(cache, update.key, CODEX_JSONL_CACHE_KIND, update.fingerprint, update.value);
+      }
+    });
     return parsedFiles.filter((entry) => entry !== null);
   })();
   codexParseCache.set(cacheKey, loadPromise);
@@ -1690,8 +2142,8 @@ async function loadCodexStats(options = {}) {
 function normalizePresentableModelName(modelName) {
   return getModelDisplayName(modelName).trim();
 }
-function normalizeEntryModels(entries2) {
-  return entries2.map((entry) => ({
+function normalizeEntryModels(entries) {
+  return entries.map((entry) => ({
     ...entry,
     model: normalizePresentableModelName(entry.model)
   }));
@@ -1703,9 +2155,9 @@ function toLocalDateString3(isoTimestamp) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
-async function parseClaudeJsonl(projectFilter, families) {
-  const entries2 = await collectAnthropicUsageEntries({ projectFilter, families });
-  return entries2.map((entry) => ({
+async function parseClaudeJsonl(projectFilter, families, cacheOptions = {}) {
+  const entries = await collectAnthropicUsageEntries({ projectFilter, families, ...cacheOptions });
+  return entries.map((entry) => ({
     date: entry.date,
     model: entry.model,
     rawModel: entry.rawModel,
@@ -1723,9 +2175,9 @@ async function parseClaudeJsonl(projectFilter, families) {
     timestamp: entry.timestamp
   }));
 }
-async function parseCodexJsonl(families) {
-  const entries2 = await collectCodexUsageEntries({ families });
-  return entries2.map((entry) => ({
+async function parseCodexJsonl(families, cacheOptions = {}) {
+  const entries = await collectCodexUsageEntries({ families, ...cacheOptions });
+  return entries.map((entry) => ({
     date: entry.date,
     model: entry.model,
     rawModel: entry.rawModel,
@@ -1751,10 +2203,10 @@ function getSourceLabel(sourceKey, source) {
   if (key === "codex") return "Codex CLI";
   return key;
 }
-function computeSessionCounts(entries2) {
+function computeSessionCounts(entries) {
   const mainSessions = /* @__PURE__ */ new Set();
   const subagentSessions = /* @__PURE__ */ new Set();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const sourceKey = entry.sourceKey || entry.source;
     if (entry.sessionId) {
       mainSessions.add(`${sourceKey}:${entry.sessionId}`);
@@ -1769,8 +2221,8 @@ function computeSessionCounts(entries2) {
     total: mainSessions.size + subagentSessions.size
   };
 }
-function filterByDateRange(entries2, since, until) {
-  return entries2.filter((e) => {
+function filterByDateRange(entries, since, until) {
+  return entries.filter((e) => {
     if (since && e.date < since) return false;
     if (until && e.date > until) return false;
     return true;
@@ -1797,9 +2249,9 @@ function sortModelsByTier(models) {
     return priorityB - priorityA;
   });
 }
-function aggregateByDay(entries2) {
+function aggregateByDay(entries) {
   const dayMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     const existing = dayMap.get(e.date);
     if (existing) {
@@ -1828,9 +2280,9 @@ function aggregateByDay(entries2) {
     models: sortModelsByTier(Array.from(modelsSet))
   })).sort((a, b) => a.key.localeCompare(b.key));
 }
-function aggregateByMonth(entries2) {
+function aggregateByMonth(entries) {
   const monthMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const month = e.date.slice(0, 7);
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     const existing = monthMap.get(month);
@@ -1860,9 +2312,9 @@ function aggregateByMonth(entries2) {
     models: sortModelsByTier(Array.from(modelsSet))
   })).sort((a, b) => a.key.localeCompare(b.key));
 }
-function aggregateByModel(entries2) {
+function aggregateByModel(entries) {
   const modelMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     if (entryTotal <= 0) continue;
     const existing = modelMap.get(e.model);
@@ -1887,9 +2339,9 @@ function aggregateByModel(entries2) {
   }
   return Array.from(modelMap.values()).sort((a, b) => b.totalTokens - a.totalTokens);
 }
-function aggregateBySession(entries2) {
+function aggregateBySession(entries) {
   const sessionMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const sourceKey = e.sourceKey || e.source;
     const sid = e.sessionId ? `${sourceKey}:${e.sessionId}` : "unknown";
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
@@ -1921,9 +2373,9 @@ function aggregateBySession(entries2) {
   }
   return Array.from(sessionMap.entries()).filter(([, data]) => data.totalTokens > 0).map(([sessionId, data]) => {
     const date = data.firstTimestamp ? toLocalDateString3(data.firstTimestamp) : "unknown";
-    const shortId = data.displaySessionId.slice(0, 12);
+    const shortId2 = data.displaySessionId.slice(0, 12);
     return {
-      key: `${date} ${shortId}`,
+      key: `${date} ${shortId2}`,
       inputTokens: data.inputTokens,
       outputTokens: data.outputTokens,
       cacheWriteTokens: data.cacheWriteTokens,
@@ -1947,9 +2399,9 @@ function computeTotals(rows) {
     { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0, totalTokens: 0, cost: 0 }
   );
 }
-function computeModelBreakdown(entries2) {
+function computeModelBreakdown(entries) {
   const modelMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const total = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     if (total <= 0) continue;
     const existing = modelMap.get(e.model);
@@ -1968,10 +2420,10 @@ function computeModelBreakdown(entries2) {
     percentage: totalTokens > 0 ? Math.round(data.tokens / totalTokens * 100) : 0
   })).sort((a, b) => b.tokens - a.tokens);
 }
-function computeSourceBreakdown(entries2) {
+function computeSourceBreakdown(entries) {
   const sourceMap = /* @__PURE__ */ new Map();
   const sessionsBySource = /* @__PURE__ */ new Map();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const sourceKey = entry.sourceKey || entry.source;
     const label = getSourceLabel(entry.sourceKey, entry.source);
     const total = entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens;
@@ -2001,9 +2453,9 @@ function computeSourceBreakdown(entries2) {
     percentage: totalTokens > 0 ? Math.round(source.tokens / totalTokens * 100) : 0
   })).sort((a, b) => b.tokens - a.tokens);
 }
-function computeActivityStats(entries2, source) {
+function computeActivityStats(entries, source) {
   const dayMap = /* @__PURE__ */ new Map();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const existing = dayMap.get(entry.date);
     if (existing) {
       existing.inputTokens += entry.inputTokens;
@@ -2026,7 +2478,7 @@ function computeActivityStats(entries2, source) {
     }
   }
   const sessionMap = /* @__PURE__ */ new Map();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     if (!entry.sessionId) continue;
     const sessions = sessionMap.get(entry.date) || /* @__PURE__ */ new Set();
     sessions.add(`${entry.source}:${entry.sessionId}`);
@@ -2065,33 +2517,34 @@ function computeActivityStats(entries2, source) {
     },
     days,
     totals,
-    modelBreakdown: computeModelBreakdown(entries2),
-    sessionCounts: computeSessionCounts(entries2),
-    sourceBreakdown: computeSourceBreakdown(entries2)
+    modelBreakdown: computeModelBreakdown(entries),
+    sessionCounts: computeSessionCounts(entries),
+    sourceBreakdown: computeSourceBreakdown(entries)
   };
 }
 async function loadUsageStats(options) {
   const { aggregation, since, until, codexOnly, combined, projectFilter, families } = options;
-  let entries2 = [];
+  const cacheOptions = { useCache: options.useCache, refreshCache: options.refreshCache };
+  let entries = [];
   if (!codexOnly) {
-    entries2 = entries2.concat(await parseClaudeJsonl(projectFilter, families));
+    entries = entries.concat(await parseClaudeJsonl(projectFilter, families, cacheOptions));
   }
   if (codexOnly || combined) {
-    entries2 = entries2.concat(await parseCodexJsonl(families));
+    entries = entries.concat(await parseCodexJsonl(families, cacheOptions));
   }
-  if (entries2.length === 0) {
+  if (entries.length === 0) {
     return null;
   }
-  entries2 = normalizeEntryModels(entries2);
+  entries = normalizeEntryModels(entries);
   if (families && families.length > 0) {
-    entries2 = entries2.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
+    entries = entries.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
   }
-  entries2 = filterByDateRange(entries2, since, until);
-  entries2 = entries2.filter((e) => !e.model.toLowerCase().includes("synthetic"));
-  if (entries2.length === 0) {
+  entries = filterByDateRange(entries, since, until);
+  entries = entries.filter((e) => !e.model.toLowerCase().includes("synthetic"));
+  if (entries.length === 0) {
     return null;
   }
-  const dates = entries2.map((e) => e.date).sort();
+  const dates = entries.map((e) => e.date).sort();
   const dateRange = {
     start: dates[0],
     end: dates[dates.length - 1]
@@ -2099,26 +2552,26 @@ async function loadUsageStats(options) {
   let rows;
   switch (aggregation) {
     case "monthly":
-      rows = aggregateByMonth(entries2);
+      rows = aggregateByMonth(entries);
       break;
     case "model":
-      rows = aggregateByModel(entries2);
+      rows = aggregateByModel(entries);
       break;
     case "session":
-      rows = aggregateBySession(entries2);
+      rows = aggregateBySession(entries);
       break;
     case "total":
       rows = [];
       break;
     case "daily":
     default:
-      rows = aggregateByDay(entries2);
+      rows = aggregateByDay(entries);
       break;
   }
-  const totals = aggregation === "total" ? computeTotals(aggregateByDay(entries2)) : computeTotals(rows);
-  const modelBreakdown = computeModelBreakdown(entries2);
-  const sessionCounts = computeSessionCounts(entries2);
-  const sourceBreakdown = computeSourceBreakdown(entries2);
+  const totals = aggregation === "total" ? computeTotals(aggregateByDay(entries)) : computeTotals(rows);
+  const modelBreakdown = computeModelBreakdown(entries);
+  const sessionCounts = computeSessionCounts(entries);
+  const sourceBreakdown = computeSourceBreakdown(entries);
   let source = "claude";
   if (codexOnly) source = "codex";
   else if (combined) source = "combined";
@@ -2136,29 +2589,30 @@ async function loadUsageStats(options) {
 }
 async function loadActivityStats(options) {
   const { since, until, codexOnly, combined, projectFilter, families } = options;
-  let entries2 = [];
+  const cacheOptions = { useCache: options.useCache, refreshCache: options.refreshCache };
+  let entries = [];
   if (!codexOnly) {
-    entries2 = entries2.concat(await parseClaudeJsonl(projectFilter, families));
+    entries = entries.concat(await parseClaudeJsonl(projectFilter, families, cacheOptions));
   }
   if (codexOnly || combined) {
-    entries2 = entries2.concat(await parseCodexJsonl(families));
+    entries = entries.concat(await parseCodexJsonl(families, cacheOptions));
   }
-  if (entries2.length === 0) {
+  if (entries.length === 0) {
     return null;
   }
-  entries2 = normalizeEntryModels(entries2);
+  entries = normalizeEntryModels(entries);
   if (families && families.length > 0) {
-    entries2 = entries2.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
+    entries = entries.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
   }
-  entries2 = filterByDateRange(entries2, since, until);
-  entries2 = entries2.filter((entry) => !entry.model.toLowerCase().includes("synthetic"));
-  if (entries2.length === 0) {
+  entries = filterByDateRange(entries, since, until);
+  entries = entries.filter((entry) => !entry.model.toLowerCase().includes("synthetic"));
+  if (entries.length === 0) {
     return null;
   }
   let source = "claude";
   if (codexOnly) source = "codex";
   else if (combined) source = "combined";
-  const stats = computeActivityStats(entries2, source);
+  const stats = computeActivityStats(entries, source);
   stats.scopeLabel = formatModelFamilyLabel(families);
   return stats;
 }
@@ -2428,12 +2882,20 @@ async function loadData(options) {
   let codex = null;
   if (!codexOnly) {
     if (await claudeCompatibleDataExists()) {
-      claude = await loadClaudeStatsFromJsonl({ families });
+      claude = await loadClaudeStatsFromJsonl({
+        families,
+        useCache: options.useCache,
+        refreshCache: options.refreshCache
+      });
     }
   }
   if (codexOnly || combined) {
     if (await codexDataExists()) {
-      codex = await loadCodexStats({ families });
+      codex = await loadCodexStats({
+        families,
+        useCache: options.useCache,
+        refreshCache: options.refreshCache
+      });
     }
   }
   let source = "claude";
@@ -3052,15 +3514,15 @@ async function publishArtifact(artifact, baseUrl, legacyUrl) {
 }
 
 // src/claude-inspector.ts
-import { promises as fs3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { promises as fs4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 function getClaudeDir2() {
-  return process.env.CLAUDE_HOME || join3(homedir3(), ".claude");
+  return process.env.CLAUDE_HOME || join4(homedir4(), ".claude");
 }
 async function pathExists3(path) {
   try {
-    await fs3.access(path);
+    await fs4.access(path);
     return true;
   } catch {
     return false;
@@ -3068,7 +3530,7 @@ async function pathExists3(path) {
 }
 async function readJsonFile(path) {
   try {
-    const content = await fs3.readFile(path, "utf-8");
+    const content = await fs4.readFile(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -3076,17 +3538,17 @@ async function readJsonFile(path) {
 }
 async function walkFiles(dir, visitor) {
   if (!await pathExists3(dir)) return;
-  let entries2;
+  let entries;
   try {
-    entries2 = await fs3.readdir(dir);
+    entries = await fs4.readdir(dir);
   } catch {
     return;
   }
-  for (const entry of entries2) {
-    const fullPath = join3(dir, entry);
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry);
     let stat;
     try {
-      stat = await fs3.stat(fullPath);
+      stat = await fs4.stat(fullPath);
     } catch {
       continue;
     }
@@ -3104,8 +3566,8 @@ function daysSince(dateStr) {
   const diffMs = Date.now() - parsed.getTime();
   return Math.max(0, Math.floor(diffMs / (24 * 60 * 60 * 1e3)));
 }
-async function inspectClaudeSystem(home = homedir3()) {
-  const path = join3(home, ".claude.json");
+async function inspectClaudeSystem(home = homedir4()) {
+  const path = join4(home, ".claude.json");
   const json = await readJsonFile(path);
   return {
     path,
@@ -3120,18 +3582,18 @@ async function inspectClaudeSystem(home = homedir3()) {
   };
 }
 async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
-  const statsCachePath = join3(claudeDir, "stats-cache.json");
+  const statsCachePath = join4(claudeDir, "stats-cache.json");
   const statsCache = await readJsonFile(statsCachePath);
-  const facetsDir = join3(claudeDir, "usage-data", "facets");
-  const sessionMetaDir = join3(claudeDir, "usage-data", "session-meta");
-  const projectsDir = join3(claudeDir, "projects");
-  const facetFiles = await pathExists3(facetsDir) ? (await fs3.readdir(facetsDir)).filter((file) => file.endsWith(".json")) : [];
-  const sessionMetaFiles = await pathExists3(sessionMetaDir) ? (await fs3.readdir(sessionMetaDir)).filter((file) => file.endsWith(".json")) : [];
+  const facetsDir = join4(claudeDir, "usage-data", "facets");
+  const sessionMetaDir = join4(claudeDir, "usage-data", "session-meta");
+  const projectsDir = join4(claudeDir, "projects");
+  const facetFiles = await pathExists3(facetsDir) ? (await fs4.readdir(facetsDir)).filter((file) => file.endsWith(".json")) : [];
+  const sessionMetaFiles = await pathExists3(sessionMetaDir) ? (await fs4.readdir(sessionMetaDir)).filter((file) => file.endsWith(".json")) : [];
   let rateLimitHit = 0;
   let apiTokenLimit = 0;
   let contextLimit = 0;
   for (const file of facetFiles) {
-    const json = await readJsonFile(join3(facetsDir, file));
+    const json = await readJsonFile(join4(facetsDir, file));
     const friction = json?.friction_counts || {};
     rateLimitHit += friction.rate_limit_hit || 0;
     apiTokenLimit += friction.api_token_limit || 0;
@@ -3141,7 +3603,7 @@ async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
   let inputTokens = 0;
   let outputTokens = 0;
   for (const file of sessionMetaFiles) {
-    const json = await readJsonFile(join3(sessionMetaDir, file));
+    const json = await readJsonFile(join4(sessionMetaDir, file));
     if (!json) continue;
     if (json.uses_task_agent) sessionsUsingTaskAgent += 1;
     inputTokens += json.input_tokens || 0;
@@ -3204,6 +3666,359 @@ async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
   };
 }
 
+// src/shared/args.ts
+var modelFamilyArgs = {
+  claude: {
+    type: "boolean",
+    description: "Show only Claude family stats across local usage sources",
+    default: false
+  },
+  kimi: {
+    type: "boolean",
+    description: "Show only Kimi family stats across local usage sources",
+    default: false
+  },
+  minimax: {
+    type: "boolean",
+    description: "Show only MiniMax family stats across local usage sources",
+    default: false
+  }
+};
+function getSelectedModelFamilies(args) {
+  const families = [];
+  if (args.claude === true) families.push("claude");
+  if (args.kimi === true) families.push("kimi");
+  if (args.minimax === true) families.push("minimax");
+  return families;
+}
+var cacheArgs = {
+  "no-cache": {
+    type: "boolean",
+    description: "Bypass the persistent local usage cache for this run",
+    default: false
+  },
+  "refresh-cache": {
+    type: "boolean",
+    description: "Rebuild the persistent local usage cache before showing stats",
+    default: false
+  }
+};
+function getUsageCacheOptions(args) {
+  return {
+    useCache: args["no-cache"] !== true,
+    refreshCache: args["refresh-cache"] === true
+  };
+}
+
+// src/dashboard/assets-path.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve, join as join5 } from "path";
+import { existsSync } from "fs";
+function resolveDashboardAssets(importMetaUrl) {
+  const here = dirname2(fileURLToPath(importMetaUrl));
+  const candidates = [
+    // Published tarball (tsup single-file bundle): here === .../dist, assets at .../dist/web
+    resolve(here, "web"),
+    // Same tarball layout but caller is nested one deeper (e.g. dist/commands/...)
+    resolve(here, "..", "web"),
+    // Monorepo dev with tsx from packages/cli/src/dashboard/...
+    resolve(here, "..", "..", "..", "web", ".next-static"),
+    // Monorepo dev with tsx from packages/cli/src/commands/...
+    resolve(here, "..", "..", "web", ".next-static")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(join5(candidate, "index.html"))) return candidate;
+  }
+  throw new Error(
+    `dashboard assets not found. Tried:
+` + candidates.map((c) => `  - ${c}`).join("\n") + `
+Run \`pnpm --filter web build:static\` first.`
+  );
+}
+
+// src/dashboard/payloads.ts
+import { randomBytes } from "crypto";
+var MAX_INLINE_BYTES = 6e3;
+var STUB_BASE = "http://local";
+function extractEncodedQuery(urlWithQuery) {
+  const url = new URL(urlWithQuery);
+  const query = url.search.replace(/^\?/, "");
+  return query || null;
+}
+function shortId() {
+  return randomBytes(6).toString("hex");
+}
+function inlineOrFallback(paramKey, payload, inlineQuery, out) {
+  if (!payload || !inlineQuery) return;
+  if (Buffer.byteLength(inlineQuery, "utf-8") <= MAX_INLINE_BYTES) {
+    out.hubParams.set(paramKey, inlineQuery);
+    return;
+  }
+  const id = shortId();
+  out.jsonStore.set(id, JSON.stringify(payload));
+  out.hubParams.set(paramKey, `json:${id}`);
+}
+function buildDashboardPayloads(input) {
+  const out = {
+    hubParams: new URLSearchParams(),
+    jsonStore: /* @__PURE__ */ new Map()
+  };
+  if (input.usage) {
+    const full = encodeUsageToUrl(input.usage, STUB_BASE);
+    inlineOrFallback("u", input.usage, extractEncodedQuery(full), out);
+  }
+  if (input.wrapped) {
+    const full = encodeStatsToUrl(input.wrapped, STUB_BASE);
+    inlineOrFallback("w", input.wrapped, extractEncodedQuery(full), out);
+  }
+  if (input.activity) {
+    const full = encodeActivityToUrl(input.activity, STUB_BASE);
+    inlineOrFallback("a", input.activity, extractEncodedQuery(full), out);
+  }
+  return out;
+}
+
+// src/dashboard/open-browser.ts
+import { spawn } from "child_process";
+import { platform } from "os";
+function openInBrowser(url) {
+  const os = platform();
+  const cmd = os === "darwin" ? "open" : os === "win32" ? "cmd" : "xdg-open";
+  const args = os === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/dashboard/server.ts
+import { createServer as createServer2 } from "http";
+import { readFile } from "fs/promises";
+import { existsSync as existsSync2, realpathSync, statSync } from "fs";
+import { extname, join as join6, normalize, resolve as resolve2, sep } from "path";
+
+// src/dashboard/port.ts
+import { createServer, createConnection } from "net";
+async function findFreePort(start, end) {
+  for (let port = start; port <= end; port++) {
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error(`no free port available in range ${start}-${end}`);
+}
+function isPortFree(port) {
+  return isConnectable(port).then((connectable) => {
+    if (connectable) return false;
+    return isBindable(port);
+  });
+}
+function isConnectable(port) {
+  return new Promise((resolve3) => {
+    const socket = createConnection({ port, host: "127.0.0.1" });
+    const done = (result) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve3(result);
+    };
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+    const timer = setTimeout(() => done(false), 250);
+    timer.unref();
+  });
+}
+function isBindable(port) {
+  return new Promise((resolve3) => {
+    const server = createServer();
+    const onError = () => {
+      server.removeListener("listening", onListening);
+      resolve3(false);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      server.close(() => {
+        resolve3(true);
+      });
+    };
+    server.on("error", onError);
+    server.on("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
+}
+
+// src/dashboard/server.ts
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".txt": "text/plain; charset=utf-8",
+  ".map": "application/json; charset=utf-8"
+};
+async function startDashboardServer(options) {
+  const root = realpathSync(resolve2(options.assetsDir));
+  const preferred = options.preferredPort ?? 8080;
+  const port = await findFreePort(preferred, preferred + 20);
+  const server = createServer2(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+      let pathname = url.pathname;
+      const dataMatch = /^\/data\/([A-Za-z0-9_-]+)\.json$/.exec(pathname);
+      if (dataMatch) {
+        const body2 = options.jsonStore.get(dataMatch[1]);
+        if (!body2) {
+          res.statusCode = 404;
+          res.end("not found");
+          return;
+        }
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(body2);
+        return;
+      }
+      if (pathname === "/") pathname = "/index.html";
+      if (pathname !== "/index.html" && pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+      }
+      const safePath = normalize(join6(root, pathname));
+      if (!safePath.startsWith(root + sep) && safePath !== root) {
+        res.statusCode = 400;
+        res.end("bad request");
+        return;
+      }
+      let filePath = safePath;
+      const sibling = filePath + ".html";
+      if (existsSync2(filePath) && statSync(filePath).isFile()) {
+      } else if (existsSync2(sibling) && statSync(sibling).isFile()) {
+        filePath = sibling;
+      } else if (existsSync2(filePath) && statSync(filePath).isDirectory()) {
+        filePath = join6(filePath, "index.html");
+      }
+      let realFilePath;
+      try {
+        realFilePath = realpathSync(filePath);
+      } catch {
+        res.statusCode = 404;
+        res.end("not found");
+        return;
+      }
+      if (!realFilePath.startsWith(root + sep) && realFilePath !== root) {
+        res.statusCode = 400;
+        res.end("bad request");
+        return;
+      }
+      if (!existsSync2(realFilePath) || !statSync(realFilePath).isFile()) {
+        res.statusCode = 404;
+        res.end("not found");
+        return;
+      }
+      const ext = extname(realFilePath).toLowerCase();
+      const mime = MIME[ext] || "application/octet-stream";
+      const body = await readFile(realFilePath);
+      if (pathname.startsWith("/_next/static/")) {
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+      } else {
+        res.setHeader("Cache-Control", "no-cache");
+      }
+      res.setHeader("Content-Type", mime);
+      res.setHeader("Content-Length", String(body.length));
+      res.end(body);
+    } catch (err) {
+      console.error("[dashboard] server error:", err);
+      res.statusCode = 500;
+      res.end("internal error");
+    }
+  });
+  await new Promise((resolveFn, rejectFn) => {
+    const onError = (err) => rejectFn(err);
+    server.once("error", onError);
+    server.listen(port, "127.0.0.1", () => {
+      server.removeListener("error", onError);
+      resolveFn();
+    });
+  });
+  return {
+    server,
+    port,
+    async close() {
+      await Promise.race([
+        new Promise(
+          (resolveFn, rejectFn) => server.close((err) => err ? rejectFn(err) : resolveFn())
+        ),
+        new Promise((resolveFn) => {
+          const t = setTimeout(resolveFn, 2e3);
+          t.unref();
+        })
+      ]);
+    }
+  };
+}
+
+// src/commands/dashboard.ts
+async function runDashboard(args, config) {
+  void config;
+  const families = getSelectedModelFamilies(args);
+  const scopeLabel = formatModelFamilyLabel(families);
+  const cacheOptions = getUsageCacheOptions(args);
+  const codexOnly = args.codex;
+  const combined = args.combined;
+  const [usage, activity, data] = await Promise.all([
+    loadUsageStats({
+      aggregation: "daily",
+      codexOnly,
+      combined,
+      families,
+      scopeLabel,
+      ...cacheOptions
+    }),
+    loadActivityStats({ codexOnly, combined, families, scopeLabel, ...cacheOptions }),
+    loadData({ codexOnly, combined, families, scopeLabel, ...cacheOptions })
+  ]);
+  validateData(data, { codexOnly, combined, families, scopeLabel, ...cacheOptions });
+  let wrapped = null;
+  if (combined) {
+    const c = data.claude ? computeWrappedStats(data.claude) : null;
+    const x = data.codex ? computeCodexWrappedStats(data.codex) : null;
+    wrapped = combineWrappedStats(c, x);
+  } else if (codexOnly) {
+    wrapped = data.codex ? computeCodexWrappedStats(data.codex) : null;
+  } else {
+    wrapped = data.claude ? computeWrappedStats(data.claude) : null;
+  }
+  const activityPayload = activity ? buildActivityArtifact(activity, "tokens", 365).payload : null;
+  const { hubParams, jsonStore } = buildDashboardPayloads({
+    usage: usage ?? null,
+    wrapped,
+    activity: activityPayload
+  });
+  const assetsDir = resolveDashboardAssets(import.meta.url);
+  const server = await startDashboardServer({ assetsDir, jsonStore });
+  const url = `http://127.0.0.1:${server.port}/dashboard/?${hubParams.toString()}`;
+  const orange = "\x1B[38;5;208m";
+  const reset = "\x1B[0m";
+  console.log(`${orange}vibestats dashboard${reset} \u2192 ${url}`);
+  console.log("Press Ctrl+C to stop.");
+  openInBrowser(url);
+  await new Promise((resolveFn) => {
+    const shutdown = async () => {
+      await server.close();
+      resolveFn();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+
 // src/cli-intent.ts
 var COMMANDS = /* @__PURE__ */ new Set(["usage", "limits", "limit", "pace"]);
 var SCOPES = /* @__PURE__ */ new Set(["claude", "codex", "all", "combined"]);
@@ -3216,7 +4031,9 @@ var USAGE_COMMAND_FLAGS = /* @__PURE__ */ new Set([
   "metric",
   "model",
   "monthly",
+  "no-cache",
   "project",
+  "refresh-cache",
   "sessions",
   "share",
   "since",
@@ -3241,9 +4058,11 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "minimax",
   "model",
   "monthly",
+  "no-cache",
   "no-short",
   "project",
   "quiet",
+  "refresh-cache",
   "sessions",
   "share",
   "total",
@@ -3390,8 +4209,8 @@ function applyCliIntent(args, intent) {
 // src/limits/claude.ts
 import { execFile as execFile2 } from "child_process";
 import { randomUUID } from "crypto";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/limits/pace.ts
 var PACE_EPSILON_PERCENT = 1;
@@ -3741,7 +4560,7 @@ function isClaudePromptReady(text) {
   return /Claude Code v\d+\.\d+\.\d+/.test(normalized) && (normalized.includes("\u276F") || normalized.includes(">"));
 }
 function execFileCommand(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     execFile2(
       command,
       [...args],
@@ -3755,18 +4574,18 @@ function execFileCommand(command, args, options = {}) {
           reject(error);
           return;
         }
-        resolve({ stdout, stderr });
+        resolve3({ stdout, stderr });
       }
     );
   });
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function resolveDefaultClaudeUsageCwd() {
   const envCwd = process.env.VIBESTATS_CLAUDE_USAGE_CWD ?? process.env.VIBESTATS_USAGE_CWD;
   if (envCwd?.trim()) return envCwd;
-  return dirname(fileURLToPath(import.meta.url));
+  return dirname3(fileURLToPath2(import.meta.url));
 }
 async function captureUsageWithTmux(options) {
   const sessionName = `${TMUX_SESSION_PREFIX}-${randomUUID().replaceAll("-", "").slice(0, 16)}`;
@@ -3834,7 +4653,7 @@ async function fetchClaudeLimits(options = {}) {
       timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       now,
       runCommand: options.runCommand ?? execFileCommand,
-      sleepFn: options.sleepFn ?? sleep
+      sleepFn: options.sleepFn ?? sleep2
     });
   } catch (error) {
     return {
@@ -3863,7 +4682,7 @@ async function fetchClaudeLimits(options = {}) {
 }
 
 // src/limits/codex.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function clampPercent3(value) {
   const numeric = typeof value === "number" ? value : Number(value);
   if (!Number.isFinite(numeric)) return 0;
@@ -3996,8 +4815,8 @@ var JsonRpcClient = class {
       method,
       ...params === void 0 ? {} : { params }
     };
-    const promise = new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
+    const promise = new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
     });
     try {
       this.child.stdin.write(`${JSON.stringify(message)}
@@ -4077,7 +4896,7 @@ function scriptArgsForCodexStatus(command) {
 async function fetchCodexStatusFallback(options = {}) {
   const command = options.command || "codex";
   const timeoutMs = options.timeoutMs ?? 8e3;
-  const child = spawn("script", scriptArgsForCodexStatus(command), {
+  const child = spawn2("script", scriptArgsForCodexStatus(command), {
     stdio: ["ignore", "pipe", "pipe"],
     env: process.env
   });
@@ -4090,19 +4909,19 @@ async function fetchCodexStatusFallback(options = {}) {
   child.stderr.on("data", (chunk) => {
     output += chunk;
   });
-  await new Promise((resolve) => {
+  await new Promise((resolve3) => {
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve();
+      resolve3();
     }, timeoutMs);
     timer.unref();
     child.on("error", () => {
       clearTimeout(timer);
-      resolve();
+      resolve3();
     });
     child.on("exit", () => {
       clearTimeout(timer);
-      resolve();
+      resolve3();
     });
   });
   const windows = parseCodexStatusText(output);
@@ -4125,7 +4944,7 @@ async function fetchCodexStatusFallback(options = {}) {
 async function fetchCodexLimits(options = {}) {
   const command = options.command || "codex";
   const timeoutMs = options.timeoutMs ?? 8e3;
-  const child = spawn(command, ["-s", "read-only", "-a", "untrusted", "app-server"], {
+  const child = spawn2(command, ["-s", "read-only", "-a", "untrusted", "app-server"], {
     stdio: ["pipe", "pipe", "pipe"],
     env: process.env
   });
@@ -4290,10 +5109,10 @@ function displayUsageLimits(limits, options = {}) {
 }
 
 // src/config.ts
-import { readFileSync, existsSync, writeFileSync } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
-var CONFIG_PATH = join4(homedir4(), ".vibestats.json");
+import { readFileSync, existsSync as existsSync3, writeFileSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+var CONFIG_PATH = join7(homedir5(), ".vibestats.json");
 var DEFAULT_CONFIG = {
   baseUrl: "https://vibestats.wolfai.dev",
   outputFormat: "normal",
@@ -4303,7 +5122,7 @@ var DEFAULT_CONFIG = {
   hideCost: false
 };
 function loadConfig() {
-  if (!existsSync(CONFIG_PATH)) {
+  if (!existsSync3(CONFIG_PATH)) {
     return DEFAULT_CONFIG;
   }
   try {
@@ -4326,7 +5145,7 @@ function mergeConfig(defaults, user) {
   };
 }
 function initConfig() {
-  if (existsSync(CONFIG_PATH)) {
+  if (existsSync3(CONFIG_PATH)) {
     console.log(`Config file already exists at ${CONFIG_PATH}`);
     return;
   }
@@ -4356,32 +5175,6 @@ function resolveOptions(cliArgs, config) {
   };
 }
 
-// src/shared/args.ts
-var modelFamilyArgs = {
-  claude: {
-    type: "boolean",
-    description: "Show only Claude family stats across local usage sources",
-    default: false
-  },
-  kimi: {
-    type: "boolean",
-    description: "Show only Kimi family stats across local usage sources",
-    default: false
-  },
-  minimax: {
-    type: "boolean",
-    description: "Show only MiniMax family stats across local usage sources",
-    default: false
-  }
-};
-function getSelectedModelFamilies(args) {
-  const families = [];
-  if (args.claude === true) families.push("claude");
-  if (args.kimi === true) families.push("kimi");
-  if (args.minimax === true) families.push("minimax");
-  return families;
-}
-
 // src/index.ts
 function printCommandHelp(error) {
   console.error(`Error: ${error}`);
@@ -4390,6 +5183,9 @@ function printCommandHelp(error) {
   console.error("  vibestats limits all");
   console.error("  vibestats limits claude");
   console.error("  vibestats limits codex");
+  console.error("  vibestats claude");
+  console.error("  vibestats codex");
+  console.error("  vibestats all");
   console.error("  vibestats usage all");
   console.error("  vibestats usage --combined --daily");
   console.error("  vibestats usage codex --total");
@@ -4539,7 +5335,7 @@ async function publishArtifactWithFallback(artifact, baseUrl, fallbackUrl, prefe
 var main = defineCommand({
   meta: {
     name: "vibestats",
-    version: "1.3.13",
+    version: "1.4.1",
     description: "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex"
   },
   args: {
@@ -4664,6 +5460,7 @@ var main = defineCommand({
       description: "Disable shortlink generation",
       default: false
     },
+    ...cacheArgs,
     // Config management
     init: {
       type: "boolean",
@@ -4675,6 +5472,11 @@ var main = defineCommand({
       description: "Show current config location and values",
       default: false
     },
+    dashboard: {
+      type: "boolean",
+      description: "Open a local web dashboard with usage, activity, and wrapped views",
+      default: false
+    },
     "claude-system": {
       type: "boolean",
       description: "Inspect ~/.claude.json account and app state",
@@ -4715,6 +5517,10 @@ var main = defineCommand({
       await runLiveLimits(normalizedArgs, config);
       return;
     }
+    if (normalizedArgs.dashboard) {
+      await runDashboard(normalizedArgs, config);
+      return;
+    }
     if (normalizedArgs.activity) {
       await runActivity(normalizedArgs, config);
     } else if (normalizedArgs.wrapped) {
@@ -4750,6 +5556,7 @@ async function runUsage(args, config) {
   else if (args.model) aggregation = "model";
   else if (args.total) aggregation = "total";
   const shouldShowSpinner = !args.json && !args.quiet;
+  const cacheOptions = getUsageCacheOptions(args);
   const statsPromise = loadUsageStats({
     aggregation,
     since,
@@ -4758,7 +5565,8 @@ async function runUsage(args, config) {
     combined: args.combined,
     projectFilter: args.project ? process.cwd() : void 0,
     families,
-    scopeLabel
+    scopeLabel,
+    ...cacheOptions
   });
   const stats = shouldShowSpinner ? await createSpinner("Loading vibestats...").whilePromise(statsPromise) : await statsPromise;
   if (!stats) {
@@ -4865,14 +5673,15 @@ async function runWrapped(args, config) {
   const scopeLabel = formatModelFamilyLabel(families);
   const metric = parseActivityMetric(args.metric);
   const days = parseActivityDays(args.days);
+  const cacheOptions = getUsageCacheOptions(args);
   const spinner = createSpinner("Preparing wrapped...");
   const [data, activityStats] = await spinner.whilePromise(
     Promise.all([
-      loadData({ codexOnly: args.codex, combined: args.combined, families, scopeLabel }),
-      loadActivityStats({ codexOnly: args.codex, combined: args.combined, families, scopeLabel })
+      loadData({ codexOnly: args.codex, combined: args.combined, families, scopeLabel, ...cacheOptions }),
+      loadActivityStats({ codexOnly: args.codex, combined: args.combined, families, scopeLabel, ...cacheOptions })
     ])
   );
-  validateData(data, { codexOnly: args.codex, combined: args.combined, families, scopeLabel });
+  validateData(data, { codexOnly: args.codex, combined: args.combined, families, scopeLabel, ...cacheOptions });
   let claudeStats = null;
   let codexStats = null;
   if (data.claude) {
@@ -4933,6 +5742,7 @@ async function runActivity(args, config) {
   const metric = parseActivityMetric(args.metric);
   const days = parseActivityDays(args.days);
   const spinner = createSpinner("Preparing activity graph...");
+  const cacheOptions = getUsageCacheOptions(args);
   const stats = await spinner.whilePromise(
     loadActivityStats({
       codexOnly: args.codex,
@@ -4941,7 +5751,8 @@ async function runActivity(args, config) {
       since: args.since,
       until: args.until,
       families,
-      scopeLabel
+      scopeLabel,
+      ...cacheOptions
     })
   );
   if (!stats) {