vibestats 1.3.7 → 1.3.8

package/dist/index.js

@@ -788,7 +788,7 @@ function getClaudeDir() {
   return process.env.CLAUDE_HOME || join(homedir(), ".claude");
 }
 function getCodexDir() {
-  return join(homedir(), ".codex");
+  return process.env.CODEX_HOME || join(homedir(), ".codex");
 }
 async function pathExists(path) {
   try {
@@ -861,11 +861,12 @@ async function parseClaudeJsonl(projectFilter) {
   }
   const jsonlFiles = await findJsonlFiles(searchDir);
   for (const filePath of jsonlFiles) {
-    const sessionId = basename(filePath, ".jsonl");
     try {
       const content = await fs.readFile(filePath, "utf-8");
       if (!content.trim()) continue;
       const lines = content.split("\n");
+      const fallbackSessionId = basename(filePath, ".jsonl");
+      const isSubagentFile = filePath.includes("/subagents/");
       for (const line of lines) {
         if (!line.trim()) continue;
         try {
@@ -880,6 +881,8 @@ async function parseClaudeJsonl(projectFilter) {
           const model = entry.message.model || "unknown";
           const timestamp = entry.timestamp;
           if (!timestamp) continue;
+          const sessionId = entry.sessionId || fallbackSessionId;
+          const sessionKind = entry.isSidechain === true || isSubagentFile ? "subagent" : "main";
           const date = toLocalDateString(timestamp);
           const pricing = getModelPricing(model);
           const inputTokens = usage.input_tokens || 0;
@@ -898,6 +901,8 @@ async function parseClaudeJsonl(projectFilter) {
             messageCount: 1,
             source: "claude",
             sessionId,
+            sessionKind,
+            subagentId: sessionKind === "subagent" ? filePath : void 0,
             timestamp
           });
         } catch {
@@ -924,10 +929,22 @@ async function parseCodexJsonl() {
       const content = await fs.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let currentModel = "gpt-5";
+      let fileSessionId = basename(filePath, ".jsonl");
+      let canonicalSessionId = fileSessionId;
+      let sessionKind = "main";
       for (const line of lines) {
         if (!line.trim()) continue;
         try {
           const entry = JSON.parse(line);
+          if (entry.type === "session_meta") {
+            const payload = entry.payload || {};
+            const payloadSessionId = typeof payload.id === "string" ? payload.id : fileSessionId;
+            const parentThreadId = typeof payload.source?.subagent?.thread_spawn?.parent_thread_id === "string" ? payload.source.subagent.thread_spawn.parent_thread_id : null;
+            fileSessionId = payloadSessionId;
+            canonicalSessionId = parentThreadId || payloadSessionId;
+            sessionKind = parentThreadId ? "subagent" : "main";
+            continue;
+          }
           if (entry.type === "turn_context" && entry.payload?.model) {
             currentModel = entry.payload.model;
             continue;
@@ -954,7 +971,9 @@ async function parseCodexJsonl() {
               cost,
               messageCount: 1,
               source: "codex",
-              sessionId: basename(filePath, ".jsonl"),
+              sessionId: canonicalSessionId,
+              sessionKind,
+              subagentId: sessionKind === "subagent" ? fileSessionId : void 0,
               timestamp
             });
           }
@@ -966,6 +985,23 @@ async function parseCodexJsonl() {
   }
   return entries;
 }
+function computeSessionCounts(entries) {
+  const mainSessions = /* @__PURE__ */ new Set();
+  const subagentSessions = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.sessionId) {
+      mainSessions.add(`${entry.source}:${entry.sessionId}`);
+    }
+    if (entry.sessionKind === "subagent" && entry.subagentId) {
+      subagentSessions.add(`${entry.source}:${entry.subagentId}`);
+    }
+  }
+  return {
+    main: mainSessions.size,
+    subagent: subagentSessions.size,
+    total: mainSessions.size + subagentSessions.size
+  };
+}
 function filterByDateRange(entries, since, until) {
   return entries.filter((e) => {
     if (since && e.date < since) return false;
@@ -1082,7 +1118,7 @@ function aggregateByModel(entries) {
 function aggregateBySession(entries) {
   const sessionMap = /* @__PURE__ */ new Map();
   for (const e of entries) {
-    const sid = e.sessionId || "unknown";
+    const sid = e.sessionId ? `${e.source}:${e.sessionId}` : "unknown";
     const existing = sessionMap.get(sid);
     if (existing) {
       existing.inputTokens += e.inputTokens;
@@ -1097,6 +1133,7 @@ function aggregateBySession(entries) {
       }
     } else {
       sessionMap.set(sid, {
+        displaySessionId: e.sessionId || sid,
         modelsSet: /* @__PURE__ */ new Set([e.model]),
         inputTokens: e.inputTokens,
         outputTokens: e.outputTokens,
@@ -1110,7 +1147,7 @@ function aggregateBySession(entries) {
   }
   return Array.from(sessionMap.entries()).filter(([, data]) => data.totalTokens > 0).map(([sessionId, data]) => {
     const date = data.firstTimestamp ? toLocalDateString(data.firstTimestamp) : "unknown";
-    const shortId = sessionId.slice(0, 12);
+    const shortId = data.displaySessionId.slice(0, 12);
     return {
       key: `${date} ${shortId}`,
       inputTokens: data.inputTokens,
@@ -1167,9 +1204,6 @@ function computeActivityStats(entries, source) {
       existing.cacheReadTokens += entry.cacheReadTokens;
       existing.totalTokens += entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens;
       existing.messageCount += entry.messageCount;
-      if (entry.sessionId) {
-        existing.sessionCount += 0;
-      }
     } else {
       dayMap.set(entry.date, {
         date: entry.date,
@@ -1187,7 +1221,7 @@ function computeActivityStats(entries, source) {
   for (const entry of entries) {
     if (!entry.sessionId) continue;
     const sessions = sessionMap.get(entry.date) || /* @__PURE__ */ new Set();
-    sessions.add(entry.sessionId);
+    sessions.add(`${entry.source}:${entry.sessionId}`);
     sessionMap.set(entry.date, sessions);
   }
   const days = Array.from(dayMap.values()).map((day) => ({
@@ -1223,7 +1257,8 @@ function computeActivityStats(entries, source) {
     },
     days,
     totals,
-    modelBreakdown: computeModelBreakdown(entries)
+    modelBreakdown: computeModelBreakdown(entries),
+    sessionCounts: computeSessionCounts(entries)
   };
 }
 async function loadUsageStats(options) {
@@ -1269,6 +1304,7 @@ async function loadUsageStats(options) {
   }
   const totals = aggregation === "total" ? computeTotals(aggregateByDay(entries)) : computeTotals(rows);
   const modelBreakdown = computeModelBreakdown(entries);
+  const sessionCounts = computeSessionCounts(entries);
   let source = "claude";
   if (codexOnly) source = "codex";
   else if (combined) source = "combined";
@@ -1278,7 +1314,8 @@ async function loadUsageStats(options) {
     source,
     aggregation,
     dateRange,
-    modelBreakdown
+    modelBreakdown,
+    sessionCounts
   };
 }
 async function loadActivityStats(options) {
@@ -1340,6 +1377,9 @@ function padLeft(str, width) {
 function padRight(str, width) {
   return str.padEnd(width);
 }
+function formatCount(n) {
+  return n.toLocaleString("en-US");
+}
 function displayUsageTable(stats, options = {}) {
   const c = getColors(options.showColors);
   const { compact, hideCost } = options;
@@ -1352,6 +1392,9 @@ function displayUsageTable(stats, options = {}) {
   const aggLabel = stats.aggregation === "daily" ? "Daily" : stats.aggregation === "monthly" ? "Monthly" : stats.aggregation === "model" ? "By Model" : stats.aggregation === "session" ? "By Session" : "Total";
   console.log(`${c.orange}${c.bold}${title} - ${aggLabel} Report${c.reset}`);
   console.log(`${c.gray}Date range: ${stats.dateRange.start} to ${stats.dateRange.end}${c.reset}`);
+  if (stats.sessionCounts) {
+    console.log(`${c.gray}Tracked mix: ${formatCount(stats.sessionCounts.main)} main, ${formatCount(stats.sessionCounts.subagent)} subagents${c.reset}`);
+  }
   console.log(`${c.gray}${"\u2500".repeat(Math.min(termWidth - 2, 120))}${c.reset}`);
   console.log();
   const isSession = stats.aggregation === "session";
@@ -1431,6 +1474,9 @@ function displayTotalOnly(stats, options = {}) {
   else if (stats.source === "combined") title = "AI Coding Usage (Claude + Codex)";
   console.log(`${c.orange}${c.bold}${title} - Summary${c.reset}`);
   console.log(`${c.gray}Date range: ${stats.dateRange.start} to ${stats.dateRange.end}${c.reset}`);
+  if (stats.sessionCounts) {
+    console.log(`${c.gray}Tracked mix: ${formatCount(stats.sessionCounts.main)} main, ${formatCount(stats.sessionCounts.subagent)} subagents${c.reset}`);
+  }
   console.log(`${c.gray}${"\u2500".repeat(50)}${c.reset}`);
   console.log();
   const t = stats.totals;
@@ -1463,7 +1509,7 @@ function displayTotalOnly(stats, options = {}) {
 // src/claude-jsonl-loader.ts
 import { promises as fs2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { basename as basename2, join as join2 } from "path";
 function getClaudeDir2() {
   return process.env.CLAUDE_HOME || join2(homedir2(), ".claude");
 }
@@ -1521,6 +1567,9 @@ async function loadClaudeStatsFromJsonl() {
   }
   const modelUsage = {};
   const dailyMap = /* @__PURE__ */ new Map();
+  const sessionsByDate = /* @__PURE__ */ new Map();
+  const mainSessions = /* @__PURE__ */ new Set();
+  const subagentSessions = /* @__PURE__ */ new Set();
   const hourCounts = {};
   let firstTimestamp = null;
   let totalMessages = 0;
@@ -1529,6 +1578,8 @@ async function loadClaudeStatsFromJsonl() {
     try {
       const content = await fs2.readFile(filePath, "utf-8");
       const lines = content.split("\n");
+      const fallbackSessionId = basename2(filePath, ".jsonl");
+      const isSubagentFile = filePath.includes("/subagents/");
       for (const line of lines) {
         if (!line.trim()) continue;
         try {
@@ -1539,6 +1590,8 @@ async function loadClaudeStatsFromJsonl() {
           const model = entry.message.model || "unknown";
           const timestamp = entry.timestamp;
           const messageId = entry.message.id;
+          const sessionId = entry.sessionId || fallbackSessionId;
+          const sessionKind = entry.isSidechain === true || isSubagentFile ? "subagent" : "main";
           if (!modelUsage[model]) {
             modelUsage[model] = {
               inputTokens: 0,
@@ -1562,8 +1615,15 @@ async function loadClaudeStatsFromJsonl() {
             }
             const daily = dailyMap.get(date);
             daily.messageCount++;
+            const dateSessions = sessionsByDate.get(date) || /* @__PURE__ */ new Set();
+            dateSessions.add(sessionId);
+            sessionsByDate.set(date, dateSessions);
             hourCounts[hour] = (hourCounts[hour] || 0) + 1;
           }
+          mainSessions.add(sessionId);
+          if (sessionKind === "subagent") {
+            subagentSessions.add(filePath);
+          }
           if (timestamp && (!firstTimestamp || timestamp < firstTimestamp)) {
             firstTimestamp = timestamp;
           }
@@ -1592,18 +1652,21 @@ async function loadClaudeStatsFromJsonl() {
   const dailyActivity = Array.from(dailyMap.entries()).map(([date, data]) => ({
     date,
     messageCount: data.messageCount,
-    sessionCount: 1,
+    sessionCount: sessionsByDate.get(date)?.size || 0,
     toolCallCount: data.toolCallCount
   })).sort((a, b) => a.date.localeCompare(b.date));
-  const sessionsByDate = /* @__PURE__ */ new Map();
-  void sessionsByDate;
+  const sessionCounts = {
+    main: mainSessions.size,
+    subagent: subagentSessions.size,
+    total: mainSessions.size + subagentSessions.size
+  };
   return {
     version: 1,
     lastComputedDate: toLocalDateString2((/* @__PURE__ */ new Date()).toISOString()),
     dailyActivity,
     dailyModelTokens: [],
     modelUsage: statsCacheModelUsage,
-    totalSessions: jsonlFiles.length,
+    totalSessions: sessionCounts.main,
     totalMessages,
     longestSession: {
       sessionId: "",
@@ -1612,7 +1675,8 @@ async function loadClaudeStatsFromJsonl() {
       timestamp: ""
     },
     firstSessionDate: firstTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    hourCounts
+    hourCounts,
+    sessionCounts
   };
 }
 
@@ -1677,12 +1741,16 @@ async function parseSessionFile(filePath) {
     let sessionMeta = null;
     let currentModel = "gpt-5";
     const perModelUsage = {};
+    let sessionKind = "main";
+    let canonicalId = "";
     for (const line of lines) {
       if (!line.trim()) continue;
       try {
         const entry = JSON.parse(line);
         if (entry.type === "session_meta") {
           sessionMeta = entry.payload;
+          canonicalId = sessionMeta.source?.subagent?.thread_spawn?.parent_thread_id || sessionMeta.id;
+          sessionKind = sessionMeta.source?.subagent?.thread_spawn?.parent_thread_id ? "subagent" : "main";
         } else if (entry.type === "turn_context") {
           const payload = entry.payload;
           if (payload.model) {
@@ -1734,11 +1802,13 @@ async function parseSessionFile(filePath) {
     }
     return {
       id: sessionMeta.id,
+      canonicalId: canonicalId || sessionMeta.id,
       timestamp: sessionMeta.timestamp,
       cwd: sessionMeta.cwd,
       model: primaryModel,
       tokenUsage: summedUsage,
-      perModelUsage
+      perModelUsage,
+      sessionKind
     };
   } catch {
     return null;
@@ -1771,7 +1841,13 @@ async function loadCodexStats() {
   }
   sessions.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   const modelUsage = {};
+  const mainSessions = /* @__PURE__ */ new Set();
+  const subagentSessions = /* @__PURE__ */ new Set();
   for (const session of sessions) {
+    mainSessions.add(session.canonicalId);
+    if (session.sessionKind === "subagent") {
+      subagentSessions.add(session.id);
+    }
     if (session.perModelUsage) {
       for (const [model, usage] of Object.entries(session.perModelUsage)) {
         if (!modelUsage[model]) {
@@ -1805,23 +1881,36 @@ async function loadCodexStats() {
   const dailyMap = /* @__PURE__ */ new Map();
   for (const session of sessions) {
     const date = toLocalDateString3(session.timestamp);
-    dailyMap.set(date, (dailyMap.get(date) || 0) + 1);
+    dailyMap.set(date, 0);
   }
-  const dailyActivity = Array.from(dailyMap.entries()).map(([date, sessionCount]) => ({ date, sessionCount })).sort((a, b) => a.date.localeCompare(b.date));
+  const sessionsByDate = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const date = toLocalDateString3(session.timestamp);
+    const dateSessions = sessionsByDate.get(date) || /* @__PURE__ */ new Set();
+    dateSessions.add(session.canonicalId);
+    sessionsByDate.set(date, dateSessions);
+  }
+  const dailyActivity = Array.from(dailyMap.entries()).map(([date]) => ({ date, sessionCount: sessionsByDate.get(date)?.size || 0 })).sort((a, b) => a.date.localeCompare(b.date));
   const hourCounts = {};
   for (const session of sessions) {
     const hour = new Date(session.timestamp).getHours().toString();
     hourCounts[hour] = (hourCounts[hour] || 0) + 1;
   }
   const totalMessages = sessions.length;
+  const sessionCounts = {
+    main: mainSessions.size,
+    subagent: subagentSessions.size,
+    total: mainSessions.size + subagentSessions.size
+  };
   return {
     sessions,
-    totalSessions: sessions.length,
+    totalSessions: sessionCounts.main,
     totalMessages,
     modelUsage,
     dailyActivity,
     hourCounts,
-    firstSessionDate: toLocalDateString3(sessions[0].timestamp)
+    firstSessionDate: toLocalDateString3(sessions[0].timestamp),
+    sessionCounts
   };
 }
 
@@ -2009,6 +2098,23 @@ function calculateWordsGenerated(modelUsage) {
   }
   return Math.round(totalOutputTokens * 0.75);
 }
+function mergeSessionCounts(...counts) {
+  let main2 = 0;
+  let subagent = 0;
+  let found = false;
+  for (const count of counts) {
+    if (!count) continue;
+    found = true;
+    main2 += count.main;
+    subagent += count.subagent;
+  }
+  if (!found) return void 0;
+  return {
+    main: main2,
+    subagent,
+    total: main2 + subagent
+  };
+}
 function computeWrappedStats(cache) {
   let totalCost = 0;
   for (const [modelName, usage] of Object.entries(cache.modelUsage)) {
@@ -2038,7 +2144,8 @@ function computeWrappedStats(cache) {
     modelBreakdown,
     wordsGenerated,
     firstSessionDate: cache.firstSessionDate,
-    source: "claude"
+    source: "claude",
+    sessionCounts: cache.sessionCounts
   };
 }
 function computeCodexWrappedStats(cache) {
@@ -2122,7 +2229,8 @@ function computeCodexWrappedStats(cache) {
     modelBreakdown,
     wordsGenerated,
     firstSessionDate: cache.firstSessionDate,
-    source: "codex"
+    source: "codex",
+    sessionCounts: cache.sessionCounts
   };
 }
 function combineWrappedStats(claude, codex) {
@@ -2154,8 +2262,9 @@ function combineWrappedStats(claude, codex) {
   const peakHour = claude.sessions > codex.sessions ? claude.peakHour : codex.peakHour;
   const peakDay = claude.sessions > codex.sessions ? claude.peakDay : codex.peakDay;
   const busiestMonth = claude.sessions > codex.sessions ? claude.busiestMonth : codex.busiestMonth;
+  const sessionCounts = mergeSessionCounts(claude.sessionCounts, codex.sessionCounts);
   return {
-    sessions: claude.sessions + codex.sessions,
+    sessions: sessionCounts?.main ?? claude.sessions + codex.sessions,
     messages: claude.messages + codex.messages,
     totalTokens: claude.totalTokens + codex.totalTokens,
     totalCost: claude.totalCost + codex.totalCost,
@@ -2170,7 +2279,8 @@ function combineWrappedStats(claude, codex) {
     modelBreakdown: combinedBreakdown,
     wordsGenerated: claude.wordsGenerated + codex.wordsGenerated,
     firstSessionDate,
-    source: "combined"
+    source: "combined",
+    sessionCounts
   };
 }
 
@@ -2196,6 +2306,9 @@ function getColors2(theme) {
   }
   return colors2;
 }
+function formatCount2(n) {
+  return n.toLocaleString("en-US");
+}
 function displayWrappedStats(stats, url, options) {
   const c = getColors2(options?.theme);
   console.log();
@@ -2224,6 +2337,11 @@ function displayWrappedStats(stats, url, options) {
     `${c.amber}${c.bold}${stats.daysActive}${c.reset} days active`
   ];
   console.log(`  ${statsLine.join("  \u2502  ")}`);
+  if (stats.sessionCounts) {
+    console.log(
+      `  ${c.dim}Tracked mix: ${formatCount2(stats.sessionCounts.main)} main, ${formatCount2(stats.sessionCounts.subagent)} subagents${c.reset}`
+    );
+  }
   console.log();
   console.log(`${c.bold}\u{1F525} Consistency${c.reset}`);
   console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
@@ -2369,11 +2487,164 @@ async function publishArtifact(artifact, baseUrl, legacyUrl) {
   }
 }
 
-// src/config.ts
-import { readFileSync, existsSync, writeFileSync } from "fs";
+// src/claude-inspector.ts
+import { promises as fs4 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
-var CONFIG_PATH = join4(homedir4(), ".vibestats.json");
+function getClaudeDir3() {
+  return process.env.CLAUDE_HOME || join4(homedir4(), ".claude");
+}
+async function pathExists4(path) {
+  try {
+    await fs4.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile(path) {
+  try {
+    const content = await fs4.readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function walkFiles(dir, visitor) {
+  if (!await pathExists4(dir)) return;
+  let entries;
+  try {
+    entries = await fs4.readdir(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry);
+    let stat;
+    try {
+      stat = await fs4.stat(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      await walkFiles(fullPath, visitor);
+    } else {
+      await visitor(fullPath, entry);
+    }
+  }
+}
+function daysSince(dateStr) {
+  if (!dateStr) return null;
+  const parsed = /* @__PURE__ */ new Date(`${dateStr}T12:00:00`);
+  if (Number.isNaN(parsed.getTime())) return null;
+  const diffMs = Date.now() - parsed.getTime();
+  return Math.max(0, Math.floor(diffMs / (24 * 60 * 60 * 1e3)));
+}
+async function inspectClaudeSystem(home = homedir4()) {
+  const path = join4(home, ".claude.json");
+  const json = await readJsonFile(path);
+  return {
+    path,
+    exists: Boolean(json),
+    oauthAccount: json?.oauthAccount || null,
+    hasAvailableSubscription: json?.hasAvailableSubscription,
+    cachedExtraUsageDisabledReason: json?.cachedExtraUsageDisabledReason,
+    subscriptionNoticeCount: json?.subscriptionNoticeCount,
+    toolUsageCount: json?.toolUsage ? Object.keys(json.toolUsage).length : void 0,
+    skillUsageCount: json?.skillUsage ? Object.keys(json.skillUsage).length : void 0,
+    projectCount: json?.projects ? Object.keys(json.projects).length : void 0
+  };
+}
+async function inspectClaudeUsage(claudeDir = getClaudeDir3()) {
+  const statsCachePath = join4(claudeDir, "stats-cache.json");
+  const statsCache = await readJsonFile(statsCachePath);
+  const facetsDir = join4(claudeDir, "usage-data", "facets");
+  const sessionMetaDir = join4(claudeDir, "usage-data", "session-meta");
+  const projectsDir = join4(claudeDir, "projects");
+  const facetFiles = await pathExists4(facetsDir) ? (await fs4.readdir(facetsDir)).filter((file) => file.endsWith(".json")) : [];
+  const sessionMetaFiles = await pathExists4(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(join4(facetsDir, file));
+    const friction = json?.friction_counts || {};
+    rateLimitHit += friction.rate_limit_hit || 0;
+    apiTokenLimit += friction.api_token_limit || 0;
+    contextLimit += friction.context_limit || 0;
+  }
+  let sessionsUsingTaskAgent = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const file of sessionMetaFiles) {
+    const json = await readJsonFile(join4(sessionMetaDir, file));
+    if (!json) continue;
+    if (json.uses_task_agent) sessionsUsingTaskAgent += 1;
+    inputTokens += json.input_tokens || 0;
+    outputTokens += json.output_tokens || 0;
+  }
+  let mainJsonlFiles = 0;
+  let subagentJsonlFiles = 0;
+  let sessionsIndexFiles = 0;
+  let indexedSessionEntries = 0;
+  await walkFiles(projectsDir, async (fullPath, entryName) => {
+    if (entryName === "sessions-index.json") {
+      sessionsIndexFiles += 1;
+      const indexJson = await readJsonFile(fullPath);
+      if (Array.isArray(indexJson)) {
+        indexedSessionEntries += indexJson.length;
+      } else if (Array.isArray(indexJson?.entries)) {
+        indexedSessionEntries += indexJson.entries.length;
+      }
+      return;
+    }
+    if (!entryName.endsWith(".jsonl")) return;
+    if (fullPath.includes("/subagents/")) {
+      subagentJsonlFiles += 1;
+    } else {
+      mainJsonlFiles += 1;
+    }
+  });
+  return {
+    claudeDir,
+    statsCache: {
+      path: statsCachePath,
+      exists: Boolean(statsCache),
+      lastComputedDate: statsCache?.lastComputedDate,
+      totalSessions: statsCache?.totalSessions,
+      totalMessages: statsCache?.totalMessages,
+      ageDays: daysSince(statsCache?.lastComputedDate)
+    },
+    usageData: {
+      sessionMetaFiles: sessionMetaFiles.length,
+      facetFiles: facetFiles.length
+    },
+    facets: {
+      rateLimitHit,
+      apiTokenLimit,
+      contextLimit
+    },
+    sessionMeta: {
+      sessionsUsingTaskAgent,
+      taskAgentShare: sessionMetaFiles.length > 0 ? Number((sessionsUsingTaskAgent / sessionMetaFiles.length * 100).toFixed(1)) : 0,
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens
+    },
+    projects: {
+      mainJsonlFiles,
+      subagentJsonlFiles,
+      sessionsIndexFiles,
+      indexedSessionEntries
+    }
+  };
+}
+
+// src/config.ts
+import { readFileSync, existsSync, writeFileSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+var CONFIG_PATH = join5(homedir5(), ".vibestats.json");
 var DEFAULT_CONFIG = {
   baseUrl: "https://vibestats.wolfai.dev",
   outputFormat: "normal",
@@ -2579,7 +2850,7 @@ async function publishArtifactWithFallback(artifact, baseUrl, fallbackUrl, prefe
 var main = defineCommand({
   meta: {
     name: "vibestats",
-    version: "1.3.7",
+    version: "1.3.8",
     description: "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex"
   },
   args: {
@@ -2708,6 +2979,16 @@ var main = defineCommand({
       type: "boolean",
       description: "Show current config location and values",
       default: false
+    },
+    "claude-system": {
+      type: "boolean",
+      description: "Inspect ~/.claude.json account and app state",
+      default: false
+    },
+    "claude-limits": {
+      type: "boolean",
+      description: "Inspect Claude usage-data, cache freshness, and local limit signals",
+      default: false
     }
   },
   async run({ args }) {
@@ -2721,6 +3002,14 @@ var main = defineCommand({
       console.log(JSON.stringify(config, null, 2));
       return;
     }
+    if (args["claude-system"]) {
+      await runClaudeSystem(args);
+      return;
+    }
+    if (args["claude-limits"]) {
+      await runClaudeLimits(args);
+      return;
+    }
     if (args.activity) {
       await runActivity(args, config);
     } else if (args.wrapped) {
@@ -2942,10 +3231,67 @@ async function runActivity(args, config) {
     imageUrl: shared?.imageUrl || null
   });
 }
+async function runClaudeSystem(args) {
+  const summary = await inspectClaudeSystem();
+  if (args.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  console.log("Claude System");
+  console.log(`Path: ${summary.path}`);
+  console.log(`Exists: ${summary.exists ? "yes" : "no"}`);
+  if (!summary.exists) return;
+  console.log(`Billing type: ${summary.oauthAccount?.billingType || "unknown"}`);
+  console.log(`Extra usage enabled: ${summary.oauthAccount?.hasExtraUsageEnabled === true ? "yes" : "no"}`);
+  console.log(`Available subscription: ${summary.hasAvailableSubscription === true ? "yes" : "no"}`);
+  console.log(`Extra usage disabled reason: ${summary.cachedExtraUsageDisabledReason || "none"}`);
+  console.log(`Subscription notices shown: ${formatPlainNumber(summary.subscriptionNoticeCount)}`);
+  console.log(`Tracked tools in root file: ${formatPlainNumber(summary.toolUsageCount)}`);
+  console.log(`Tracked skills in root file: ${formatPlainNumber(summary.skillUsageCount)}`);
+  console.log(`Tracked projects in root file: ${formatPlainNumber(summary.projectCount)}`);
+}
+async function runClaudeLimits(args) {
+  const diagnostics = await inspectClaudeUsage();
+  if (args.json) {
+    console.log(JSON.stringify(diagnostics, null, 2));
+    return;
+  }
+  console.log("Claude Limits");
+  console.log(`Claude dir: ${diagnostics.claudeDir}`);
+  console.log(`Stats cache: ${diagnostics.statsCache.path}`);
+  console.log(
+    `Stats cache freshness: ${diagnostics.statsCache.exists ? `${diagnostics.statsCache.lastComputedDate || "unknown"} (${formatPlainNumber(diagnostics.statsCache.ageDays ?? void 0)} days old)` : "missing"}`
+  );
+  console.log(
+    `Stats cache totals: ${formatPlainNumber(diagnostics.statsCache.totalSessions)} sessions, ${formatPlainNumber(diagnostics.statsCache.totalMessages)} messages`
+  );
+  console.log(
+    `Usage-data files: ${formatPlainNumber(diagnostics.usageData.sessionMetaFiles)} session-meta, ${formatPlainNumber(diagnostics.usageData.facetFiles)} facets`
+  );
+  console.log(
+    `Facet limits: ${formatPlainNumber(diagnostics.facets.rateLimitHit)} rate-limit hits, ${formatPlainNumber(diagnostics.facets.apiTokenLimit)} api-token limits, ${formatPlainNumber(diagnostics.facets.contextLimit)} context limits`
+  );
+  console.log(
+    `Task-agent share: ${formatPlainNumber(diagnostics.sessionMeta.sessionsUsingTaskAgent)} / ${formatPlainNumber(diagnostics.usageData.sessionMetaFiles)} sessions (${diagnostics.sessionMeta.taskAgentShare}%)`
+  );
+  console.log(
+    `Session-meta tokens: ${formatNumber2(diagnostics.sessionMeta.totalTokens)} total (${formatNumber2(diagnostics.sessionMeta.inputTokens)} in, ${formatNumber2(diagnostics.sessionMeta.outputTokens)} out)`
+  );
+  console.log(
+    `Project logs: ${formatPlainNumber(diagnostics.projects.mainJsonlFiles)} main JSONL files, ${formatPlainNumber(diagnostics.projects.subagentJsonlFiles)} subagent JSONL files`
+  );
+  console.log(
+    `Session indexes: ${formatPlainNumber(diagnostics.projects.sessionsIndexFiles)} files, ${formatPlainNumber(diagnostics.projects.indexedSessionEntries)} indexed entries`
+  );
+}
 function formatNumber2(n) {
   if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
   if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
   return n.toString();
 }
+function formatPlainNumber(n) {
+  if (typeof n !== "number") return "unknown";
+  return n.toLocaleString("en-US");
+}
 runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestats",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "description": "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,6 +18,12 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --dts --clean --shims",
+    "test": "tsx --test src/**/*.test.ts",
+    "prepublishOnly": "pnpm build"
+  },
   "keywords": [
     "claude",
     "claude-code",
@@ -45,10 +51,5 @@
   },
   "engines": {
     "node": ">=18.0.0"
-  },
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "tsup src/index.ts --format esm --dts --clean --shims",
-    "test": "tsx --test src/**/*.test.ts"
   }
-}
+}