tokentracker-cli 0.94.0 → 0.95.0

package/src/commands/sync.js

@@ -15,6 +15,7 @@ const {
   chmod600IfPossible,
   openLock,
   inspectLock,
+  updateJsonLocked,
 } = require("../lib/fs");
 const { physicalJsonlRecords } = require("../lib/jsonl-lines");
 const {
@@ -104,6 +105,10 @@ const {
   parseRoocodeIncremental,
   resolveZedDbPath,
   parseZedIncremental,
+  resolveLmstudioLogFiles,
+  parseLmstudioIncremental,
+  resolveUnslothDbPath,
+  parseUnslothIncremental,
   resolveAnythingllmDbPath,
   parseAnythingllmIncremental,
   resolveGooseDbPath,
@@ -260,6 +265,7 @@ const CODEX_COLD_SCAN_AUDIT_MAX_SYNCS = 288;
 const MIMO_PROVIDER_REPAIR_KEY = "mimoClaudeMislabelRepair_2026_06";
 const DSH_LEGACY_SOURCE_MIGRATION_KEY = "deepseekHarnessSourceMigration_2026_08";
 const ZCODE_NATIVE_USAGE_REPAIR_KEY = "zcodeNativeUsageRepair_2026_08";
+const ZCODE_INCLUSIVE_TOKEN_REPAIR_KEY = "zcodeInclusiveTokenRepair_2026_09";
 const AUTO_SYNC_SOURCE_ALIASES = new Map([
   ["code", "every-code"],
   ["deepseek", "dsh"],
@@ -291,6 +297,7 @@ const AUTO_SYNC_SOURCES = new Set([
   "kiro",
   "kimi",
   "kimi-code",
+  "lmstudio",
   "mimo",
   "omp",
   "opencode",
@@ -301,6 +308,7 @@ const AUTO_SYNC_SOURCES = new Set([
   "reasonix",
   "roocode",
   "trae-cn",
+  "unsloth",
   "workbuddy",
   "zcode",
   "zed",
@@ -561,6 +569,8 @@ async function cmdSync(argv, context = {}) {
       legacyBaseUrlMigration = {
         previousDeviceToken,
         replacementDeviceToken,
+        hadPersistedAnonKey: Object.prototype.hasOwnProperty.call(config, "anonKey"),
+        persistedAnonKey: config.anonKey,
       };
     }
     const codexCursorRoots = [process.env.CODEX_HOME || path.join(home, ".codex")];
@@ -1432,6 +1442,13 @@ async function cmdSync(argv, context = {}) {
               projectQueueStatePath,
             });
           }
+          await repairZcodeInclusiveTokenMigration({
+            cursors,
+            queuePath,
+            queueStatePath,
+            projectQueuePath,
+            projectQueueStatePath,
+          });
           zcodeResult = await multiInstallParse({
             paths: zcodePaths, parserFn: parseOpencodeDbForInstall, providerName: "zcode",
             cursors, getParams: (p) => ({ dbPath: p, readFn: readZcodeDbMessages, source: "zcode", cursorKey: "zcode" }),
@@ -1477,6 +1494,47 @@ async function cmdSync(argv, context = {}) {
       }
     }
 
+    // ── LM Studio and Unsloth Studio — passive inference usage ──
+    let lmstudioResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (sourceAllowed("lmstudio")) {
+      const lmstudioLogFiles = await resolveLmstudioLogFiles(process.env);
+      if (lmstudioLogFiles.length > 0) {
+        if (progress?.enabled) {
+          progress.start(
+            `Parsing LM Studio ${renderBar(0)} 0/${formatNumber(lmstudioLogFiles.length)} logs | buckets 0`,
+          );
+        }
+        try {
+          lmstudioResult = await parseLmstudioIncremental({
+            logFiles: lmstudioLogFiles,
+            cursors,
+            queuePath,
+            onProgress: makeProviderProgress("LM Studio"),
+          });
+        } catch (err) {
+          warnProviderParseFailure("LM Studio", err, opts);
+        }
+      }
+    }
+
+    let unslothResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (sourceAllowed("unsloth")) {
+      const unslothDbPath = resolveUnslothDbPath(process.env);
+      if (unslothDbPath && fssync.existsSync(unslothDbPath)) {
+        if (progress?.enabled) progress.start(`Parsing Unsloth ${renderBar(0)} | buckets 0`);
+        try {
+          unslothResult = await parseUnslothIncremental({
+            dbPath: unslothDbPath,
+            cursors,
+            queuePath,
+            onProgress: makeProviderProgress("Unsloth"),
+          });
+        } catch (err) {
+          warnProviderParseFailure("Unsloth", err, opts);
+        }
+      }
+    }
+
     // ── AnythingLLM Desktop (workspace_chats.response.metrics) ──
     let anythingllmResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (sourceAllowed("anythingllm")) {
@@ -2747,6 +2805,8 @@ async function cmdSync(argv, context = {}) {
       reasonixResult.recordsProcessed +
       grokResult.recordsProcessed +
       copilotResult.recordsProcessed +
+      lmstudioResult.recordsProcessed +
+      unslothResult.recordsProcessed +
       anythingllmResult.recordsProcessed +
       kiloResult.recordsProcessed +
       mimoResult.recordsProcessed +
@@ -2783,6 +2843,8 @@ async function cmdSync(argv, context = {}) {
       reasonixResult.bucketsQueued +
       grokResult.bucketsQueued +
       copilotResult.bucketsQueued +
+      lmstudioResult.bucketsQueued +
+      unslothResult.bucketsQueued +
       anythingllmResult.bucketsQueued +
       kiloResult.bucketsQueued +
       mimoResult.bucketsQueued +
@@ -2835,6 +2897,9 @@ async function cmdSync(argv, context = {}) {
     progress?.stop();
 
     const runtimeConfig = config ? { ...config } : {};
+    if (legacyBaseUrlMigration) {
+      delete runtimeConfig.anonKey;
+    }
     if (legacyBaseUrlMigration?.replacementDeviceToken) {
       runtimeConfig.deviceToken = legacyBaseUrlMigration.replacementDeviceToken;
     }
@@ -2888,6 +2953,7 @@ async function cmdSync(argv, context = {}) {
         const drainWithToken = (deviceToken) =>
           drainQueueToCloud({
             baseUrl: runtime.baseUrl,
+            anonKey: runtime.anonKey,
             deviceToken,
             queuePath,
             queueStatePath,
@@ -2917,15 +2983,25 @@ async function cmdSync(argv, context = {}) {
         if (legacyBaseUrlMigration && uploadResult.batches > 0) {
           // device-login does not share the sync lock and may have written a
           // fresh current-backend config while the scan/upload was running.
-          // Re-read before committing, merge only while the legacy marker still
-          // exists, and never clobber a concurrently completed login.
-          const latestConfig = (await readJson(configPath)) || config;
-          if (isLegacyInsforgeBaseUrl(latestConfig.baseUrl)) {
-            latestConfig.deviceToken = successfulDeviceToken;
-            delete latestConfig.baseUrl;
-            await writeJson(configPath, latestConfig);
-            await chmod600IfPossible(configPath);
-          }
+          // Re-read before committing and only remove the anonymous key this
+          // migration observed. A concurrent login may replace the backend URL
+          // while preserving the old key, or another writer may replace the key
+          // while the legacy URL is still present.
+          await updateJsonLocked(configPath, async (latestConfig) => {
+            const hasLegacyBaseUrl = isLegacyInsforgeBaseUrl(latestConfig.baseUrl);
+            const hasUnchangedLegacyAnonKey =
+              legacyBaseUrlMigration.hadPersistedAnonKey &&
+              latestConfig.anonKey === legacyBaseUrlMigration.persistedAnonKey;
+            if (!hasLegacyBaseUrl && !hasUnchangedLegacyAnonKey) return null;
+            if (hasLegacyBaseUrl) {
+              latestConfig.deviceToken = successfulDeviceToken;
+              delete latestConfig.baseUrl;
+            }
+            if (hasUnchangedLegacyAnonKey) {
+              delete latestConfig.anonKey;
+            }
+            return latestConfig;
+          });
         }
         // Record success so the exponential backoff step resets — otherwise
         // a single past failure keeps us pessimistically throttled forever.
@@ -3138,6 +3214,7 @@ module.exports = {
   repairDroidDuplicateSessionInflation,
   repairMimoClaudeMislabel,
   repairZcodeNativeUsageMigration,
+  repairZcodeInclusiveTokenMigration,
   reincludeClaudeMemObserverFiles,
   repairGrokQueueFromSessionSnapshots,
   applyCloudConversationsBackfill,
@@ -3613,7 +3690,7 @@ const AUTO_RETRY_MAX_DELAY_MS = 2 * 60 * 60 * 1000;
 const INGEST_SLUG = "tokentracker-ingest";
 const MAX_INGEST_BUCKETS = 500;
 
-async function drainQueueToCloud({ baseUrl, deviceToken, queuePath, queueStatePath, maxBatches = 5, batchSize = 200 }) {
+async function drainQueueToCloud({ baseUrl, anonKey, deviceToken, queuePath, queueStatePath, maxBatches = 5, batchSize = 200 }) {
   const state = (await readJson(queueStatePath)) || { offset: 0 };
   let offset = Number(state.offset || 0);
   let inserted = 0;
@@ -3632,7 +3709,6 @@ async function drainQueueToCloud({ baseUrl, deviceToken, queuePath, queueStatePa
     if (result.buckets.length === 0 && result.sessionStates.length === 0) break;
 
     const root = baseUrl.replace(/\/$/, "");
-    const anonKey = process.env.TOKENTRACKER_INSFORGE_ANON_KEY || "";
     const headers = {
       "Content-Type": "application/json",
       Accept: "application/json",
@@ -4116,7 +4192,7 @@ async function repairMimoClaudeMislabel({
   return true;
 }
 
-async function resetUploadOffsetForZcodeNativeRepair(queueStatePath) {
+async function resetUploadOffsetForZcodeRepair(queueStatePath, note) {
   if (typeof queueStatePath !== "string" || !queueStatePath) return false;
   let state = {};
   try {
@@ -4126,7 +4202,7 @@ async function resetUploadOffsetForZcodeNativeRepair(queueStatePath) {
   }
   state.offset = 0;
   state.updatedAt = new Date().toISOString();
-  state.note = "reset_after_zcode_native_usage_repair_2026_08";
+  state.note = note;
   await ensureDir(path.dirname(queueStatePath));
   await fs.writeFile(queueStatePath, JSON.stringify(state, null, 2) + "\n", "utf8");
   return true;
@@ -4188,7 +4264,9 @@ async function dropZcodeQueueRows(filePath, { retainRetractions = false } = {})
   return { removed, retractions: retractions.size };
 }
 
-async function repairZcodeNativeUsageMigration({
+async function repairZcodeUsageMigration({
+  migrationKey,
+  queueStateNote,
   cursors,
   queuePath,
   queueStatePath,
@@ -4197,7 +4275,7 @@ async function repairZcodeNativeUsageMigration({
 } = {}) {
   if (!cursors || typeof cursors !== "object") return false;
   const migrations = (cursors.migrations ||= {});
-  if (migrations[ZCODE_NATIVE_USAGE_REPAIR_KEY]) return false;
+  if (migrations[migrationKey]) return false;
 
   const mainRepair = await dropZcodeQueueRows(queuePath, { retainRetractions: true });
   const projectRepair = projectQueuePath
@@ -4225,11 +4303,13 @@ async function repairZcodeNativeUsageMigration({
   }
   delete cursors.zcode;
 
-  if (mainRepair.removed > 0) await resetUploadOffsetForZcodeNativeRepair(queueStatePath);
+  if (mainRepair.removed > 0) {
+    await resetUploadOffsetForZcodeRepair(queueStatePath, queueStateNote);
+  }
   if (projectRepair.removed > 0) {
-    await resetUploadOffsetForZcodeNativeRepair(projectQueueStatePath);
+    await resetUploadOffsetForZcodeRepair(projectQueueStatePath, queueStateNote);
   }
-  migrations[ZCODE_NATIVE_USAGE_REPAIR_KEY] = {
+  migrations[migrationKey] = {
     appliedAt: new Date().toISOString(),
     removedMain: mainRepair.removed,
     removedProject: projectRepair.removed,
@@ -4238,6 +4318,22 @@ async function repairZcodeNativeUsageMigration({
   return true;
 }
 
+async function repairZcodeNativeUsageMigration(options = {}) {
+  return repairZcodeUsageMigration({
+    ...options,
+    migrationKey: ZCODE_NATIVE_USAGE_REPAIR_KEY,
+    queueStateNote: "reset_after_zcode_native_usage_repair_2026_08",
+  });
+}
+
+async function repairZcodeInclusiveTokenMigration(options = {}) {
+  return repairZcodeUsageMigration({
+    ...options,
+    migrationKey: ZCODE_INCLUSIVE_TOKEN_REPAIR_KEY,
+    queueStateNote: "reset_after_zcode_inclusive_token_repair_2026_09",
+  });
+}
+
 async function repairGrokQueueFromSessionSnapshots({ cursors, queuePath, queueStatePath } = {}) {
   if (!cursors || typeof cursors !== "object") return false;
   const grokState = (cursors.grok ||= {});

package/src/lib/cloud-account.js

@@ -73,8 +73,27 @@ function decodeJwtExpMs(token) {
 // The popover polls frequently, so caching avoids hammering /api/auth/refresh.
 let tokenCache = { cacheKey: null, accessToken: null, expMs: 0 };
 
+// In-flight refresh de-duplication ("single flight"), keyed the same way as
+// `tokenCache`. A full popover refresh fires six account reads concurrently; on
+// a cold cache every one of them used to POST /api/auth/refresh with the SAME
+// refresh token. When the backend rotates refresh tokens, the losers of that
+// race present an already-consumed token and fail — which is exactly the
+// intermittent "Activity silently dropped to this-machine data" symptom.
+const mintInflight = new Map();
+
 function __resetCloudAccountCacheForTests() {
   tokenCache = { cacheKey: null, accessToken: null, expMs: 0 };
+  mintInflight.clear();
+}
+
+// Failure classes surfaced to local-api so it can tell an intentional local
+// view ("signed out", "cloud sync off") apart from a temporary cloud outage.
+class AccountAuthError extends Error {
+  constructor(code, message) {
+    super(message || code);
+    this.name = "AccountAuthError";
+    this.code = code;
+  }
 }
 
 function csrfTokenFromRefreshPayload(data) {
@@ -87,30 +106,11 @@ function csrfTokenFromRefreshPayload(data) {
 }
 
 /**
- * Mint (or reuse a cached) InsForge access token from a refresh token.
- * @returns {Promise<{accessToken: string, refreshToken: string|null, csrfToken: string|null}|null>}
- *   null when no refresh token is available or the refresh failed.
+ * Perform the actual refresh POST. Throws a classified `AccountAuthError` on
+ * every failure so callers can distinguish a transient outage (timeout,
+ * offline, rotated-token rejection) from an intentionally local view.
  */
-async function mintAccessToken({
-  baseUrl,
-  anonKey,
-  refreshToken,
-  fetchImpl = fetch,
-  now = Date.now,
-  skewMs = 60_000,
-  timeoutMs,
-} = {}) {
-  if (!refreshToken) return null;
-  const root = String(baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
-  const cacheKey = `${root}\0${refreshToken}`;
-  if (
-    tokenCache.cacheKey === cacheKey &&
-    tokenCache.accessToken &&
-    tokenCache.expMs - skewMs > now()
-  ) {
-    return { accessToken: tokenCache.accessToken, refreshToken: null, csrfToken: null };
-  }
-
+async function performMint({ root, cacheKey, anonKey, refreshToken, fetchImpl, now, timeoutMs }) {
   const headers = { "Content-Type": "application/json", Accept: "application/json" };
   if (anonKey) headers.apikey = anonKey;
 
@@ -132,24 +132,37 @@ async function mintAccessToken({
       body: JSON.stringify({ refresh_token: refreshToken }),
       signal,
     });
-  } catch {
-    return null;
+  } catch (e) {
+    const aborted = e && (e.name === "AbortError" || e.name === "TimeoutError");
+    throw new AccountAuthError(
+      aborted ? "auth_timeout" : "auth_network",
+      e?.message || "token refresh failed",
+    );
   } finally {
     if (timeoutId) {
       clearTimeout(timeoutId);
     }
   }
-  if (!res || !res.ok) return null;
+  if (!res || !res.ok) {
+    const err = new AccountAuthError(
+      "auth_rejected",
+      `token refresh failed with HTTP ${res ? res.status : "?"}`,
+    );
+    err.status = res ? res.status : 0;
+    throw err;
+  }
 
   let data = null;
   try {
     data = await res.json();
-  } catch {
-    return null;
+  } catch (e) {
+    throw new AccountAuthError("auth_invalid", e?.message || "token refresh returned invalid JSON");
   }
 
   const accessToken = accessTokenFromRefreshPayload(data);
-  if (!accessToken) return null;
+  if (!accessToken) {
+    throw new AccountAuthError("auth_invalid", "token refresh returned no access token");
+  }
 
   const expMs = decodeJwtExpMs(accessToken) || now() + 10 * 60_000;
   tokenCache = { cacheKey, accessToken, expMs };
@@ -166,6 +179,60 @@ async function mintAccessToken({
   };
 }
 
+/**
+ * Mint (or reuse a cached) InsForge access token from a refresh token.
+ *
+ * Concurrent callers with the same (baseUrl, refreshToken) share ONE in-flight
+ * refresh; see `mintInflight`.
+ *
+ * @param {boolean} [throwOnFailure] when true, reject with a classified
+ *   `AccountAuthError` instead of resolving to `null`.
+ * @returns {Promise<{accessToken: string, refreshToken: string|null, csrfToken: string|null}|null>}
+ *   null when no refresh token is available or the refresh failed.
+ */
+async function mintAccessToken({
+  baseUrl,
+  anonKey,
+  refreshToken,
+  fetchImpl = fetch,
+  now = Date.now,
+  skewMs = 60_000,
+  timeoutMs,
+  throwOnFailure = false,
+} = {}) {
+  if (!refreshToken) {
+    if (throwOnFailure) throw new AccountAuthError("auth_missing_refresh_token", "not signed in");
+    return null;
+  }
+  const root = String(baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+  const cacheKey = `${root}\0${refreshToken}`;
+  if (
+    tokenCache.cacheKey === cacheKey &&
+    tokenCache.accessToken &&
+    tokenCache.expMs - skewMs > now()
+  ) {
+    return { accessToken: tokenCache.accessToken, refreshToken: null, csrfToken: null };
+  }
+
+  let inflight = mintInflight.get(cacheKey);
+  if (!inflight) {
+    inflight = performMint({ root, cacheKey, anonKey, refreshToken, fetchImpl, now, timeoutMs })
+      .finally(() => {
+        // Only clear our own entry: a later caller may already have started a
+        // fresh mint after this one settled.
+        if (mintInflight.get(cacheKey) === inflight) mintInflight.delete(cacheKey);
+      });
+    mintInflight.set(cacheKey, inflight);
+  }
+
+  try {
+    return await inflight;
+  } catch (e) {
+    if (throwOnFailure) throw e;
+    return null;
+  }
+}
+
 /**
  * GET a `tokentracker-account-*` edge function, forwarding the popover's query
  * params (minus `account`/`scope`, which are local-only routing knobs).
@@ -237,6 +304,7 @@ async function fetchAccountUsage({
 } = {}) {
   const slug = accountSlugFor(usageSlug);
   if (!slug) return null;
+  if (!refreshToken) return null;
 
   const startTime = now();
   const getRemainingTimeout = () => {
@@ -246,6 +314,9 @@ async function fetchAccountUsage({
     return remaining > 0 ? remaining : 1;
   };
 
+  // `throwOnFailure` keeps "not signed in" (null, handled above) distinct from
+  // "signed in but the refresh call failed" (throws) so the caller does not
+  // silently downgrade an account view into a this-machine view.
   const minted = await mintAccessToken({
     baseUrl,
     anonKey,
@@ -253,6 +324,7 @@ async function fetchAccountUsage({
     fetchImpl,
     now,
     timeoutMs: getRemainingTimeout(),
+    throwOnFailure: true,
   });
   if (!minted) return null;
 
@@ -269,6 +341,7 @@ async function fetchAccountUsage({
 }
 
 module.exports = {
+  AccountAuthError,
   USAGE_TO_ACCOUNT_SLUG,
   accountSlugFor,
   accessTokenFromRefreshPayload,

package/src/lib/fs.js

@@ -413,6 +413,35 @@ async function openLock(
   }
 }
 
+async function updateJsonLocked(
+  filePath,
+  update,
+  { timeoutMs = 30_000, retryMs = 10 } = {},
+) {
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + timeoutMs;
+  let lock = null;
+  while (!lock) {
+    lock = await openLock(lockPath, { quietIfLocked: true });
+    if (lock) break;
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting to update JSON file: ${filePath}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, retryMs));
+  }
+
+  try {
+    const current = (await readJson(filePath)) || {};
+    const next = await update(current);
+    if (next == null) return current;
+    await writeJson(filePath, next);
+    await chmod600IfPossible(filePath);
+    return next;
+  } finally {
+    await lock.release();
+  }
+}
+
 module.exports = {
   ensureDir,
   writeFileAtomic,
@@ -422,4 +451,5 @@ module.exports = {
   chmod600IfPossible,
   openLock,
   inspectLock,
+  updateJsonLocked,
 };

package/src/lib/grok-context-breakdown.js

@@ -26,8 +26,9 @@ const {
   sanitizeCommandSignature,
   getExecutableName,
 } = require("./categorizer-utils");
+const { normalizeGrokUsage } = require("./grok-usage");
 
-const CACHE_SCHEMA_VERSION = "grok-context-v2";
+const CACHE_SCHEMA_VERSION = "grok-context-v3";
 const CACHE = new Map();
 // Result-level TTL. Per-file parse cache is the main win when flipping tabs.
 const CACHE_TTL_MS = 5 * 60_000;
@@ -246,31 +247,7 @@ function outputSizeBucket(lines, chars) {
 }
 
 function readUsageTotals(usage) {
-  if (!usage || typeof usage !== "object") return null;
-  const inputRaw = Math.max(0, Number(usage.inputTokens ?? usage.input_tokens ?? 0) || 0);
-  const cached = Math.max(
-    0,
-    Number(usage.cachedReadTokens ?? usage.cache_read_input_tokens ?? usage.cached_input_tokens ?? 0) || 0,
-  );
-  const output = Math.max(0, Number(usage.outputTokens ?? usage.output_tokens ?? 0) || 0);
-  const reasoning = Math.max(
-    0,
-    Number(usage.reasoningTokens ?? usage.reasoning_output_tokens ?? 0) || 0,
-  );
-  const nonCachedInput = Math.max(0, inputRaw - cached);
-  // Prefer the reported totalTokens (authoritative billable total). Fallback
-  // includes reasoning so a missing total still matches usage-parser shape.
-  let total = Math.max(0, Number(usage.totalTokens ?? usage.total_tokens ?? 0) || 0);
-  if (total <= 0) total = nonCachedInput + cached + output + reasoning;
-  if (total <= 0) return null;
-  return {
-    input_tokens: nonCachedInput,
-    cached_input_tokens: cached,
-    cache_creation_input_tokens: 0,
-    output_tokens: output,
-    reasoning_output_tokens: reasoning,
-    total_tokens: total,
-  };
+  return normalizeGrokUsage(usage);
 }
 
 // ---------------------------------------------------------------------------
@@ -778,15 +755,17 @@ async function computeGrokContextBreakdownUncached({
     }))
     .sort((a, b) => (b.totals?.total_tokens || 0) - (a.totals?.total_tokens || 0));
 
-  // Message breakdown: residual "text_response" tools + reasoning/output split
-  const textResponse = toolRows.find((r) => r.name === "text_response");
-  const textTotals = textResponse?.totals || emptyTotals();
+  // Message breakdown uses the same mutually exclusive columns as the parser.
+  // Grok's raw outputTokens includes reasoning, but readUsageTotals has already
+  // split it, so subtracting reasoning here would undercount assistant output.
   const reasoning = Number(grand.reasoning_output_tokens || 0);
-  const assistantOut = Math.max(0, Number(grand.output_tokens || 0) - Math.min(reasoning, Number(grand.output_tokens || 0)));
+  const assistantOut = Number(grand.output_tokens || 0);
   // For Grok, cached reads dominate conversation history; non-cached input is
   // closer to "current user/context injection". Heuristic only — matches Codex
   // message_breakdown intent without reading message bodies.
-  const historyTokens = Number(grand.cached_input_tokens || 0);
+  const cachedHistoryTokens = Number(grand.cached_input_tokens || 0);
+  const cacheCreationTokens = Number(grand.cache_creation_input_tokens || 0);
+  const historyTokens = cachedHistoryTokens + cacheCreationTokens;
   const userish = Number(grand.input_tokens || 0);
   const messageBreakdown = [
     {
@@ -806,8 +785,8 @@ async function computeGrokContextBreakdownUncached({
       name: "Conversation history",
       totals: roundTotals({
         input_tokens: 0,
-        cached_input_tokens: historyTokens,
-        cache_creation_input_tokens: 0,
+        cached_input_tokens: cachedHistoryTokens,
+        cache_creation_input_tokens: cacheCreationTokens,
         output_tokens: 0,
         reasoning_output_tokens: 0,
         total_tokens: historyTokens,
@@ -825,6 +804,18 @@ async function computeGrokContextBreakdownUncached({
         total_tokens: assistantOut,
       }),
     },
+    {
+      key: "reasoning",
+      name: "Reasoning",
+      totals: roundTotals({
+        input_tokens: 0,
+        cached_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        output_tokens: 0,
+        reasoning_output_tokens: reasoning,
+        total_tokens: reasoning,
+      }),
+    },
   ].sort((a, b) => (b.totals?.total_tokens || 0) - (a.totals?.total_tokens || 0));
 
   const serializeExecRows = (rows) =>