llm-usage-metrics 0.5.0 → 0.5.2

package/dist/index.js

@@ -106,6 +106,9 @@ function getParsingRuntimeConfig(env = process.env) {
   };
 }
 
+// src/update/update-notifier.ts
+import { spawn as spawn2 } from "child_process";
+
 // src/update/update-cache-repository.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
 import path2 from "path";
@@ -251,8 +254,8 @@ function shouldOfferUpdate(currentVersion, latestVersion) {
 }
 
 // src/update/update-cache-repository.ts
-var DEFAULT_CACHE_TTL_MS = 60 * 60 * 1e3;
-var DEFAULT_FETCH_TIMEOUT_MS = 1e3;
+var DEFAULT_UPDATE_CHECK_CACHE_TTL_MS = 60 * 60 * 1e3;
+var DEFAULT_UPDATE_CHECK_FETCH_TIMEOUT_MS = 1e3;
 var DEFAULT_FETCH_RETRY_COUNT = 2;
 var DEFAULT_FETCH_RETRY_DELAY_MS = 200;
 var UPDATE_CHECK_CACHE_SCOPE_ENV_VAR = "LLM_USAGE_UPDATE_CACHE_SCOPE";
@@ -414,8 +417,8 @@ async function fetchLatestVersionWithRetry(packageName2, fetchImpl, fetchTimeout
 }
 async function resolveLatestVersion(options) {
   const cacheFilePath = options.cacheFilePath ?? getDefaultUpdateCheckCachePath();
-  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
-  const fetchTimeoutMs = options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_UPDATE_CHECK_CACHE_TTL_MS;
+  const fetchTimeoutMs = options.fetchTimeoutMs ?? DEFAULT_UPDATE_CHECK_FETCH_TIMEOUT_MS;
   const fetchRetryCount = options.fetchRetryCount ?? DEFAULT_FETCH_RETRY_COUNT;
   const fetchRetryDelayMs = options.fetchRetryDelayMs ?? DEFAULT_FETCH_RETRY_DELAY_MS;
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -526,6 +529,7 @@ async function runInteractiveInstallAndRestart(options) {
 
 // src/update/update-notifier.ts
 var UPDATE_CHECK_SKIP_ENV_VAR = "LLM_USAGE_SKIP_UPDATE_CHECK";
+var UPDATE_CHECK_REFRESH_ENV_VAR = "LLM_USAGE_REFRESH_UPDATE_CHECK";
 function isTruthyEnvFlag(value) {
   if (value === void 0) {
     return false;
@@ -584,6 +588,32 @@ function toResolveLatestVersionOptions(options, env) {
     now: options.now
   };
 }
+function runDetachedCommandWithSpawn(command, args, options = {}) {
+  const child = spawn2(command, args, {
+    env: options.env,
+    stdio: options.stdio ?? "ignore",
+    detached: true
+  });
+  child.on("error", () => void 0);
+  child.unref();
+}
+function scheduleBackgroundUpdateRefresh(options, env, argv) {
+  const spawnDetachedCommand = options.spawnDetachedCommand ?? runDetachedCommandWithSpawn;
+  spawnDetachedCommand(options.execPath ?? process.execPath, argv.slice(1), {
+    env: {
+      ...env,
+      [UPDATE_CHECK_REFRESH_ENV_VAR]: "1"
+    },
+    stdio: "ignore"
+  });
+}
+async function refreshUpdateCheckCache(options) {
+  try {
+    const env = options.env ?? process.env;
+    await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
+  } catch {
+  }
+}
 async function checkForUpdatesAndMaybeRestart(options) {
   const env = options.env ?? process.env;
   const argv = options.argv ?? process.argv;
@@ -600,7 +630,19 @@ async function checkForUpdatesAndMaybeRestart(options) {
     return { continueExecution: true };
   }
   try {
-    const latestVersion = await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
+    const resolveOptions = toResolveLatestVersionOptions(options, env);
+    const cacheFilePath = resolveOptions.cacheFilePath ?? getDefaultUpdateCheckCachePath();
+    const cachePayload = await readUpdateCheckCachePayload(cacheFilePath);
+    const cacheTtlMs = resolveOptions.cacheTtlMs ?? DEFAULT_UPDATE_CHECK_CACHE_TTL_MS;
+    const now = resolveOptions.now ?? Date.now;
+    if (!cachePayload || !isCacheFresh(cachePayload, cacheTtlMs, now)) {
+      try {
+        scheduleBackgroundUpdateRefresh(options, env, argv);
+      } catch {
+      }
+      return { continueExecution: true };
+    }
+    const latestVersion = cachePayload.latestVersion;
     if (!latestVersion || !shouldOfferUpdate(options.currentVersion, latestVersion)) {
       return { continueExecution: true };
     }
@@ -2260,8 +2302,9 @@ function addOutcomeTotals(left, right) {
   };
 }
 function addUsageTotals(left, right) {
+  const hasAnyBucketUsage = (value) => value.inputTokens > 0 || value.outputTokens > 0 || value.reasoningTokens > 0 || value.cacheReadTokens > 0 || value.cacheWriteTokens > 0;
   const hasUnknownCost = left.costIncomplete === true && left.costUsd === void 0 || right.costIncomplete === true && right.costUsd === void 0;
-  const isNeutralZeroCost = (value) => value.totalTokens === 0 && value.costUsd === 0 && value.costIncomplete !== true;
+  const isNeutralZeroCost = (value) => !hasAnyBucketUsage(value) && value.totalTokens === 0 && value.costUsd === 0 && value.costIncomplete !== true;
   const leftKnownCost = left.costUsd !== void 0 && !isNeutralZeroCost(left) ? left.costUsd : void 0;
   const rightKnownCost = right.costUsd !== void 0 && !isNeutralZeroCost(right) ? right.costUsd : void 0;
   let costUsd = leftKnownCost !== void 0 && rightKnownCost !== void 0 ? addUsd2(leftKnownCost, rightKnownCost) : leftKnownCost ?? rightKnownCost;
@@ -2279,6 +2322,9 @@ function addUsageTotals(left, right) {
     costIncomplete: left.costIncomplete || right.costIncomplete ? true : void 0
   };
 }
+function hasMeaningfulUsageSignal(usageTotals) {
+  return usageTotals.totalTokens > 0 || usageTotals.inputTokens > 0 || usageTotals.outputTokens > 0 || usageTotals.reasoningTokens > 0 || usageTotals.cacheReadTokens > 0 || usageTotals.cacheWriteTokens > 0 || usageTotals.costUsd !== void 0 || usageTotals.costIncomplete === true;
+}
 function computeDerivedMetrics(usage, outcomes) {
   const costUsd = usage.costUsd;
   const nonCacheTotalTokens = usage.inputTokens + usage.outputTokens + usage.reasoningTokens;
@@ -2301,7 +2347,7 @@ function aggregateEfficiency(options) {
     const usageTotals = usageTotalsByPeriod.get(periodKey) ?? createEmptyEfficiencyUsageTotals();
     const outcomeTotals = options.periodOutcomes.get(periodKey) ?? createEmptyEfficiencyOutcomeTotals();
     const hasUsageRow = usageTotalsByPeriod.has(periodKey);
-    const hasUsageSignal3 = hasUsageRow && (usageTotals.totalTokens > 0 || usageTotals.costUsd !== void 0 || usageTotals.costIncomplete === true);
+    const hasUsageSignal3 = hasUsageRow && hasMeaningfulUsageSignal(usageTotals);
     if (outcomeTotals.commitCount === 0 || !hasUsageSignal3) {
       continue;
     }
@@ -2328,7 +2374,7 @@ function aggregateEfficiency(options) {
 }
 
 // src/efficiency/git-outcome-collector.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 import path3 from "path";
 import { stat } from "fs/promises";
@@ -2527,7 +2573,7 @@ function parseGitLogShortstatLines(lines, authorEmail) {
 }
 async function runGitCommand(repoDir, args) {
   return await new Promise((resolve, reject) => {
-    const child = spawn2("git", args, {
+    const child = spawn3("git", args, {
       cwd: repoDir,
       env: {
         ...process.env,
@@ -2812,86 +2858,6 @@ async function attributeUsageEventsToRepo(events, repoDir, resolveRepoRoot3 = re
   };
 }
 
-// src/cli/build-usage-data-diagnostics.ts
-function buildUsageDiagnostics(params) {
-  const parseResultBySource = new Map(
-    params.successfulParseResults.map((result) => [result.source.toLowerCase(), result])
-  );
-  const sessionStats = params.adaptersToParse.map((adapter) => {
-    const parseResult = parseResultBySource.get(adapter.id.toLowerCase());
-    return {
-      source: adapter.id,
-      filesFound: parseResult?.filesFound ?? 0,
-      eventsParsed: parseResult?.events.length ?? 0
-    };
-  });
-  const skippedRows = params.successfulParseResults.filter((result) => result.skippedRows > 0).map((result) => ({
-    source: result.source,
-    skippedRows: result.skippedRows,
-    reasons: result.skippedRowReasons
-  }));
-  return {
-    sessionStats,
-    sourceFailures: params.sourceFailures,
-    skippedRows,
-    pricingOrigin: params.pricingOrigin,
-    pricingWarning: params.pricingWarning,
-    activeEnvOverrides: params.activeEnvOverrides,
-    timezone: params.timezone
-  };
-}
-function assembleUsageDataResult(events, rows, diagnostics) {
-  return {
-    events,
-    rows,
-    diagnostics
-  };
-}
-
-// src/config/env-var-display.ts
-var ENV_VARS_TO_DISPLAY = [
-  { name: "LLM_USAGE_SKIP_UPDATE_CHECK", description: "skip startup update check" },
-  {
-    name: "LLM_USAGE_UPDATE_CACHE_SCOPE",
-    description: "update-check cache scope (global/session)"
-  },
-  { name: "LLM_USAGE_UPDATE_CACHE_SESSION_KEY", description: "update-check session cache key" },
-  { name: "LLM_USAGE_UPDATE_CACHE_TTL_MS", description: "update-check cache TTL" },
-  { name: "LLM_USAGE_UPDATE_FETCH_TIMEOUT_MS", description: "update-check fetch timeout" },
-  { name: "LLM_USAGE_PRICING_CACHE_TTL_MS", description: "pricing cache TTL" },
-  { name: "LLM_USAGE_PRICING_FETCH_TIMEOUT_MS", description: "pricing fetch timeout" },
-  { name: "LLM_USAGE_PARSE_MAX_PARALLEL", description: "max parallel file parsing" },
-  { name: "LLM_USAGE_PARSE_CACHE_ENABLED", description: "enable file parse cache" },
-  { name: "LLM_USAGE_PARSE_CACHE_TTL_MS", description: "file parse cache TTL" },
-  { name: "LLM_USAGE_PARSE_CACHE_MAX_ENTRIES", description: "file parse cache max entries" },
-  { name: "LLM_USAGE_PARSE_CACHE_MAX_BYTES", description: "file parse cache max bytes" }
-];
-function getActiveEnvVarOverrides() {
-  const overrides = [];
-  for (const { name, description } of ENV_VARS_TO_DISPLAY) {
-    const value = process.env[name];
-    if (value !== void 0 && value !== "") {
-      overrides.push({ name, value, description });
-    }
-  }
-  return overrides;
-}
-function formatEnvVarOverrides(overrides) {
-  if (overrides.length === 0) {
-    return [];
-  }
-  const lines = [];
-  lines.push("Active environment overrides:");
-  for (const { name, value, description } of overrides) {
-    lines.push(`  ${name}=${value}  (${description})`);
-  }
-  return lines;
-}
-
-// src/sources/codex/codex-source-adapter.ts
-import os2 from "os";
-import path6 from "path";
-
 // src/domain/provider-normalization.ts
 var billingProviderAliases = /* @__PURE__ */ new Map([
   ["openai-codex", "openai"],
@@ -2901,6 +2867,13 @@ var billingProviderPrefixAliases = [
   ["openai-", "openai"],
   ["openai/", "openai"]
 ];
+var knownCanonicalProviderRoots = /* @__PURE__ */ new Set(["anthropic", "github", "google", "openai"]);
+var explicitModelProviderRootPatterns = [
+  [/^gpt-/u, "openai"],
+  [/^o(?:1|3|4)(?:$|[-.])/u, "openai"],
+  [/^claude(?:$|[-.])/u, "anthropic"],
+  [/^gemini(?:$|[-.])/u, "google"]
+];
 function normalizeProviderToBillingEntity(provider) {
   if (!provider) {
     return void 0;
@@ -2920,6 +2893,73 @@ function normalizeProviderToBillingEntity(provider) {
   }
   return normalizedProvider;
 }
+function matchesCanonicalProviderFilter(provider, providerFilter) {
+  const normalizedFilter = normalizeProviderToBillingEntity(providerFilter);
+  if (!normalizedFilter) {
+    return true;
+  }
+  const normalizedProvider = normalizeProviderToBillingEntity(provider);
+  if (!normalizedProvider) {
+    return false;
+  }
+  return normalizedProvider.includes(normalizedFilter);
+}
+function collectCanonicalProviderRoots(providers) {
+  const canonicalProviders = /* @__PURE__ */ new Set();
+  for (const provider of providers) {
+    const normalizedProvider = normalizeProviderToBillingEntity(provider);
+    if (normalizedProvider) {
+      canonicalProviders.add(normalizedProvider);
+    }
+  }
+  return [...canonicalProviders].sort(compareByCodePoint);
+}
+function resolveExplicitProviderRoots(providerFilter) {
+  if (!providerFilter) {
+    return void 0;
+  }
+  const normalizedProviderFilter = normalizeProviderToBillingEntity(providerFilter);
+  if (!normalizedProviderFilter || !knownCanonicalProviderRoots.has(normalizedProviderFilter)) {
+    return void 0;
+  }
+  return [normalizedProviderFilter];
+}
+function inferCanonicalProviderRootFromModel(model) {
+  const normalizedModel = model.trim().toLowerCase();
+  if (!normalizedModel) {
+    return void 0;
+  }
+  for (const [pattern, providerRoot] of explicitModelProviderRootPatterns) {
+    if (pattern.test(normalizedModel)) {
+      return providerRoot;
+    }
+  }
+  return void 0;
+}
+function inferCanonicalProviderRootsFromModels(models) {
+  if (!models || models.length === 0) {
+    return void 0;
+  }
+  const inferredProviderRoots = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const inferredProviderRoot = inferCanonicalProviderRootFromModel(model);
+    if (!inferredProviderRoot) {
+      return void 0;
+    }
+    inferredProviderRoots.add(inferredProviderRoot);
+  }
+  return [...inferredProviderRoots].sort(compareByCodePoint);
+}
+function intersectCanonicalProviderRoots(left, right) {
+  if (!left) {
+    return right;
+  }
+  if (!right) {
+    return left;
+  }
+  const rightSet = new Set(right);
+  return left.filter((providerRoot) => rightSet.has(providerRoot));
+}
 
 // src/domain/usage-event.ts
 function normalizeSourceId(value) {
@@ -2977,7 +3017,7 @@ function createUsageEvent(input) {
   const cacheWriteTokens = normalizeNonNegativeInteger(input.cacheWriteTokens);
   const declaredTotalTokens = normalizeNonNegativeInteger(input.totalTokens);
   const componentTotalTokens = inputTokens + outputTokens + reasoningTokens + cacheReadTokens + cacheWriteTokens;
-  const totalTokens = declaredTotalTokens > 0 ? declaredTotalTokens : componentTotalTokens;
+  const totalTokens = input.totalTokens === void 0 ? componentTotalTokens : declaredTotalTokens;
   const costUsd = normalizeUsdCost(input.costUsd);
   const costMode = resolveCostMode(input.costMode, costUsd);
   return {
@@ -2997,9 +3037,97 @@ function createUsageEvent(input) {
     costMode
   };
 }
+function hasBillableTokenBuckets(usage) {
+  return usage.inputTokens > 0 || usage.outputTokens > 0 || usage.reasoningTokens > 0 || usage.cacheReadTokens > 0 || usage.cacheWriteTokens > 0;
+}
+function isPriceableEvent(event) {
+  return hasBillableTokenBuckets(event);
+}
+
+// src/cli/build-usage-data-diagnostics.ts
+function buildUsageDiagnostics(params) {
+  const parseResultBySource = new Map(
+    params.successfulParseResults.map((result) => [result.source.toLowerCase(), result])
+  );
+  const sessionStats = params.adaptersToParse.map((adapter) => {
+    const parseResult = parseResultBySource.get(adapter.id.toLowerCase());
+    return {
+      source: adapter.id,
+      filesFound: parseResult?.filesFound ?? 0,
+      eventsParsed: parseResult?.events.length ?? 0
+    };
+  });
+  const skippedRows = params.successfulParseResults.filter((result) => result.skippedRows > 0).map((result) => ({
+    source: result.source,
+    skippedRows: result.skippedRows,
+    reasons: result.skippedRowReasons
+  }));
+  return {
+    sessionStats,
+    sourceFailures: params.sourceFailures,
+    skippedRows,
+    pricingOrigin: params.pricingOrigin,
+    pricingWarning: params.pricingWarning,
+    activeEnvOverrides: params.activeEnvOverrides,
+    timezone: params.timezone,
+    runtimeProfile: params.runtimeProfile
+  };
+}
+function assembleUsageDataResult(events, rows, diagnostics) {
+  return {
+    events,
+    rows,
+    diagnostics
+  };
+}
+
+// src/config/env-var-display.ts
+var ENV_VARS_TO_DISPLAY = [
+  { name: "LLM_USAGE_SKIP_UPDATE_CHECK", description: "skip startup update check" },
+  {
+    name: "LLM_USAGE_UPDATE_CACHE_SCOPE",
+    description: "update-check cache scope (global/session)"
+  },
+  { name: "LLM_USAGE_UPDATE_CACHE_SESSION_KEY", description: "update-check session cache key" },
+  { name: "LLM_USAGE_UPDATE_CACHE_TTL_MS", description: "update-check cache TTL" },
+  { name: "LLM_USAGE_UPDATE_FETCH_TIMEOUT_MS", description: "update-check fetch timeout" },
+  { name: "LLM_USAGE_PRICING_CACHE_TTL_MS", description: "pricing cache TTL" },
+  { name: "LLM_USAGE_PRICING_FETCH_TIMEOUT_MS", description: "pricing fetch timeout" },
+  { name: "LLM_USAGE_PARSE_MAX_PARALLEL", description: "max parallel file parsing" },
+  { name: "LLM_USAGE_PARSE_CACHE_ENABLED", description: "enable file parse cache" },
+  { name: "LLM_USAGE_PARSE_CACHE_TTL_MS", description: "file parse cache TTL" },
+  { name: "LLM_USAGE_PARSE_CACHE_MAX_ENTRIES", description: "file parse cache max entries" },
+  { name: "LLM_USAGE_PARSE_CACHE_MAX_BYTES", description: "file parse cache max bytes" },
+  { name: "LLM_USAGE_PROFILE_RUNTIME", description: "emit runtime profiling diagnostics" }
+];
+function getActiveEnvVarOverrides() {
+  const overrides = [];
+  for (const { name, description } of ENV_VARS_TO_DISPLAY) {
+    const value = process.env[name];
+    if (value !== void 0 && value !== "") {
+      overrides.push({ name, value, description });
+    }
+  }
+  return overrides;
+}
+function formatEnvVarOverrides(overrides) {
+  if (overrides.length === 0) {
+    return [];
+  }
+  const lines = [];
+  lines.push("Active environment overrides:");
+  for (const { name, value, description } of overrides) {
+    lines.push(`  ${name}=${value}  (${description})`);
+  }
+  return lines;
+}
+
+// src/sources/codex/codex-source-adapter.ts
+import os2 from "os";
+import path6 from "path";
 
 // src/utils/discover-files.ts
-import { readdir } from "fs/promises";
+import { readdir, realpath as realpath2, stat as stat2 } from "fs/promises";
 import path5 from "path";
 function getNodeErrorCode2(error) {
   const record = asRecord(error);
@@ -3024,7 +3152,22 @@ function normalizeExtension(extension) {
   }
   return normalized;
 }
-async function walkDirectory(rootDir, acc, options) {
+async function walkDirectory(rootDir, acc, options, ancestryRealPaths) {
+  let resolvedRootDir;
+  try {
+    resolvedRootDir = await realpath2(rootDir);
+  } catch (error) {
+    if (getNodeErrorCode2(error) === "ENOENT") {
+      return;
+    }
+    if (options.allowPermissionSkip && isSkippableDirectoryReadError(error)) {
+      return;
+    }
+    throw error;
+  }
+  if (ancestryRealPaths.has(resolvedRootDir)) {
+    return;
+  }
   let entries;
   try {
     entries = await readdir(rootDir, { withFileTypes: true, encoding: "utf8" });
@@ -3037,13 +3180,37 @@ async function walkDirectory(rootDir, acc, options) {
     }
     throw error;
   }
+  const nextAncestryRealPaths = new Set(ancestryRealPaths);
+  nextAncestryRealPaths.add(resolvedRootDir);
   if (options.sort) {
     entries.sort((left, right) => compareByCodePoint(left.name, right.name));
   }
   for (const entry of entries) {
     const entryPath = path5.join(rootDir, entry.name);
+    if (entry.isSymbolicLink()) {
+      try {
+        const entryStats = await stat2(entryPath);
+        const resolvedEntryPath = await realpath2(entryPath);
+        if (entryStats.isDirectory() && options.recursive) {
+          await walkDirectory(entryPath, acc, options, nextAncestryRealPaths);
+          continue;
+        }
+        if (entryStats.isFile() && (matchesExtension(entry.name, options.extension) || matchesExtension(path5.basename(resolvedEntryPath), options.extension))) {
+          acc.push(entryPath);
+        }
+      } catch (error) {
+        if (getNodeErrorCode2(error) === "ENOENT") {
+          continue;
+        }
+        if (options.allowPermissionSkip && isSkippableDirectoryReadError(error)) {
+          continue;
+        }
+        throw error;
+      }
+      continue;
+    }
     if (entry.isDirectory() && options.recursive) {
-      await walkDirectory(entryPath, acc, options);
+      await walkDirectory(entryPath, acc, options, nextAncestryRealPaths);
       continue;
     }
     if (entry.isFile() && matchesExtension(entry.name, options.extension)) {
@@ -3051,6 +3218,33 @@ async function walkDirectory(rootDir, acc, options) {
     }
   }
 }
+async function toCanonicalFiles(files, options) {
+  const canonicalFiles = [];
+  const seenRealPaths = /* @__PURE__ */ new Set();
+  for (const filePath of files) {
+    let resolvedFilePath;
+    try {
+      resolvedFilePath = await realpath2(filePath);
+    } catch (error) {
+      if (getNodeErrorCode2(error) === "ENOENT") {
+        continue;
+      }
+      if (options.allowPermissionSkip && isSkippableDirectoryReadError(error)) {
+        continue;
+      }
+      throw error;
+    }
+    if (seenRealPaths.has(resolvedFilePath)) {
+      continue;
+    }
+    seenRealPaths.add(resolvedFilePath);
+    canonicalFiles.push(resolvedFilePath);
+  }
+  if (options.sort) {
+    canonicalFiles.sort(compareByCodePoint);
+  }
+  return canonicalFiles;
+}
 async function discoverFiles(rootDir, options) {
   const files = [];
   const resolvedOptions = {
@@ -3059,8 +3253,8 @@ async function discoverFiles(rootDir, options) {
     allowPermissionSkip: options.allowPermissionSkip ?? true,
     sort: options.sort ?? true
   };
-  await walkDirectory(rootDir, files, resolvedOptions);
-  return files;
+  await walkDirectory(rootDir, files, resolvedOptions, /* @__PURE__ */ new Set());
+  return toCanonicalFiles(files, resolvedOptions);
 }
 
 // src/utils/discover-jsonl-files.ts
@@ -3069,7 +3263,7 @@ async function discoverJsonlFiles(rootDir) {
 }
 
 // src/utils/fs-helpers.ts
-import { access as access2, constants as constants2, stat as stat2 } from "fs/promises";
+import { access as access2, constants as constants2, stat as stat3 } from "fs/promises";
 async function pathExists(filePath) {
   try {
     await access2(filePath, constants2.F_OK);
@@ -3088,21 +3282,21 @@ async function pathReadable(filePath) {
 }
 async function pathIsDirectory(filePath) {
   try {
-    return (await stat2(filePath)).isDirectory();
+    return (await stat3(filePath)).isDirectory();
   } catch {
     return false;
   }
 }
 async function pathIsFile(filePath) {
   try {
-    return (await stat2(filePath)).isFile();
+    return (await stat3(filePath)).isFile();
   } catch {
     return false;
   }
 }
 async function pathStat(filePath) {
   try {
-    return await stat2(filePath);
+    return await stat3(filePath);
   } catch {
     return void 0;
   }
@@ -3150,6 +3344,8 @@ async function* readJsonlObjects(filePath, options = {}) {
 }
 
 // src/sources/parsing-utils.ts
+var MIN_PLAUSIBLE_UNIX_SECONDS_ABS = 1e8;
+var UNIX_SECONDS_ABS_CUTOFF = 1e10;
 function asTrimmedText(value) {
   if (typeof value !== "string") {
     return void 0;
@@ -3166,13 +3362,45 @@ function toNumberLike(value) {
   }
   return void 0;
 }
-
-// src/sources/codex/codex-source-adapter.ts
-var defaultSessionsDir = path6.join(os2.homedir(), ".codex", "sessions");
-var LEGACY_CODEX_MODEL_FALLBACK = "legacy-codex-unknown";
-var SESSION_META_LINE_PATTERN = /"type"\s*:\s*"session_meta"/u;
-var TURN_CONTEXT_LINE_PATTERN = /"type"\s*:\s*"turn_context"/u;
-var EVENT_MSG_LINE_PATTERN = /"type"\s*:\s*"event_msg"/u;
+function normalizeTimestampCandidate(candidate) {
+  if (candidate instanceof Date) {
+    return Number.isNaN(candidate.getTime()) ? void 0 : candidate.toISOString();
+  }
+  if (typeof candidate === "number" && Number.isFinite(candidate)) {
+    if (Math.abs(candidate) < MIN_PLAUSIBLE_UNIX_SECONDS_ABS) {
+      return void 0;
+    }
+    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF ? candidate * 1e3 : candidate;
+    const date2 = new Date(timestampMs);
+    if (Number.isNaN(date2.getTime())) {
+      return void 0;
+    }
+    return date2.toISOString();
+  }
+  const normalizedText = asTrimmedText(candidate);
+  if (!normalizedText) {
+    return void 0;
+  }
+  const numericTimestamp = /^-?\d+$/u.test(normalizedText) && normalizedText.length >= 9 ? Number(normalizedText) : NaN;
+  if (Number.isFinite(numericTimestamp)) {
+    return normalizeTimestampCandidate(numericTimestamp);
+  }
+  if (/^-?\d+$/u.test(normalizedText)) {
+    return void 0;
+  }
+  const date = new Date(normalizedText);
+  if (Number.isNaN(date.getTime())) {
+    return void 0;
+  }
+  return date.toISOString();
+}
+
+// src/sources/codex/codex-source-adapter.ts
+var defaultSessionsDir = path6.join(os2.homedir(), ".codex", "sessions");
+var LEGACY_CODEX_MODEL_FALLBACK = "legacy-codex-unknown";
+var SESSION_META_LINE_PATTERN = /"type"\s*:\s*"session_meta"/u;
+var TURN_CONTEXT_LINE_PATTERN = /"type"\s*:\s*"turn_context"/u;
+var EVENT_MSG_LINE_PATTERN = /"type"\s*:\s*"event_msg"/u;
 var TOKEN_COUNT_LINE_PATTERN = /"type"\s*:\s*"token_count"/u;
 function shouldParseCodexJsonlLine(lineText) {
   if (SESSION_META_LINE_PATTERN.test(lineText) || TURN_CONTEXT_LINE_PATTERN.test(lineText)) {
@@ -3221,10 +3449,22 @@ function addUsage(left, right) {
 function hasUsageSignal(usage) {
   return usage.inputTokens > 0 || usage.cacheReadTokens > 0 || usage.outputTokens > 0 || usage.reasoningTokens > 0 || usage.totalTokens > 0;
 }
+function hasUsageRollback(current, previous) {
+  return current.inputTokens < previous.inputTokens || current.cacheReadTokens < previous.cacheReadTokens || current.outputTokens < previous.outputTokens || current.reasoningTokens < previous.reasoningTokens || current.totalTokens < previous.totalTokens;
+}
 function deriveDeltaUsage(info, previousTotalUsage) {
   const totalUsage = toUsage(info.total_token_usage);
   const lastUsage = toUsage(info.last_token_usage);
   if (totalUsage && previousTotalUsage) {
+    if (hasUsageRollback(totalUsage, previousTotalUsage)) {
+      if (lastUsage && hasUsageSignal(lastUsage)) {
+        return { deltaUsage: lastUsage, latestTotalUsage: totalUsage };
+      }
+      return {
+        deltaUsage: hasUsageSignal(totalUsage) ? totalUsage : void 0,
+        latestTotalUsage: totalUsage
+      };
+    }
     const deltaFromTotals = subtractUsage(totalUsage, previousTotalUsage);
     if (hasUsageSignal(deltaFromTotals)) {
       return { deltaUsage: deltaFromTotals, latestTotalUsage: totalUsage };
@@ -3232,7 +3472,7 @@ function deriveDeltaUsage(info, previousTotalUsage) {
     return { latestTotalUsage: totalUsage };
   }
   if (lastUsage) {
-    return { deltaUsage: lastUsage, latestTotalUsage: totalUsage };
+    return { deltaUsage: lastUsage, latestTotalUsage: totalUsage, fromLastUsageOnly: true };
   }
   if (!totalUsage) {
     return {};
@@ -3240,6 +3480,16 @@ function deriveDeltaUsage(info, previousTotalUsage) {
   const deltaUsage = previousTotalUsage ? subtractUsage(totalUsage, previousTotalUsage) : totalUsage;
   return { deltaUsage, latestTotalUsage: totalUsage };
 }
+function createLastUsageOnlyKey(timestamp, usage) {
+  return [
+    timestamp,
+    usage.inputTokens,
+    usage.cacheReadTokens,
+    usage.outputTokens,
+    usage.reasoningTokens,
+    usage.totalTokens
+  ].join(":");
+}
 function getFallbackSessionId(filePath) {
   return path6.basename(filePath, ".jsonl");
 }
@@ -3251,6 +3501,9 @@ function resolveRepoRootFromPayload(payload) {
 }
 var CodexSourceAdapter = class {
   id = "codex";
+  capabilities = {
+    fixedProviderRoots: ["openai"]
+  };
   sessionsDir;
   requireSessionsDir;
   constructor(options = {}) {
@@ -3308,16 +3561,33 @@ var CodexSourceAdapter = class {
       if (!info) {
         continue;
       }
-      const { deltaUsage, latestTotalUsage } = deriveDeltaUsage(info, state.previousTotalUsage);
+      const { deltaUsage, latestTotalUsage, fromLastUsageOnly } = deriveDeltaUsage(
+        info,
+        state.previousTotalUsage
+      );
       if (!deltaUsage || !hasUsageSignal(deltaUsage)) {
+        if (!fromLastUsageOnly) {
+          state.previousLastUsageOnlyKey = void 0;
+        }
         state.previousTotalUsage = latestTotalUsage ?? state.previousTotalUsage;
         continue;
       }
-      const timestamp = asTrimmedText(line.timestamp);
+      const timestamp = normalizeTimestampCandidate(line.timestamp);
       if (!timestamp) {
-        state.previousTotalUsage = latestTotalUsage ?? state.previousTotalUsage;
+        if (!fromLastUsageOnly) {
+          state.previousLastUsageOnlyKey = void 0;
+        }
         continue;
       }
+      if (fromLastUsageOnly) {
+        const currentLastUsageOnlyKey = createLastUsageOnlyKey(timestamp, deltaUsage);
+        if (state.previousLastUsageOnlyKey === currentLastUsageOnlyKey) {
+          continue;
+        }
+        state.previousLastUsageOnlyKey = currentLastUsageOnlyKey;
+      } else {
+        state.previousLastUsageOnlyKey = void 0;
+      }
       const model = state.model ?? LEGACY_CODEX_MODEL_FALLBACK;
       try {
         events.push(
@@ -3379,24 +3649,6 @@ var DROID_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 function shouldParseDroidJsonlLine(lineText) {
   return DROID_SESSION_START_LINE_PATTERN.test(lineText) || DROID_MESSAGE_LINE_PATTERN.test(lineText);
 }
-var UNIX_SECONDS_ABS_CUTOFF = 1e10;
-function normalizeTimestampCandidate(candidate) {
-  let date;
-  if (typeof candidate === "number" && Number.isFinite(candidate)) {
-    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF ? candidate * 1e3 : candidate;
-    date = new Date(timestampMs);
-  } else {
-    const normalizedText = asTrimmedText(candidate);
-    if (!normalizedText) {
-      return void 0;
-    }
-    date = new Date(normalizedText);
-  }
-  if (Number.isNaN(date.getTime())) {
-    return void 0;
-  }
-  return date.toISOString();
-}
 function getSettingsSessionId(filePath) {
   return path7.basename(filePath, ".settings.json");
 }
@@ -3437,6 +3689,9 @@ var DroidSourceAdapter = class {
     }
     return discoverFiles(normalizedDir, { extension: ".settings.json" });
   }
+  async getParseDependencies(filePath) {
+    return [getSiblingJsonlPath(filePath)];
+  }
   async parseFile(filePath) {
     const { events } = await this.parseFileWithDiagnostics(filePath);
     return events;
@@ -3474,7 +3729,8 @@ var DroidSourceAdapter = class {
       toNumberLike(tokenUsage.cacheCreationTokens)
     );
     const billableTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
-    if (billableTokens === 0) {
+    const hasUsageSignal3 = billableTokens > 0 || reasoningTokens > 0;
+    if (!hasUsageSignal3) {
       skippedRows++;
       incrementSkippedReason(skippedRowReasons, "no_token_usage");
       return toParseDiagnostics(events, skippedRows, skippedRowReasons);
@@ -3540,10 +3796,13 @@ var DroidSourceAdapter = class {
 };
 
 // src/sources/gemini/gemini-source-adapter.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
 import os4 from "os";
 import path8 from "path";
 var defaultGeminiDir = path8.join(os4.homedir(), ".gemini");
+function getProjectsJsonPath(geminiDir) {
+  return path8.join(geminiDir, "projects.json");
+}
 function parseProjectsJson(data) {
   const mapping = /* @__PURE__ */ new Map();
   const record = asRecord(data);
@@ -3564,26 +3823,41 @@ function parseProjectsJson(data) {
   return mapping;
 }
 async function loadProjectsJson(geminiDir) {
-  const projectsPath = path8.join(geminiDir, "projects.json");
+  const projectsPath = getProjectsJsonPath(geminiDir);
   try {
     const content = await readFile3(projectsPath, "utf8");
     const parsed = JSON.parse(content);
     return parseProjectsJson(parsed);
-  } catch {
-    return /* @__PURE__ */ new Map();
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return /* @__PURE__ */ new Map();
+    }
+    throw error;
   }
 }
 async function discoverSessionFiles(geminiDir) {
   const tmpDir = path8.join(geminiDir, "tmp");
+  let projectEntries;
+  try {
+    projectEntries = await readdir2(tmpDir, { withFileTypes: true, encoding: "utf8" });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
   const allSessionFiles = [];
-  const discoveredFiles = await discoverFiles(tmpDir, { extension: ".json" });
-  for (const filePath of discoveredFiles) {
-    const parentDir = path8.basename(path8.dirname(filePath));
-    if (parentDir.toLowerCase() === "chats") {
-      allSessionFiles.push(filePath);
+  for (const projectEntry of projectEntries.sort(
+    (left, right) => compareByCodePoint(left.name, right.name)
+  )) {
+    if (!projectEntry.isDirectory() && !projectEntry.isSymbolicLink()) {
+      continue;
     }
+    const chatsDir = path8.join(tmpDir, projectEntry.name, "chats");
+    const discoveredChatFiles = await discoverFiles(chatsDir, { extension: ".json" });
+    allSessionFiles.push(...discoveredChatFiles);
   }
-  return allSessionFiles;
+  return allSessionFiles.sort(compareByCodePoint);
 }
 function resolveRepoRoot(filePath, sessionData, projectMapping) {
   const projectHash = asTrimmedText(sessionData.projectHash);
@@ -3642,21 +3916,13 @@ function extractTokenUsage(tokens) {
     totalTokens
   };
 }
-function normalizeTimestamp2(candidate) {
-  if (typeof candidate !== "string" || isBlankText(candidate)) {
-    return void 0;
-  }
-  const date = new Date(candidate.trim());
-  if (Number.isNaN(date.getTime())) {
-    return void 0;
-  }
-  return date.toISOString();
-}
 var GeminiSourceAdapter = class {
   id = "gemini";
+  capabilities = {
+    fixedProviderRoots: ["google"]
+  };
   geminiDir;
   requireGeminiDir;
-  projectMapping = null;
   constructor(options = {}) {
     this.geminiDir = options.geminiDir ?? defaultGeminiDir;
     this.requireGeminiDir = options.requireGeminiDir ?? false;
@@ -3667,22 +3933,11 @@ var GeminiSourceAdapter = class {
     }
     return this.geminiDir.trim();
   }
-  async getProjectMapping(normalizedGeminiDir) {
-    if (this.projectMapping) {
-      return this.projectMapping;
-    }
-    this.projectMapping = await loadProjectsJson(normalizedGeminiDir);
-    return this.projectMapping;
-  }
   async getProjectMappingForParse() {
-    if (this.projectMapping) {
-      return this.projectMapping;
-    }
     if (isBlankText(this.geminiDir)) {
       return /* @__PURE__ */ new Map();
     }
-    this.projectMapping = await loadProjectsJson(this.geminiDir.trim());
-    return this.projectMapping;
+    return loadProjectsJson(this.geminiDir.trim());
   }
   async discoverFiles() {
     const normalizedDir = this.getNormalizedGeminiDir();
@@ -3692,9 +3947,14 @@ var GeminiSourceAdapter = class {
     if (this.requireGeminiDir && !await pathIsDirectory(normalizedDir)) {
       throw new Error(`Gemini directory is not a directory: ${normalizedDir}`);
     }
-    await this.getProjectMapping(normalizedDir);
     return discoverSessionFiles(normalizedDir);
   }
+  async getParseDependencies() {
+    if (isBlankText(this.geminiDir)) {
+      return [];
+    }
+    return [getProjectsJsonPath(this.getNormalizedGeminiDir())];
+  }
   async parseFile(filePath) {
     const { events } = await this.parseFileWithDiagnostics(filePath);
     return events;
@@ -3745,7 +4005,7 @@ var GeminiSourceAdapter = class {
         incrementSkippedReason(skippedRowReasons, "no_token_usage");
         continue;
       }
-      const timestamp = normalizeTimestamp2(message.timestamp);
+      const timestamp = normalizeTimestampCandidate(message.timestamp);
       if (!timestamp) {
         skippedRows++;
         incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
@@ -3780,8 +4040,15 @@ import path9 from "path";
 function deduplicate(paths) {
   return [...new Set(paths)];
 }
+function normalizeEnvPath(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized || void 0;
+}
 function getLinuxLikeCandidates(homeDir, env) {
-  const xdgDataHome = env.XDG_DATA_HOME ?? path9.join(homeDir, ".local", "share");
+  const xdgDataHome = normalizeEnvPath(env.XDG_DATA_HOME) ?? path9.join(homeDir, ".local", "share");
   return [
     path9.join(xdgDataHome, "opencode", "opencode.db"),
     path9.join(xdgDataHome, "opencode", "db.sqlite"),
@@ -3799,7 +4066,8 @@ function getMacOsCandidates(homeDir) {
   ];
 }
 function getWindowsCandidates(homeDir, env) {
-  const roamingBase = env.APPDATA ?? env.LOCALAPPDATA ?? (env.USERPROFILE ? path9.join(env.USERPROFILE, "AppData", "Roaming") : void 0);
+  const userProfile = normalizeEnvPath(env.USERPROFILE);
+  const roamingBase = normalizeEnvPath(env.APPDATA) ?? normalizeEnvPath(env.LOCALAPPDATA) ?? (userProfile ? path9.join(userProfile, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [
     path9.join(roamingBase, "opencode", "opencode.db"),
     path9.join(roamingBase, "opencode", "db.sqlite")
@@ -3878,33 +4146,6 @@ async function loadNodeSqliteModule() {
 }
 
 // src/sources/opencode/opencode-row-parser.ts
-var UNIX_SECONDS_ABS_CUTOFF2 = 1e10;
-function normalizeTimestampCandidate2(candidate) {
-  if (typeof candidate === "number" && Number.isFinite(candidate)) {
-    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF2 ? candidate * 1e3 : candidate;
-    const date = new Date(timestampMs);
-    if (Number.isNaN(date.getTime())) {
-      return void 0;
-    }
-    return date.toISOString();
-  }
-  if (typeof candidate === "string") {
-    const trimmed = candidate.trim();
-    if (!trimmed) {
-      return void 0;
-    }
-    const numericTimestamp = Number(trimmed);
-    if (Number.isFinite(numericTimestamp)) {
-      return normalizeTimestampCandidate2(numericTimestamp);
-    }
-    const date = new Date(trimmed);
-    if (Number.isNaN(date.getTime())) {
-      return void 0;
-    }
-    return date.toISOString();
-  }
-  return void 0;
-}
 function resolveTimestamp(rowTimestamp, messagePayload) {
   const timestampCandidates = [
     rowTimestamp,
@@ -3913,7 +4154,7 @@ function resolveTimestamp(rowTimestamp, messagePayload) {
     messagePayload.time_created
   ];
   for (const candidate of timestampCandidates) {
-    const resolved = normalizeTimestampCandidate2(candidate);
+    const resolved = normalizeTimestampCandidate(candidate);
     if (resolved) {
       return resolved;
     }
@@ -4229,6 +4470,9 @@ async function sleep2(delayMs) {
     setTimeout(resolve, delayMs);
   });
 }
+function getOpenCodeParseDependencies(dbPath) {
+  return [`${dbPath}-wal`, `${dbPath}-shm`, `${dbPath}-journal`];
+}
 var OpenCodeSourceAdapter = class {
   id = "opencode";
   explicitDbPath;
@@ -4287,6 +4531,12 @@ var OpenCodeSourceAdapter = class {
     const parseDiagnostics = await this.parseFileWithDiagnostics(dbPath);
     return parseDiagnostics.events;
   }
+  async getParseDependencies(dbPath) {
+    if (isBlankText2(dbPath)) {
+      return [];
+    }
+    return getOpenCodeParseDependencies(dbPath.trim());
+  }
   async parseFileWithDiagnostics(dbPath) {
     if (isBlankText2(dbPath)) {
       throw new Error("OpenCode DB path must be a non-empty path");
@@ -4328,29 +4578,10 @@ var PI_MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
 function shouldParsePiJsonlLine(lineText) {
   return PI_MESSAGE_LINE_PATTERN.test(lineText) || PI_SESSION_LINE_PATTERN.test(lineText) || PI_MODEL_CHANGE_LINE_PATTERN.test(lineText);
 }
-var allowAllProviders = () => true;
-var UNIX_SECONDS_ABS_CUTOFF3 = 1e10;
-function normalizeTimestampCandidate3(candidate) {
-  let date;
-  if (typeof candidate === "number" && Number.isFinite(candidate)) {
-    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF3 ? candidate * 1e3 : candidate;
-    date = new Date(timestampMs);
-  } else {
-    const normalizedText = asTrimmedText(candidate);
-    if (!normalizedText) {
-      return void 0;
-    }
-    date = new Date(normalizedText);
-  }
-  if (Number.isNaN(date.getTime())) {
-    return void 0;
-  }
-  return date.toISOString();
-}
 function resolveTimestamp2(line, message, state) {
   const candidates = [line.timestamp, message?.timestamp, state.sessionTimestamp];
   for (const candidate of candidates) {
-    const normalizedTimestamp = normalizeTimestampCandidate3(candidate);
+    const normalizedTimestamp = normalizeTimestampCandidate(candidate);
     if (normalizedTimestamp) {
       return normalizedTimestamp;
     }
@@ -4426,11 +4657,9 @@ function resolveRepoRootFromRecord(record) {
 var PiSourceAdapter = class {
   id = "pi";
   sessionsDir;
-  providerFilter;
   requireSessionsDir;
   constructor(options = {}) {
     this.sessionsDir = options.sessionsDir ?? defaultSessionsDir3;
-    this.providerFilter = options.providerFilter ?? allowAllProviders;
     this.requireSessionsDir = options.requireSessionsDir ?? false;
   }
   async discoverFiles() {
@@ -4473,9 +4702,6 @@ var PiSourceAdapter = class {
         continue;
       }
       const provider = asTrimmedText(line.provider) ?? asTrimmedText(message?.provider) ?? state.provider;
-      if (!this.providerFilter(provider)) {
-        continue;
-      }
       const timestamp = resolveTimestamp2(line, message, state);
       if (!timestamp || !state.sessionId) {
         continue;
@@ -4502,7 +4728,7 @@ var PiSourceAdapter = class {
   }
 };
 
-// src/sources/create-default-adapters.ts
+// src/utils/source-directory-overrides.ts
 function parseSourceDirectoryOverrides(entries) {
   const overrides = /* @__PURE__ */ new Map();
   if (!entries || entries.length === 0) {
@@ -4525,6 +4751,8 @@ function parseSourceDirectoryOverrides(entries) {
   }
   return overrides;
 }
+
+// src/sources/create-default-adapters.ts
 var sourceRegistrations = [
   {
     id: "pi",
@@ -4757,23 +4985,6 @@ function validateBuildOptions(options) {
     normalizedPricingUrl: validatePricingUrl(options.pricingUrl)
   };
 }
-function parseSourceDirOverrideIds(sourceDirEntries) {
-  const overrideIds = /* @__PURE__ */ new Set();
-  if (!sourceDirEntries || sourceDirEntries.length === 0) {
-    return overrideIds;
-  }
-  for (const entry of sourceDirEntries) {
-    const separatorIndex = entry.indexOf("=");
-    if (separatorIndex <= 0) {
-      continue;
-    }
-    const sourceId = entry.slice(0, separatorIndex).trim().toLowerCase();
-    if (sourceId.length > 0) {
-      overrideIds.add(sourceId);
-    }
-  }
-  return overrideIds;
-}
 function resolveExplicitSourceIds(options, sourceFilter) {
   const explicitSourceIds = /* @__PURE__ */ new Set();
   if (sourceFilter) {
@@ -4781,7 +4992,7 @@ function resolveExplicitSourceIds(options, sourceFilter) {
       explicitSourceIds.add(sourceId);
     }
   }
-  for (const sourceId of parseSourceDirOverrideIds(options.sourceDir)) {
+  for (const sourceId of parseSourceDirectoryOverrides(options.sourceDir).keys()) {
     explicitSourceIds.add(sourceId);
   }
   if (options.piDir) {
@@ -4818,24 +5029,84 @@ function normalizeBuildUsageInputs(options) {
   const providerFilter = normalizeProviderFilter(options.provider);
   const sourceFilter = normalizeSourceFilter(options.source);
   const modelFilter = normalizeModelFilter(options.model);
+  const candidateProviderRoots = intersectCanonicalProviderRoots(
+    resolveExplicitProviderRoots(providerFilter),
+    inferCanonicalProviderRootsFromModels(modelFilter)
+  );
   const explicitSourceIds = resolveExplicitSourceIds(options, sourceFilter);
   return {
     timezone,
     providerFilter,
+    candidateProviderRoots,
     sourceFilter,
     modelFilter,
     explicitSourceIds,
     pricingUrl: normalizedPricingUrl
   };
 }
-function selectAdaptersForParsing(adapters, sourceFilter) {
+function selectAdaptersForParsing(adapters, options) {
   const availableSourceIds = new Set(adapters.map((adapter) => adapter.id.toLowerCase()));
-  validateSourceFilterValues(sourceFilter, availableSourceIds);
-  return sourceFilter ? adapters.filter((adapter) => sourceFilter.has(adapter.id.toLowerCase())) : adapters;
+  validateSourceFilterValues(options.sourceFilter, availableSourceIds);
+  const sourceFilter = options.sourceFilter;
+  const selectedBySource = sourceFilter ? adapters.filter((adapter) => sourceFilter.has(adapter.id.toLowerCase())) : adapters;
+  if (!options.candidateProviderRoots) {
+    options.runtimeProfile?.recordSourceSelection({
+      availableSourceIds: adapters.map((adapter) => adapter.id),
+      selectedSourceIds: selectedBySource.map((adapter) => adapter.id)
+    });
+    return selectedBySource;
+  }
+  const candidateProviderRootSet = new Set(options.candidateProviderRoots);
+  const selectedAdapters = selectedBySource.filter((adapter) => {
+    const fixedProviderRoots = adapter.capabilities?.fixedProviderRoots;
+    if (!fixedProviderRoots || fixedProviderRoots.length === 0) {
+      return true;
+    }
+    return fixedProviderRoots.some((providerRoot) => candidateProviderRootSet.has(providerRoot));
+  });
+  options.runtimeProfile?.recordSourceSelection({
+    availableSourceIds: adapters.map((adapter) => adapter.id),
+    selectedSourceIds: selectedAdapters.map((adapter) => adapter.id),
+    candidateProviderRoots: options.candidateProviderRoots
+  });
+  return selectedAdapters;
+}
+function describeExplicitScopeConstraint(options) {
+  const activeFlags = [];
+  if (options.providerFilter) {
+    activeFlags.push("--provider");
+  }
+  if (options.modelFilter && options.modelFilter.length > 0) {
+    activeFlags.push("--model");
+  }
+  if (activeFlags.length === 0) {
+    return "provider/model";
+  }
+  return activeFlags.join("/");
+}
+function throwOnExplicitSourceScopeConflicts(adapters, selectedAdapters, options) {
+  if (!options.candidateProviderRoots || options.explicitSourceIds.size === 0) {
+    return;
+  }
+  const selectedSourceIds = new Set(selectedAdapters.map((adapter) => adapter.id.toLowerCase()));
+  const incompatibleExplicitSources = adapters.filter((adapter) => {
+    const sourceId = adapter.id.toLowerCase();
+    if (!options.explicitSourceIds.has(sourceId) || selectedSourceIds.has(sourceId)) {
+      return false;
+    }
+    const fixedProviderRoots = adapter.capabilities?.fixedProviderRoots;
+    return Boolean(fixedProviderRoots && fixedProviderRoots.length > 0);
+  }).map((adapter) => adapter.id).sort(compareByCodePoint);
+  if (incompatibleExplicitSources.length === 0) {
+    return;
+  }
+  throw new Error(
+    `Explicitly requested source(s) are incompatible with the requested ${describeExplicitScopeConstraint(options)} scope: ${incompatibleExplicitSources.join(", ")}.`
+  );
 }
 
 // src/cli/build-usage-data-parsing.ts
-import { stat as stat4 } from "fs/promises";
+import { stat as stat5 } from "fs/promises";
 
 // src/cli/normalize-skipped-row-reasons.ts
 function toPositiveInteger(value) {
@@ -4863,9 +5134,9 @@ function normalizeSkippedRowReasons(value) {
 }
 
 // src/cli/parse-file-cache.ts
-import { mkdir as mkdir2, readFile as readFile4, rename, rm, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, rename, rm, stat as stat4, writeFile as writeFile2 } from "fs/promises";
 import path11 from "path";
-var PARSE_FILE_CACHE_VERSION = 4;
+var PARSE_FILE_CACHE_VERSION = 5;
 var CACHE_KEY_SEPARATOR = "\0";
 function createCacheKey(source, filePath) {
   return `${source}${CACHE_KEY_SEPARATOR}${filePath}`;
@@ -4956,7 +5227,7 @@ function cloneUsageEvents(events) {
   return events.map((event) => cloneUsageEvent(event));
 }
 function cloneSkippedRowReasons(skippedRowReasons) {
-  return (skippedRowReasons ?? []).map((stat5) => ({ reason: stat5.reason, count: stat5.count }));
+  return (skippedRowReasons ?? []).map((stat6) => ({ reason: stat6.reason, count: stat6.count }));
 }
 function normalizeCachedEvents(value) {
   if (!Array.isArray(value)) {
@@ -4972,6 +5243,94 @@ function normalizeCachedEvents(value) {
   }
   return normalizedEvents;
 }
+function normalizeFingerprintPath(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized || void 0;
+}
+function normalizeParseDependencyFingerprint(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const dependencyPath = normalizeFingerprintPath(record.path);
+  const exists = typeof record.exists === "boolean" ? record.exists : void 0;
+  if (!dependencyPath || exists === void 0) {
+    return void 0;
+  }
+  if (!exists) {
+    return {
+      path: dependencyPath,
+      exists: false
+    };
+  }
+  const size = toNonNegativeInteger(record.size);
+  const mtimeMs = toNonNegativeNumber2(record.mtimeMs);
+  if (size === void 0 || mtimeMs === void 0) {
+    return void 0;
+  }
+  return {
+    path: dependencyPath,
+    exists: true,
+    size,
+    mtimeMs
+  };
+}
+function compareDependencyFingerprint(left, right) {
+  if (left.path !== right.path) {
+    return compareByCodePoint(left.path, right.path);
+  }
+  if (left.exists !== right.exists) {
+    return left.exists ? 1 : -1;
+  }
+  if ((left.size ?? -1) !== (right.size ?? -1)) {
+    return (left.size ?? -1) - (right.size ?? -1);
+  }
+  return (left.mtimeMs ?? -1) - (right.mtimeMs ?? -1);
+}
+function normalizeRuntimeFingerprint(filePath, fingerprint) {
+  const fingerprintRecord = asRecord(fingerprint);
+  if (!fingerprintRecord) {
+    return void 0;
+  }
+  if ("dependencies" in fingerprintRecord && !Array.isArray(fingerprintRecord.dependencies)) {
+    return void 0;
+  }
+  if (Array.isArray(fingerprintRecord.dependencies)) {
+    const normalizedDependencies = [];
+    for (const dependency of fingerprintRecord.dependencies) {
+      const normalizedDependency = normalizeParseDependencyFingerprint(dependency);
+      if (!normalizedDependency) {
+        return void 0;
+      }
+      normalizedDependencies.push(normalizedDependency);
+    }
+    if (normalizedDependencies.length === 0) {
+      return void 0;
+    }
+    normalizedDependencies.sort(compareDependencyFingerprint);
+    return {
+      dependencies: normalizedDependencies
+    };
+  }
+  const size = toNonNegativeInteger(fingerprintRecord.size);
+  const mtimeMs = toNonNegativeNumber2(fingerprintRecord.mtimeMs);
+  if (size === void 0 || mtimeMs === void 0) {
+    return void 0;
+  }
+  return {
+    dependencies: [
+      {
+        path: filePath,
+        exists: true,
+        size,
+        mtimeMs
+      }
+    ]
+  };
+}
 function normalizeCacheEntry(value) {
   const record = asRecord(value);
   if (!record) {
@@ -4980,13 +5339,11 @@ function normalizeCacheEntry(value) {
   const source = normalizeSourceId(record.source)?.toLowerCase() ?? "";
   const filePath = typeof record.filePath === "string" ? record.filePath.trim() : "";
   const cachedAt = toNonNegativeInteger(record.cachedAt);
-  const fingerprint = asRecord(record.fingerprint);
+  const fingerprint = normalizeRuntimeFingerprint(filePath, record.fingerprint);
   const diagnostics = asRecord(record.diagnostics);
-  const size = toNonNegativeInteger(fingerprint?.size);
-  const mtimeMs = toNonNegativeNumber2(fingerprint?.mtimeMs);
   const skippedRows = toNonNegativeInteger(diagnostics?.skippedRows) ?? 0;
   const events = normalizeCachedEvents(diagnostics?.events);
-  if (!source || !filePath || size === void 0 || mtimeMs === void 0 || cachedAt === void 0) {
+  if (!source || !filePath || !fingerprint || cachedAt === void 0) {
     return void 0;
   }
   if (!events) {
@@ -4995,7 +5352,7 @@ function normalizeCacheEntry(value) {
   return {
     source,
     filePath,
-    fingerprint: { size, mtimeMs },
+    fingerprint,
     cachedAt,
     diagnostics: {
       events,
@@ -5051,7 +5408,14 @@ var ParseFileCache = class _ParseFileCache {
       this.dirty = true;
       return void 0;
     }
-    if (entry.fingerprint.size !== fingerprint.size || entry.fingerprint.mtimeMs !== fingerprint.mtimeMs) {
+    const normalizedFingerprint = normalizeRuntimeFingerprint(filePath, fingerprint);
+    if (!normalizedFingerprint) {
+      return void 0;
+    }
+    if (entry.fingerprint.dependencies.length !== normalizedFingerprint.dependencies.length || entry.fingerprint.dependencies.some((dependency, index) => {
+      const candidate = normalizedFingerprint.dependencies[index];
+      return dependency.path !== candidate.path || dependency.exists !== candidate.exists || dependency.size !== candidate.size || dependency.mtimeMs !== candidate.mtimeMs;
+    })) {
       this.entriesByKey.delete(cacheKey);
       this.dirty = true;
       return void 0;
@@ -5064,13 +5428,14 @@ var ParseFileCache = class _ParseFileCache {
   }
   set(source, filePath, fingerprint, diagnostics) {
     const normalizedSource = normalizeCacheSource(source);
+    const normalizedFingerprint = normalizeRuntimeFingerprint(filePath, fingerprint);
+    if (!normalizedFingerprint) {
+      return;
+    }
     this.entriesByKey.set(createCacheKey(normalizedSource, filePath), {
       source: normalizedSource,
       filePath,
-      fingerprint: {
-        size: fingerprint.size,
-        mtimeMs: fingerprint.mtimeMs
-      },
+      fingerprint: normalizedFingerprint,
       cachedAt: this.now(),
       diagnostics: {
         events: cloneUsageEvents(diagnostics.events),
@@ -5111,6 +5476,7 @@ var ParseFileCache = class _ParseFileCache {
     try {
       await writeFile2(temporaryPath, payloadText, "utf8");
       await rename(temporaryPath, this.cacheFilePath);
+      this.replaceEntries(keptEntries);
       this.dirty = false;
     } catch (error) {
       await rm(temporaryPath, { force: true }).catch(() => void 0);
@@ -5133,10 +5499,16 @@ var ParseFileCache = class _ParseFileCache {
       }))
     };
   }
+  replaceEntries(entries) {
+    this.entriesByKey.clear();
+    for (const entry of entries) {
+      this.entriesByKey.set(createCacheKey(entry.source, entry.filePath), entry);
+    }
+  }
   async loadFromDisk() {
     let cacheFileSizeBytes;
     try {
-      const cacheStat = await stat3(this.cacheFilePath);
+      const cacheStat = await stat4(this.cacheFilePath);
       cacheFileSizeBytes = cacheStat.size;
     } catch {
       return;
@@ -5189,6 +5561,8 @@ var ParseFileCache = class _ParseFileCache {
       );
     }
     if (this.entriesByKey.size > this.limits.maxEntries) {
+      const keptEntries = [...this.entriesByKey.values()].sort((left, right) => right.cachedAt - left.cachedAt).slice(0, this.limits.maxEntries);
+      this.replaceEntries(keptEntries);
       this.dirty = true;
     }
   }
@@ -5204,7 +5578,82 @@ function normalizeSkippedRowsCount(value) {
   }
   return Math.max(0, Math.trunc(value));
 }
-async function parseAdapterEvents(adapter, maxParallelFileParsing, parseFileCache) {
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function createParseDependencyFingerprint(filePath, options) {
+  try {
+    const fileStat = await stat5(filePath);
+    return {
+      path: filePath,
+      exists: true,
+      size: fileStat.size,
+      mtimeMs: fileStat.mtimeMs
+    };
+  } catch (error) {
+    if (options.allowMissing && isMissingPathError(error)) {
+      return {
+        path: filePath,
+        exists: false
+      };
+    }
+    return void 0;
+  }
+}
+async function getParseFileFingerprint(adapter, filePath) {
+  const primaryFingerprint = await createParseDependencyFingerprint(filePath, {
+    allowMissing: false
+  });
+  if (!primaryFingerprint) {
+    return void 0;
+  }
+  const additionalDependencyPaths = adapter.getParseDependencies ? await adapter.getParseDependencies(filePath) : [];
+  const uniqueAdditionalDependencyPaths = [...new Set(additionalDependencyPaths)].filter((dependencyPath) => dependencyPath !== filePath).sort(compareByCodePoint);
+  const dependencyFingerprints = [primaryFingerprint];
+  for (const dependencyPath of uniqueAdditionalDependencyPaths) {
+    const dependencyFingerprint = await createParseDependencyFingerprint(dependencyPath, {
+      allowMissing: true
+    });
+    if (!dependencyFingerprint) {
+      return void 0;
+    }
+    dependencyFingerprints.push(dependencyFingerprint);
+  }
+  return {
+    dependencies: dependencyFingerprints
+  };
+}
+function createParseBudget(maxParallelFileParsing) {
+  const safeMaxParallelFileParsing = Number.isFinite(maxParallelFileParsing) && maxParallelFileParsing > 0 ? Math.max(1, Math.floor(maxParallelFileParsing)) : 1;
+  let availablePermits = safeMaxParallelFileParsing;
+  const waitingResolvers = [];
+  async function acquire() {
+    if (availablePermits > 0) {
+      availablePermits -= 1;
+      return;
+    }
+    await new Promise((resolve) => {
+      waitingResolvers.push(resolve);
+    });
+  }
+  function release() {
+    const nextResolver = waitingResolvers.shift();
+    if (nextResolver) {
+      nextResolver();
+      return;
+    }
+    availablePermits += 1;
+  }
+  return async (task) => {
+    await acquire();
+    try {
+      return await task();
+    } finally {
+      release();
+    }
+  };
+}
+async function parseAdapterEvents(adapter, maxParallelFileParsing, runWithParseBudget = async (task) => task(), parseFileCache, runtimeProfile) {
   const files = await adapter.discoverFiles();
   if (files.length === 0) {
     return {
@@ -5225,44 +5674,52 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, parseFileCach
     while (nextFileIndex < files.length) {
       const fileIndex = nextFileIndex;
       nextFileIndex += 1;
-      const filePath = files[fileIndex];
-      let fileFingerprint;
-      let parseFileDiagnostics;
-      if (parseFileCache) {
-        try {
-          const fileStat = await stat4(filePath);
-          fileFingerprint = {
-            size: fileStat.size,
-            mtimeMs: fileStat.mtimeMs
-          };
-          parseFileDiagnostics = parseFileCache.get(adapter.id, filePath, fileFingerprint);
-        } catch {
+      await runWithParseBudget(async () => {
+        const filePath = files[fileIndex];
+        let fileFingerprint;
+        let parseFileDiagnostics;
+        if (parseFileCache) {
+          fileFingerprint = await getParseFileFingerprint(adapter, filePath);
+          if (fileFingerprint) {
+            parseFileDiagnostics = parseFileCache.get(adapter.id, filePath, fileFingerprint);
+            runtimeProfile?.recordParseCacheResult(
+              adapter.id,
+              parseFileDiagnostics ? "hit" : "miss"
+            );
+          }
         }
-      }
-      if (!parseFileDiagnostics) {
-        parseFileDiagnostics = adapter.parseFileWithDiagnostics ? await adapter.parseFileWithDiagnostics(filePath) : getDefaultParseFileDiagnostics(await adapter.parseFile(filePath));
-        if (parseFileCache && fileFingerprint) {
-          parseFileCache.set(adapter.id, filePath, fileFingerprint, parseFileDiagnostics);
+        if (!parseFileDiagnostics) {
+          parseFileDiagnostics = adapter.parseFileWithDiagnostics ? await adapter.parseFileWithDiagnostics(filePath) : getDefaultParseFileDiagnostics(await adapter.parseFile(filePath));
+          if (parseFileCache && fileFingerprint) {
+            parseFileCache.set(adapter.id, filePath, fileFingerprint, parseFileDiagnostics);
+          }
         }
-      }
-      parsedByFile[fileIndex] = parseFileDiagnostics.events;
-      skippedRowsByFile[fileIndex] = normalizeSkippedRowsCount(parseFileDiagnostics.skippedRows);
-      for (const reasonStat of normalizeSkippedRowReasons(parseFileDiagnostics.skippedRowReasons)) {
-        skippedRowReasons.set(
-          reasonStat.reason,
-          (skippedRowReasons.get(reasonStat.reason) ?? 0) + reasonStat.count
-        );
-      }
+        parsedByFile[fileIndex] = parseFileDiagnostics.events;
+        skippedRowsByFile[fileIndex] = normalizeSkippedRowsCount(parseFileDiagnostics.skippedRows);
+        for (const reasonStat of normalizeSkippedRowReasons(
+          parseFileDiagnostics.skippedRowReasons
+        )) {
+          skippedRowReasons.set(
+            reasonStat.reason,
+            (skippedRowReasons.get(reasonStat.reason) ?? 0) + reasonStat.count
+          );
+        }
+      });
     }
   });
   await Promise.all(workers);
-  return {
+  const result = {
     source: adapter.id,
     events: parsedByFile.flat(),
     filesFound: files.length,
     skippedRows: skippedRowsByFile.reduce((sum, skippedRowsCount) => sum + skippedRowsCount, 0),
     skippedRowReasons: [...skippedRowReasons.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareByCodePoint(left.reason, right.reason))
   };
+  runtimeProfile?.recordParseResult(adapter.id, {
+    filesFound: result.filesFound,
+    eventsParsed: result.events.length
+  });
+  return result;
 }
 function getErrorReason(error) {
   if (error instanceof Error) {
@@ -5271,6 +5728,7 @@ function getErrorReason(error) {
   return String(error);
 }
 async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, options = {}) {
+  const runWithParseBudget = createParseBudget(maxParallelFileParsing);
   const parseCacheBySource = /* @__PURE__ */ new Map();
   if (options.parseCache?.enabled) {
     const parseCacheLimits = {
@@ -5279,12 +5737,9 @@ async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, op
       maxBytes: options.parseCache.maxBytes
     };
     const cacheFilePath = options.parseCacheFilePath ?? getDefaultParseFileCachePath();
+    const sourceIds = [...new Set(adaptersToParse.map((adapter) => adapter.id.toLowerCase()))];
     await Promise.all(
-      adaptersToParse.map(async (adapter) => {
-        const sourceId = adapter.id.toLowerCase();
-        if (parseCacheBySource.has(sourceId)) {
-          return;
-        }
+      sourceIds.map(async (sourceId) => {
         parseCacheBySource.set(
           sourceId,
           await ParseFileCache.load({
@@ -5298,9 +5753,19 @@ async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, op
   }
   const parseResults = await Promise.allSettled(
     adaptersToParse.map(
-      (adapter) => parseAdapterEvents(
+      (adapter) => options.runtimeProfile ? options.runtimeProfile.measure(
+        `parse.adapter.${adapter.id}`,
+        () => parseAdapterEvents(
+          adapter,
+          maxParallelFileParsing,
+          runWithParseBudget,
+          parseCacheBySource.get(adapter.id.toLowerCase()),
+          options.runtimeProfile
+        )
+      ) : parseAdapterEvents(
         adapter,
         maxParallelFileParsing,
+        runWithParseBudget,
         parseCacheBySource.get(adapter.id.toLowerCase())
       )
     )
@@ -5335,12 +5800,6 @@ function throwOnExplicitSourceFailures(sourceFailures, explicitSourceIds) {
   const details = explicitFailures.map((failure) => `${failure.source}: ${failure.reason}`).join("; ");
   throw new Error(`Failed to parse explicitly requested source(s): ${details}`);
 }
-function matchesProvider(provider, providerFilter) {
-  if (!providerFilter) {
-    return true;
-  }
-  return provider?.toLowerCase().includes(providerFilter) ?? false;
-}
 function isEventWithinDateRange(event, timezone, since, until) {
   const eventDate = getPeriodKey(event.timestamp, "daily", timezone);
   if (since && eventDate < since) {
@@ -5379,19 +5838,26 @@ function filterByModelRules(events, modelFilter) {
   const modelFilterRules = resolveModelFilterRules(events, modelFilter);
   return events.filter((event) => matchesModel(event.model, modelFilterRules));
 }
-function filterParsedAdapterEvents(parseResults, options) {
-  const providerAndDateFilteredEvents = [];
-  for (const result of parseResults) {
-    for (const event of result.events) {
-      if (!matchesProvider(event.provider, options.providerFilter)) {
+function collectProviderAndDateFilteredEvents(eventGroups, options) {
+  const filteredEvents = [];
+  for (const events of eventGroups) {
+    for (const event of events) {
+      if (!matchesCanonicalProviderFilter(event.provider, options.providerFilter)) {
         continue;
       }
       if (!isEventWithinDateRange(event, options.timezone, options.since, options.until)) {
         continue;
       }
-      providerAndDateFilteredEvents.push(event);
+      filteredEvents.push(event);
     }
   }
+  return filteredEvents;
+}
+function filterParsedAdapterEvents(parseResults, options) {
+  const providerAndDateFilteredEvents = collectProviderAndDateFilteredEvents(
+    parseResults.map((result) => result.events),
+    options
+  );
   return filterByModelRules(providerAndDateFilteredEvents, options.modelFilter);
 }
 
@@ -5412,21 +5878,63 @@ function calculateEstimatedCostUsd(event, pricing) {
   const reasoningCost = reasoningBilling === "separate" ? estimateTokenGroupCost(event.reasoningTokens, pricing.reasoningPer1MUsd) : 0;
   return inputCost + outputCost + cacheReadCost + cacheWriteCost + reasoningCost;
 }
-function applyPricingToEvent(event, pricingSource) {
-  const shouldRepriceExplicitZero = event.costMode === "explicit" && event.costUsd === 0 && event.model !== void 0;
+function hasNonReasoningPricedBuckets(usage) {
+  return usage.inputTokens > 0 || usage.outputTokens > 0 || usage.cacheReadTokens > 0 || usage.cacheWriteTokens > 0;
+}
+function hasDefinedRate(rate) {
+  return rate !== void 0;
+}
+function hasUsedBucketWithUndefinedRate(usage, pricing) {
+  if (usage.inputTokens > 0 && !hasDefinedRate(pricing.inputPer1MUsd)) {
+    return true;
+  }
+  if (usage.outputTokens > 0 && !hasDefinedRate(pricing.outputPer1MUsd)) {
+    return true;
+  }
+  if (usage.cacheReadTokens > 0 && !hasDefinedRate(pricing.cacheReadPer1MUsd)) {
+    return true;
+  }
+  if (usage.cacheWriteTokens > 0 && !hasDefinedRate(pricing.cacheWritePer1MUsd)) {
+    return true;
+  }
+  const reasoningBilling = pricing.reasoningBilling ?? "included-in-output";
+  return usage.reasoningTokens > 0 && reasoningBilling === "separate" && !hasDefinedRate(pricing.reasoningPer1MUsd);
+}
+function canEstimateUsageCost(usage, pricing) {
+  if (hasUsedBucketWithUndefinedRate(usage, pricing)) {
+    return false;
+  }
+  const reasoningBilling = pricing.reasoningBilling ?? "included-in-output";
+  if (usage.reasoningTokens > 0) {
+    if (reasoningBilling === "separate") {
+      return true;
+    }
+    if (usage.outputTokens === 0) {
+      return false;
+    }
+  }
+  return hasNonReasoningPricedBuckets(usage);
+}
+function applyResolvedPricingToEvent(event, pricing) {
+  const shouldRepriceExplicitZero = event.costMode === "explicit" && event.costUsd === 0 && event.model !== void 0 && isPriceableEvent(event);
   if (event.costMode === "explicit" && event.costUsd !== void 0 && !shouldRepriceExplicitZero) {
     return event;
   }
-  if (!event.model) {
+  if (!event.model || !isPriceableEvent(event)) {
     return { ...event, costMode: "estimated" };
   }
-  const pricing = pricingSource.getPricing(event.model);
   if (!pricing) {
     if (shouldRepriceExplicitZero) {
       return event;
     }
     return { ...event, costMode: "estimated" };
   }
+  if (!canEstimateUsageCost(event, pricing)) {
+    if (shouldRepriceExplicitZero) {
+      return event;
+    }
+    return { ...event, costMode: "estimated" };
+  }
   return {
     ...event,
     costUsd: calculateEstimatedCostUsd(event, pricing),
@@ -5434,7 +5942,20 @@ function applyPricingToEvent(event, pricingSource) {
   };
 }
 function applyPricingToEvents(events, pricingSource) {
-  return events.map((event) => applyPricingToEvent(event, pricingSource));
+  const pricingByModel = /* @__PURE__ */ new Map();
+  return events.map((event) => {
+    const model = event.model;
+    let pricing;
+    if (model && isPriceableEvent(event)) {
+      const resolvedModel = pricingSource.resolveModelAlias(model);
+      pricing = pricingByModel.get(resolvedModel);
+      if (!pricingByModel.has(resolvedModel)) {
+        pricing = pricingSource.getPricing(resolvedModel);
+        pricingByModel.set(resolvedModel, pricing);
+      }
+    }
+    return applyResolvedPricingToEvent(event, pricing);
+  });
 }
 
 // src/pricing/litellm-pricing-fetcher.ts
@@ -5481,8 +6002,8 @@ var litellm_model_map_default = {
 
 // src/pricing/litellm-pricing-fetcher.ts
 var ONE_MILLION2 = 1e6;
-var DEFAULT_CACHE_TTL_MS2 = 24 * 60 * 60 * 1e3;
-var DEFAULT_FETCH_TIMEOUT_MS2 = 4e3;
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_FETCH_TIMEOUT_MS = 4e3;
 var DEFAULT_FETCH_RETRY_COUNT2 = 2;
 var DEFAULT_FETCH_RETRY_DELAY_MS2 = 200;
 var DEFAULT_LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
@@ -5707,8 +6228,8 @@ var LiteLLMPricingFetcher = class {
   constructor(options = {}) {
     this.sourceUrl = options.sourceUrl ?? DEFAULT_LITELLM_PRICING_URL;
     this.cacheFilePath = options.cacheFilePath ?? getDefaultLiteLLMPricingCachePath();
-    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS2;
-    this.fetchTimeoutMs = options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS2;
+    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    this.fetchTimeoutMs = options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
     this.fetchRetryCount = Number.isFinite(options.fetchRetryCount) && (options.fetchRetryCount ?? 0) >= 0 ? Math.trunc(options.fetchRetryCount ?? DEFAULT_FETCH_RETRY_COUNT2) : DEFAULT_FETCH_RETRY_COUNT2;
     this.fetchRetryDelayMs = Number.isFinite(options.fetchRetryDelayMs) && (options.fetchRetryDelayMs ?? 0) > 0 ? Math.trunc(options.fetchRetryDelayMs ?? DEFAULT_FETCH_RETRY_DELAY_MS2) : DEFAULT_FETCH_RETRY_DELAY_MS2;
     this.offline = options.offline ?? false;
@@ -6061,7 +6582,7 @@ function eventNeedsPricingLookup(event) {
   if (!event.model) {
     return false;
   }
-  if (event.totalTokens <= 0) {
+  if (!isPriceableEvent(event)) {
     return false;
   }
   return event.costMode !== "explicit" || event.costUsd === void 0 || event.costUsd === 0;
@@ -6072,14 +6593,9 @@ function shouldLoadPricingSource(events) {
   }
   return events.some((event) => eventNeedsPricingLookup(event));
 }
-function hasAnyBillableTokenBuckets(events) {
-  return events.some(
-    (event) => event.inputTokens > 0 || event.outputTokens > 0 || event.reasoningTokens > 0 || event.cacheReadTokens > 0 || event.cacheWriteTokens > 0
-  );
-}
 function shouldLoadPricingSourceForMode(events, pricingLoadMode) {
   if (pricingLoadMode === "force") {
-    return hasAnyBillableTokenBuckets(events);
+    return events.some((event) => isPriceableEvent(event));
   }
   return shouldLoadPricingSource(events);
 }
@@ -6114,6 +6630,195 @@ async function resolveAndApplyPricingToEvents(events, options, runtimeConfig = g
   };
 }
 
+// src/cli/runtime-profile.ts
+var RUNTIME_PROFILE_ENV_VAR = "LLM_USAGE_PROFILE_RUNTIME";
+function isTruthyEnvFlag2(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const normalizedValue = value.trim().toLowerCase();
+  if (normalizedValue.length === 0) {
+    return false;
+  }
+  return ["1", "true", "yes", "on"].includes(normalizedValue);
+}
+function isRuntimeProfileEnabled(env = process.env) {
+  return isTruthyEnvFlag2(env[RUNTIME_PROFILE_ENV_VAR]);
+}
+var RuntimeProfileCollector = class {
+  constructor(now = () => performance.now()) {
+    this.now = now;
+  }
+  sourceSelection;
+  sourceStats = /* @__PURE__ */ new Map();
+  stageDurations = /* @__PURE__ */ new Map();
+  async measure(name, task) {
+    const startedAt = this.now();
+    try {
+      return await task();
+    } finally {
+      this.recordStageDuration(name, this.now() - startedAt);
+    }
+  }
+  measureSync(name, task) {
+    const startedAt = this.now();
+    try {
+      return task();
+    } finally {
+      this.recordStageDuration(name, this.now() - startedAt);
+    }
+  }
+  recordStageDuration(name, durationMs) {
+    if (!name || !Number.isFinite(durationMs) || durationMs < 0) {
+      return;
+    }
+    this.stageDurations.set(name, (this.stageDurations.get(name) ?? 0) + durationMs);
+  }
+  recordSourceSelection(selection) {
+    this.sourceSelection = {
+      availableSourceIds: [...selection.availableSourceIds],
+      selectedSourceIds: [...selection.selectedSourceIds],
+      candidateProviderRoots: selection.candidateProviderRoots ? [...selection.candidateProviderRoots] : void 0
+    };
+  }
+  recordParseCacheResult(source, result) {
+    const sourceStats = this.getOrCreateSourceStats(source);
+    if (result === "hit") {
+      sourceStats.cacheHits += 1;
+      return;
+    }
+    sourceStats.cacheMisses += 1;
+  }
+  recordParseResult(source, result) {
+    const sourceStats = this.getOrCreateSourceStats(source);
+    sourceStats.filesFound += Math.max(0, Math.trunc(result.filesFound));
+    sourceStats.eventsParsed += Math.max(0, Math.trunc(result.eventsParsed));
+  }
+  snapshot() {
+    const sourceStats = [...this.sourceStats.values()].sort(
+      (left, right) => compareByCodePoint(left.source, right.source)
+    );
+    const parseTotals = sourceStats.reduce(
+      (totals, source) => ({
+        filesFound: totals.filesFound + source.filesFound,
+        eventsParsed: totals.eventsParsed + source.eventsParsed
+      }),
+      { filesFound: 0, eventsParsed: 0 }
+    );
+    const parseCache = sourceStats.reduce(
+      (totals, source) => ({
+        hits: totals.hits + source.cacheHits,
+        misses: totals.misses + source.cacheMisses
+      }),
+      { hits: 0, misses: 0 }
+    );
+    const stageTimings = [...this.stageDurations.entries()].sort(([leftName], [rightName]) => compareByCodePoint(leftName, rightName)).map(([name, durationMs]) => ({ name, durationMs }));
+    return {
+      sourceSelection: this.sourceSelection ? {
+        availableSourceIds: [...this.sourceSelection.availableSourceIds],
+        selectedSourceIds: [...this.sourceSelection.selectedSourceIds],
+        candidateProviderRoots: this.sourceSelection.candidateProviderRoots ? [...this.sourceSelection.candidateProviderRoots] : void 0
+      } : void 0,
+      parseCache,
+      parseTotals,
+      sourceStats: sourceStats.map((source) => ({ ...source })),
+      stageTimings
+    };
+  }
+  getOrCreateSourceStats(source) {
+    const existing = this.sourceStats.get(source);
+    if (existing) {
+      return existing;
+    }
+    const created = {
+      source,
+      filesFound: 0,
+      eventsParsed: 0,
+      cacheHits: 0,
+      cacheMisses: 0
+    };
+    this.sourceStats.set(source, created);
+    return created;
+  }
+};
+async function measureRuntimeProfileStage(runtimeProfile, name, task) {
+  if (!runtimeProfile) {
+    return task();
+  }
+  return runtimeProfile.measure(name, task);
+}
+function measureRuntimeProfileStageSync(runtimeProfile, name, task) {
+  if (!runtimeProfile) {
+    return task();
+  }
+  return runtimeProfile.measureSync(name, task);
+}
+function createRuntimeProfileCollector(env = process.env) {
+  if (!isRuntimeProfileEnabled(env)) {
+    return void 0;
+  }
+  return new RuntimeProfileCollector();
+}
+function hasRecordedSourceStats(snapshot) {
+  return snapshot.sourceStats.length > 0;
+}
+function hasRecordedParseCache(snapshot) {
+  return snapshot.parseCache.hits > 0 || snapshot.parseCache.misses > 0 || hasRecordedSourceStats(snapshot);
+}
+function hasRecordedParseTotals(snapshot) {
+  return snapshot.parseTotals.filesFound > 0 || snapshot.parseTotals.eventsParsed > 0 || hasRecordedSourceStats(snapshot);
+}
+function mergeRuntimeProfiles(primary, fallback) {
+  if (!primary) {
+    return fallback;
+  }
+  if (!fallback) {
+    return primary;
+  }
+  const stageTimingsByName = new Map(
+    fallback.stageTimings.map((stageTiming) => [stageTiming.name, stageTiming])
+  );
+  for (const stageTiming of primary.stageTimings) {
+    stageTimingsByName.set(stageTiming.name, stageTiming);
+  }
+  return {
+    sourceSelection: primary.sourceSelection ?? fallback.sourceSelection,
+    parseCache: hasRecordedParseCache(primary) ? primary.parseCache : fallback.parseCache,
+    parseTotals: hasRecordedParseTotals(primary) ? primary.parseTotals : fallback.parseTotals,
+    sourceStats: primary.sourceStats.length > 0 ? primary.sourceStats : fallback.sourceStats,
+    stageTimings: [...stageTimingsByName.values()].sort(
+      (left, right) => compareByCodePoint(left.name, right.name)
+    )
+  };
+}
+function emitRuntimeProfile(runtimeProfile, diagnosticsLogger = logger) {
+  if (!runtimeProfile) {
+    return;
+  }
+  diagnosticsLogger.info("Runtime profile:");
+  if (runtimeProfile.sourceSelection) {
+    const candidateProviderRoots = runtimeProfile.sourceSelection.candidateProviderRoots && runtimeProfile.sourceSelection.candidateProviderRoots.length > 0 ? `; candidateProviderRoots=${runtimeProfile.sourceSelection.candidateProviderRoots.join(",")}` : "";
+    diagnosticsLogger.dim(
+      `  source selection: available=${runtimeProfile.sourceSelection.availableSourceIds.join(",")}; selected=${runtimeProfile.sourceSelection.selectedSourceIds.join(",")}${candidateProviderRoots}`
+    );
+  }
+  diagnosticsLogger.dim(
+    `  parse cache: hits=${runtimeProfile.parseCache.hits}; misses=${runtimeProfile.parseCache.misses}`
+  );
+  diagnosticsLogger.dim(
+    `  parse totals: files=${runtimeProfile.parseTotals.filesFound}; events=${runtimeProfile.parseTotals.eventsParsed}`
+  );
+  for (const source of runtimeProfile.sourceStats) {
+    diagnosticsLogger.dim(
+      `  source ${source.source}: files=${source.filesFound}; events=${source.eventsParsed}; cacheHits=${source.cacheHits}; cacheMisses=${source.cacheMisses}`
+    );
+  }
+  diagnosticsLogger.dim("  stage timings:");
+  for (const stageTiming of runtimeProfile.stageTimings) {
+    diagnosticsLogger.dim(`    ${stageTiming.name}: ${stageTiming.durationMs.toFixed(2)}ms`);
+  }
+}
+
 // src/cli/build-usage-event-dataset.ts
 function withNormalizedPricingUrl(options, normalizedPricingUrl) {
   if (options.pricingUrl === normalizedPricingUrl) {
@@ -6126,33 +6831,57 @@ function withNormalizedPricingUrl(options, normalizedPricingUrl) {
 }
 async function buildUsageEventDataset(options, deps = {}) {
   const normalizedInputs = normalizeBuildUsageInputs(options);
+  const runtimeProfile = deps.runtimeProfile;
   const readParsingRuntimeConfig = deps.getParsingRuntimeConfig ?? getParsingRuntimeConfig;
   const readPricingRuntimeConfig = deps.getPricingFetcherRuntimeConfig ?? getPricingFetcherRuntimeConfig;
   const makeAdapters = deps.createAdapters ?? createDefaultAdapters;
   const parsingRuntimeConfig = readParsingRuntimeConfig();
   const pricingRuntimeConfig = readPricingRuntimeConfig();
-  const adapters = makeAdapters(options);
-  const adaptersToParse = selectAdaptersForParsing(adapters, normalizedInputs.sourceFilter);
-  const { successfulParseResults, sourceFailures } = await parseSelectedAdapters(
-    adaptersToParse,
-    parsingRuntimeConfig.maxParallelFileParsing,
-    {
+  const adapters = measureRuntimeProfileStageSync(
+    runtimeProfile,
+    "usage.dataset.create_adapters",
+    () => makeAdapters(options)
+  );
+  const adaptersToParse = measureRuntimeProfileStageSync(
+    runtimeProfile,
+    "usage.dataset.select_adapters",
+    () => selectAdaptersForParsing(adapters, {
+      sourceFilter: normalizedInputs.sourceFilter,
+      candidateProviderRoots: normalizedInputs.candidateProviderRoots,
+      runtimeProfile
+    })
+  );
+  throwOnExplicitSourceScopeConflicts(adapters, adaptersToParse, {
+    explicitSourceIds: normalizedInputs.explicitSourceIds,
+    candidateProviderRoots: normalizedInputs.candidateProviderRoots,
+    providerFilter: normalizedInputs.providerFilter,
+    modelFilter: normalizedInputs.modelFilter
+  });
+  const { successfulParseResults, sourceFailures } = await measureRuntimeProfileStage(
+    runtimeProfile,
+    "usage.dataset.parse_adapters",
+    () => parseSelectedAdapters(adaptersToParse, parsingRuntimeConfig.maxParallelFileParsing, {
       parseCache: {
         enabled: parsingRuntimeConfig.parseCacheEnabled,
         ttlMs: parsingRuntimeConfig.parseCacheTtlMs,
         maxEntries: parsingRuntimeConfig.parseCacheMaxEntries,
         maxBytes: parsingRuntimeConfig.parseCacheMaxBytes
-      }
-    }
+      },
+      runtimeProfile
+    })
   );
   throwOnExplicitSourceFailures(sourceFailures, normalizedInputs.explicitSourceIds);
-  const filteredEvents = filterParsedAdapterEvents(successfulParseResults, {
-    timezone: normalizedInputs.timezone,
-    since: options.since,
-    until: options.until,
-    providerFilter: normalizedInputs.providerFilter,
-    modelFilter: normalizedInputs.modelFilter
-  });
+  const filteredEvents = measureRuntimeProfileStageSync(
+    runtimeProfile,
+    "usage.dataset.filter_events",
+    () => filterParsedAdapterEvents(successfulParseResults, {
+      timezone: normalizedInputs.timezone,
+      since: options.since,
+      until: options.until,
+      providerFilter: normalizedInputs.providerFilter,
+      modelFilter: normalizedInputs.modelFilter
+    })
+  );
   return {
     options,
     normalizedInputs,
@@ -6170,38 +6899,17 @@ async function applyPricingToUsageEventDataset(dataset, deps = {}, pricingLoadMo
     dataset.options,
     dataset.normalizedInputs.pricingUrl
   );
-  return resolveAndApplyPricingToEvents(
-    dataset.filteredEvents,
-    pricingOptions,
-    dataset.pricingRuntimeConfig,
-    loadPricingSource,
-    pricingLoadMode
-  );
-}
-
-// src/cli/build-usage-data.ts
-async function buildUsageData(granularity, options, deps = {}) {
-  const dataset = await buildUsageEventDataset(options, deps);
-  const { pricedEvents, pricingOrigin, pricingWarning } = await applyPricingToUsageEventDataset(
-    dataset,
-    deps,
-    "auto"
+  return measureRuntimeProfileStage(
+    deps.runtimeProfile,
+    "usage.pricing.apply",
+    () => resolveAndApplyPricingToEvents(
+      dataset.filteredEvents,
+      pricingOptions,
+      dataset.pricingRuntimeConfig,
+      loadPricingSource,
+      pricingLoadMode
+    )
   );
-  const rows = aggregateUsage(pricedEvents, {
-    granularity,
-    timezone: dataset.normalizedInputs.timezone,
-    sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id)
-  });
-  const diagnostics = buildUsageDiagnostics({
-    adaptersToParse: dataset.adaptersToParse,
-    successfulParseResults: dataset.successfulParseResults,
-    sourceFailures: dataset.sourceFailures,
-    pricingOrigin,
-    pricingWarning,
-    activeEnvOverrides: dataset.readEnvVarOverrides(),
-    timezone: dataset.normalizedInputs.timezone
-  });
-  return assembleUsageDataResult(pricedEvents, rows, diagnostics);
 }
 
 // src/cli/build-efficiency-data.ts
@@ -6255,52 +6963,80 @@ function resolveScopeNote(options) {
   return `Usage filters (${activeFilters.join(", ")}) affect commit attribution too: only commit days with matching repo-attributed usage events are counted.`;
 }
 function hasMeaningfulEfficiencyUsageSignal(event) {
-  return event.totalTokens > 0 || event.costUsd !== void 0 && event.costUsd > 0;
+  return event.totalTokens > 0 || hasBillableTokenBuckets(event) || event.costUsd !== void 0;
 }
 async function buildEfficiencyData(granularity, options, deps = {}) {
-  const buildUsage = deps.buildUsageData ?? buildUsageData;
+  const buildDataset = deps.buildUsageEventDataset ?? buildUsageEventDataset;
+  const applyPricing = deps.applyPricingToUsageEventDataset ?? applyPricingToUsageEventDataset;
   const collectOutcomes = deps.collectGitOutcomes ?? collectGitOutcomes;
   const resolveRepoRoot3 = deps.resolveRepoRoot ?? resolveRepoRootFromPathHint;
   const repoDir = options.repoDir?.trim();
   if (options.repoDir !== void 0 && !repoDir) {
     throw new Error("--repo-dir must be a non-empty path");
   }
-  const usageData = await buildUsage(granularity, options);
-  const attribution = await attributeUsageEventsToRepo(
-    usageData.events,
-    repoDir ?? process.cwd(),
-    resolveRepoRoot3
+  const dataset = await measureRuntimeProfileStage(
+    deps.runtimeProfile,
+    "efficiency.dataset.total",
+    () => buildDataset(options, deps)
+  );
+  const { pricedEvents, pricingOrigin, pricingWarning } = await applyPricing(dataset, deps, "auto");
+  const attribution = await measureRuntimeProfileStage(
+    deps.runtimeProfile,
+    "efficiency.attribute_repo",
+    () => attributeUsageEventsToRepo(pricedEvents, repoDir ?? process.cwd(), resolveRepoRoot3)
   );
   const matchedEventsWithSignal = attribution.matchedEvents.filter(
     (event) => hasMeaningfulEfficiencyUsageSignal(event)
   );
   const activeUsageDays = new Set(
     matchedEventsWithSignal.map(
-      (event) => getPeriodKey(event.timestamp, "daily", usageData.diagnostics.timezone)
+      (event) => getPeriodKey(event.timestamp, "daily", dataset.normalizedInputs.timezone)
     )
   );
-  const gitOutcomes = await collectOutcomes({
-    repoDir,
-    granularity,
-    timezone: usageData.diagnostics.timezone,
-    since: options.since,
-    until: options.until,
-    includeMergeCommits: options.includeMergeCommits,
-    activeUsageDays
-  });
-  const repoScopedUsageRows = aggregateUsage(matchedEventsWithSignal, {
-    granularity,
-    timezone: usageData.diagnostics.timezone,
-    includeModelBreakdown: false
-  });
-  const rows = aggregateEfficiency({
-    usageRows: repoScopedUsageRows,
-    periodOutcomes: gitOutcomes.periodOutcomes
+  const gitOutcomes = await measureRuntimeProfileStage(
+    deps.runtimeProfile,
+    "efficiency.collect_git_outcomes",
+    () => collectOutcomes({
+      repoDir,
+      granularity,
+      timezone: dataset.normalizedInputs.timezone,
+      since: options.since,
+      until: options.until,
+      includeMergeCommits: options.includeMergeCommits,
+      activeUsageDays
+    })
+  );
+  const repoScopedUsageRows = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "efficiency.aggregate_usage",
+    () => aggregateUsage(matchedEventsWithSignal, {
+      granularity,
+      timezone: dataset.normalizedInputs.timezone,
+      includeModelBreakdown: false
+    })
+  );
+  const rows = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "efficiency.aggregate",
+    () => aggregateEfficiency({
+      usageRows: repoScopedUsageRows,
+      periodOutcomes: gitOutcomes.periodOutcomes
+    })
+  );
+  const usageDiagnostics = buildUsageDiagnostics({
+    adaptersToParse: dataset.adaptersToParse,
+    successfulParseResults: dataset.successfulParseResults,
+    sourceFailures: dataset.sourceFailures,
+    pricingOrigin,
+    pricingWarning,
+    activeEnvOverrides: dataset.readEnvVarOverrides(),
+    timezone: dataset.normalizedInputs.timezone,
+    runtimeProfile: deps.runtimeProfile?.snapshot()
   });
   return {
     rows,
     diagnostics: {
-      usage: usageData.diagnostics,
+      usage: usageDiagnostics,
       repoDir: gitOutcomes.diagnostics.repoDir,
       includeMergeCommits: gitOutcomes.diagnostics.includeMergeCommits,
       gitCommitCount: gitOutcomes.diagnostics.commitsCollected,
@@ -6390,7 +7126,7 @@ function emitEnvVarOverrides(activeEnvOverrides, diagnosticsLogger) {
 }
 
 // src/cli/share-artifact.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { writeFile as writeFile4 } from "fs/promises";
 import path13 from "path";
 async function writeShareSvgFile(fileName, svgContent) {
@@ -6424,7 +7160,7 @@ function resolveOpenCommand(filePath, platform) {
 }
 async function spawnDetached(command, args) {
   await new Promise((resolve, reject) => {
-    const child = spawn3(command, args, {
+    const child = spawn4(command, args, {
       detached: true,
       stdio: "ignore",
       windowsHide: true
@@ -6519,12 +7255,22 @@ async function prepareReport(options) {
   validateOutputFormatOptions(options.commandOptions);
   options.validate?.();
   const format = resolveReportFormat(options.commandOptions, options.supportedFormats);
-  const data = await options.buildData();
+  const data = await measureRuntimeProfileStage(
+    options.runtimeProfile,
+    "report.prepare.build_data",
+    options.buildData
+  );
+  const output = measureRuntimeProfileStageSync(
+    options.runtimeProfile,
+    "report.prepare.render",
+    () => options.render(data, format)
+  );
   return {
     format,
     diagnostics: options.getDiagnostics(data),
-    output: options.render(data, format),
-    shareArtifact: options.createShareArtifact?.(data)
+    output,
+    shareArtifact: options.createShareArtifact?.(data),
+    runtimeProfile: options.runtimeProfile
   };
 }
 async function writeShareArtifact(artifact) {
@@ -6543,6 +7289,13 @@ async function runPreparedReport(options) {
   const envVarOverrides = options.getEnvVarOverrides?.(options.preparedReport.diagnostics) ?? [];
   emitEnvVarOverrides(envVarOverrides, logger);
   options.emitReportDiagnostics?.(options.preparedReport.diagnostics);
+  emitRuntimeProfile(
+    mergeRuntimeProfiles(
+      options.preparedReport.runtimeProfile?.snapshot(),
+      options.getRuntimeProfile?.(options.preparedReport.diagnostics)
+    ),
+    logger
+  );
   if (options.warnOnTerminalOverflow && options.preparedReport.format === "terminal") {
     warnIfTerminalTableOverflows(options.preparedReport.output, (message) => {
       logger.warn(message);
@@ -6568,15 +7321,16 @@ function validateShareOption(granularity, options) {
     throw new Error("--share is only supported for efficiency monthly");
   }
 }
-async function prepareEfficiencyReport(granularity, options) {
+async function prepareEfficiencyReport(granularity, options, deps = {}) {
   return prepareReport({
     commandOptions: options,
     supportedFormats: efficiencyReportFormats,
     validate: () => {
       validateShareOption(granularity, options);
     },
-    buildData: () => buildEfficiencyData(granularity, options),
+    buildData: () => buildEfficiencyData(granularity, options, deps),
     getDiagnostics: (efficiencyData) => efficiencyData.diagnostics,
+    runtimeProfile: deps.runtimeProfile,
     createShareArtifact: options.share ? (efficiencyData) => ({
       fileName: "efficiency-monthly-share.svg",
       svg: renderEfficiencyMonthlyShareSvg(efficiencyData),
@@ -6600,7 +7354,8 @@ function emitEfficiencyReportDiagnostics(diagnostics) {
   }
 }
 async function runEfficiencyReport(granularity, options) {
-  const preparedReport = await prepareEfficiencyReport(granularity, options);
+  const runtimeProfile = createRuntimeProfileCollector();
+  const preparedReport = await prepareEfficiencyReport(granularity, options, { runtimeProfile });
   await runPreparedReport({
     preparedReport,
     emitCommonDiagnostics: (diagnostics) => {
@@ -6608,6 +7363,7 @@ async function runEfficiencyReport(granularity, options) {
     },
     getEnvVarOverrides: (diagnostics) => diagnostics.usage.activeEnvOverrides,
     emitReportDiagnostics: emitEfficiencyReportDiagnostics,
+    getRuntimeProfile: (diagnostics) => diagnostics.usage.runtimeProfile,
     warnOnTerminalOverflow: true
   });
 }
@@ -6977,8 +7733,11 @@ var USD_PRECISION_SCALE3 = 1e12;
 function roundUsd(value) {
   return Math.round(value * USD_PRECISION_SCALE3) / USD_PRECISION_SCALE3;
 }
-function hasZeroBillableTokenBuckets(totals) {
-  return totals.inputTokens === 0 && totals.outputTokens === 0 && totals.reasoningTokens === 0 && totals.cacheReadTokens === 0 && totals.cacheWriteTokens === 0;
+function addUsd3(left, right) {
+  return roundUsd(left + right);
+}
+function hasAnyUsageSignal(period) {
+  return period.totalTokens > 0 || period.baselineCostIncomplete || (period.baselineCostUsd ?? 0) > 0;
 }
 function parseCandidateModelsRaw(candidateModel) {
   if (!candidateModel || Array.isArray(candidateModel) && candidateModel.length === 0) {
@@ -7044,30 +7803,41 @@ function withNotes(notes) {
 }
 function evaluateCandidateForPeriod(period, provider, candidateModel, pricingSource) {
   const notes = /* @__PURE__ */ new Set();
-  const zeroBillableTokens = hasZeroBillableTokenBuckets(period);
+  const hasBillableUsage = hasBillableTokenBuckets(period);
   const candidateResolvedModel = pricingSource ? pricingSource.resolveModelAlias(candidateModel) : candidateModel;
   const pricing = pricingSource ? pricingSource.getPricing(candidateResolvedModel) : void 0;
+  const syntheticEvent = createSyntheticEvent(period);
   let hypotheticalCostUsd;
   let hypotheticalCostIncomplete = false;
-  if (!pricing) {
-    if (zeroBillableTokens) {
+  if (!hasBillableUsage) {
+    if (!hasAnyUsageSignal(period)) {
       hypotheticalCostUsd = 0;
     } else {
       hypotheticalCostUsd = void 0;
       hypotheticalCostIncomplete = true;
-      notes.add("missing_pricing");
-    }
+      notes.add("usage_buckets_missing");
+    }
+  } else if (!pricing) {
+    hypotheticalCostUsd = void 0;
+    hypotheticalCostIncomplete = true;
+    notes.add("missing_pricing");
+  } else if (hasUsedBucketWithUndefinedRate(syntheticEvent, pricing)) {
+    hypotheticalCostUsd = void 0;
+    hypotheticalCostIncomplete = true;
+    notes.add("missing_pricing");
+  } else if (!canEstimateUsageCost(syntheticEvent, pricing)) {
+    hypotheticalCostUsd = void 0;
+    hypotheticalCostIncomplete = true;
+    notes.add("usage_buckets_missing");
   } else {
-    hypotheticalCostUsd = roundUsd(
-      calculateEstimatedCostUsd(createSyntheticEvent(period), pricing)
-    );
+    hypotheticalCostUsd = roundUsd(calculateEstimatedCostUsd(syntheticEvent, pricing));
   }
   let savingsUsd;
   let savingsPct;
   let hasBaselineTokenMismatch = false;
   if (period.baselineCostIncomplete || period.baselineCostUsd === void 0) {
     notes.add("baseline_incomplete");
-  } else if (zeroBillableTokens && period.baselineCostUsd > 0) {
+  } else if (!hasBillableUsage && period.baselineCostUsd > 0) {
     notes.add("baseline_tokens_missing");
     hasBaselineTokenMismatch = true;
   } else if (hypotheticalCostUsd !== void 0) {
@@ -7123,9 +7893,22 @@ function resolveBaselinePeriods(usageRows) {
       periodRows.set(row.periodKey, row);
       continue;
     }
-    if (!periodRows.has(row.periodKey)) {
+    const existingRow = periodRows.get(row.periodKey);
+    if (!existingRow) {
       periodRows.set(row.periodKey, row);
+      continue;
     }
+    periodRows.set(row.periodKey, {
+      ...existingRow,
+      inputTokens: existingRow.inputTokens + row.inputTokens,
+      outputTokens: existingRow.outputTokens + row.outputTokens,
+      reasoningTokens: existingRow.reasoningTokens + row.reasoningTokens,
+      cacheReadTokens: existingRow.cacheReadTokens + row.cacheReadTokens,
+      cacheWriteTokens: existingRow.cacheWriteTokens + row.cacheWriteTokens,
+      totalTokens: existingRow.totalTokens + row.totalTokens,
+      costUsd: row.costUsd !== void 0 ? addUsd3(existingRow.costUsd ?? 0, row.costUsd) : existingRow.costUsd,
+      costIncomplete: existingRow.costIncomplete === true || row.costIncomplete === true ? true : void 0
+    });
   }
   const sortedPeriodKeys = [...periodRows.keys()].sort(compareByCodePoint);
   const periods = sortedPeriodKeys.map((periodKey) => {
@@ -7225,16 +8008,13 @@ function buildCounterfactualRows(input) {
 
 // src/cli/build-optimize-data.ts
 function resolveOptimizeProvider(providers, providerFilter) {
-  const distinctProviders = [...providers].sort(compareByCodePoint);
+  const distinctProviders = collectCanonicalProviderRoots(providers);
   const normalizedProviderFilter = normalizeProviderFilter(providerFilter);
   if (distinctProviders.length > 1) {
     if (normalizedProviderFilter) {
       const matchingProviders = distinctProviders.filter(
-        (provider) => provider.includes(normalizedProviderFilter)
+        (provider) => matchesCanonicalProviderFilter(provider, normalizedProviderFilter)
       );
-      if (matchingProviders.includes(normalizedProviderFilter)) {
-        return normalizedProviderFilter;
-      }
       if (matchingProviders.length === 1) {
         return matchingProviders[0];
       }
@@ -7261,28 +8041,41 @@ function resolveOptimizeProvider(providers, providerFilter) {
 async function buildOptimizeData(granularity, options, deps = {}) {
   const candidateModels = normalizeCandidateModels(options.candidateModel);
   const top = parseTopOption(options.top);
-  const dataset = await buildUsageEventDataset(options, deps);
+  const dataset = await measureRuntimeProfileStage(
+    deps.runtimeProfile,
+    "optimize.dataset.total",
+    () => buildUsageEventDataset(options, deps)
+  );
   const detectedProviders = new Set(
     dataset.filteredEvents.map((event) => normalizeProviderFilter(event.provider)).filter((provider2) => provider2 !== void 0)
   );
-  const provider = resolveOptimizeProvider(
-    detectedProviders,
-    dataset.normalizedInputs.providerFilter
+  const provider = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "optimize.resolve_provider",
+    () => resolveOptimizeProvider(detectedProviders, dataset.normalizedInputs.providerFilter)
   );
   const { pricedEvents, pricingOrigin, pricingWarning, pricingSource } = await applyPricingToUsageEventDataset(dataset, deps, "force");
-  const usageRows = aggregateUsage(pricedEvents, {
-    granularity,
-    timezone: dataset.normalizedInputs.timezone,
-    sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id),
-    includeModelBreakdown: false
-  });
-  const counterfactual = buildCounterfactualRows({
-    usageRows,
-    provider,
-    candidateModels,
-    pricingSource,
-    top
-  });
+  const usageRows = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "optimize.aggregate_usage",
+    () => aggregateUsage(pricedEvents, {
+      granularity,
+      timezone: dataset.normalizedInputs.timezone,
+      sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id),
+      includeModelBreakdown: false
+    })
+  );
+  const counterfactual = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "optimize.counterfactual",
+    () => buildCounterfactualRows({
+      usageRows,
+      provider,
+      candidateModels,
+      pricingSource,
+      top
+    })
+  );
   const usageDiagnostics = buildUsageDiagnostics({
     adaptersToParse: dataset.adaptersToParse,
     successfulParseResults: dataset.successfulParseResults,
@@ -7290,7 +8083,8 @@ async function buildOptimizeData(granularity, options, deps = {}) {
     pricingOrigin,
     pricingWarning,
     activeEnvOverrides: dataset.readEnvVarOverrides(),
-    timezone: dataset.normalizedInputs.timezone
+    timezone: dataset.normalizedInputs.timezone,
+    runtimeProfile: deps.runtimeProfile?.snapshot()
   });
   return {
     rows: counterfactual.rows,
@@ -7318,7 +8112,7 @@ function validateShareOption2(granularity, options) {
     throw new Error("--share is only supported for optimize monthly");
   }
 }
-async function prepareOptimizeReport(granularity, options) {
+async function prepareOptimizeReport(granularity, options, deps = {}) {
   return prepareReport({
     commandOptions: options,
     supportedFormats: optimizeReportFormats,
@@ -7326,7 +8120,7 @@ async function prepareOptimizeReport(granularity, options) {
       validateShareOption2(granularity, options);
     },
     buildData: async () => {
-      const optimizeData = await buildOptimizeData(granularity, options);
+      const optimizeData = await buildOptimizeData(granularity, options, deps);
       return {
         optimizeData,
         candidateCount: optimizeData.rows.filter(
@@ -7338,6 +8132,7 @@ async function prepareOptimizeReport(granularity, options) {
       ...bundle.optimizeData.diagnostics,
       candidateCount: bundle.candidateCount
     }),
+    runtimeProfile: deps.runtimeProfile,
     createShareArtifact: options.share ? (bundle) => ({
       fileName: "optimize-monthly-share.svg",
       svg: renderOptimizeMonthlyShareSvg(bundle.optimizeData),
@@ -7362,7 +8157,8 @@ function emitOptimizeReportDiagnostics(diagnostics) {
   }
 }
 async function runOptimizeReport(granularity, options) {
-  const preparedReport = await prepareOptimizeReport(granularity, options);
+  const runtimeProfile = createRuntimeProfileCollector();
+  const preparedReport = await prepareOptimizeReport(granularity, options, { runtimeProfile });
   await runPreparedReport({
     preparedReport,
     emitCommonDiagnostics: (diagnostics) => {
@@ -7370,6 +8166,7 @@ async function runOptimizeReport(granularity, options) {
     },
     getEnvVarOverrides: (diagnostics) => diagnostics.usage.activeEnvOverrides,
     emitReportDiagnostics: emitOptimizeReportDiagnostics,
+    getRuntimeProfile: (diagnostics) => diagnostics.usage.runtimeProfile,
     warnOnTerminalOverflow: true
   });
 }
@@ -7387,6 +8184,7 @@ var compactNumberFormatter = new Intl.NumberFormat("en-US", {
   maximumFractionDigits: 1
 });
 var sparklineBlocks = [" ", "\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+var minimumCompressedEmptyEdgeDays = 7;
 function resolveTerminalWidth2(override) {
   if (typeof override === "number" && Number.isFinite(override) && override > 0) {
     return Math.floor(override);
@@ -7426,15 +8224,26 @@ function downsampleBuckets(buckets, maxColumns) {
     const startIndex = Math.floor(columnIndex * buckets.length / maxColumns);
     const endIndex = Math.floor((columnIndex + 1) * buckets.length / maxColumns);
     const slice = buckets.slice(startIndex, Math.max(startIndex + 1, endIndex));
-    const total = slice.reduce((sum, bucket) => sum + bucket.value, 0);
+    const peakValue = slice.reduce((maxValue, bucket) => Math.max(maxValue, bucket.value), 0);
     return {
       date: slice[0]?.date ?? "",
-      value: total / slice.length,
+      value: peakValue,
       observed: slice.some((bucket) => bucket.observed),
       incomplete: slice.some((bucket) => bucket.incomplete === true) || void 0
     };
   });
 }
+function getBarLevel(value, maxValue, rowCount) {
+  if (value <= 0 || maxValue <= 0 || rowCount <= 0) {
+    return 0;
+  }
+  return Math.max(1, Math.min(rowCount * 8, Math.round(value / maxValue * rowCount * 8)));
+}
+function renderCombinedChartCell(barLevel, rowIndex, rowCount) {
+  const rowBaseLevel = (rowCount - rowIndex - 1) * 8;
+  const cellLevel = Math.max(0, Math.min(8, barLevel - rowBaseLevel));
+  return sparklineBlocks[cellLevel];
+}
 function isApproximatePeak(series, metric) {
   if (metric !== "cost" || series.summary.observedDayCount === 0) {
     return false;
@@ -7483,18 +8292,88 @@ function renderSummaryOnly(trendsData, options) {
   lines.push(renderSummary(trendsData.totalSeries, trendsData.metric));
   return lines.join("\n");
 }
+function isInactiveEdgeBucket(bucket) {
+  return !bucket.observed && bucket.value === 0 && bucket.incomplete !== true;
+}
+function findLeadingInactiveBucketCount(buckets) {
+  let count = 0;
+  while (count < buckets.length && isInactiveEdgeBucket(buckets[count])) {
+    count += 1;
+  }
+  return count;
+}
+function findTrailingInactiveBucketCount(buckets) {
+  let count = 0;
+  while (count < buckets.length && isInactiveEdgeBucket(buckets[buckets.length - 1 - count])) {
+    count += 1;
+  }
+  return count;
+}
+function formatCompressedEdgeNote(count, startDate, endDate, position) {
+  const rangeLabel = startDate === endDate ? formatDateLabel(startDate) : `${formatDateLabel(startDate)}-${formatDateLabel(endDate)}`;
+  const activityLabel = position === "before" ? "before first activity" : "after last activity";
+  return `Compressed ${count} empty day(s) ${activityLabel} (${rangeLabel}).`;
+}
+function getCombinedChartView(series) {
+  if (series.buckets.length === 0) {
+    return {
+      chartSeries: series,
+      notes: []
+    };
+  }
+  const leadingInactiveBucketCount = findLeadingInactiveBucketCount(series.buckets);
+  const trailingInactiveBucketCount = findTrailingInactiveBucketCount(series.buckets);
+  const notes = [];
+  let startIndex = 0;
+  let endIndex = series.buckets.length - 1;
+  if (leadingInactiveBucketCount >= minimumCompressedEmptyEdgeDays && leadingInactiveBucketCount < series.buckets.length) {
+    const firstCompressedBucket = series.buckets[0];
+    const lastCompressedBucket = series.buckets[leadingInactiveBucketCount - 1];
+    notes.push(
+      formatCompressedEdgeNote(
+        leadingInactiveBucketCount,
+        firstCompressedBucket.date,
+        lastCompressedBucket.date,
+        "before"
+      )
+    );
+    startIndex = leadingInactiveBucketCount;
+  }
+  if (trailingInactiveBucketCount >= minimumCompressedEmptyEdgeDays && trailingInactiveBucketCount < series.buckets.length - startIndex) {
+    const firstCompressedBucket = series.buckets[series.buckets.length - trailingInactiveBucketCount];
+    const lastCompressedBucket = series.buckets[series.buckets.length - 1];
+    notes.push(
+      formatCompressedEdgeNote(
+        trailingInactiveBucketCount,
+        firstCompressedBucket.date,
+        lastCompressedBucket.date,
+        "after"
+      )
+    );
+    endIndex = series.buckets.length - trailingInactiveBucketCount - 1;
+  }
+  return {
+    chartSeries: notes.length === 0 ? series : {
+      ...series,
+      buckets: series.buckets.slice(startIndex, endIndex + 1)
+    },
+    notes
+  };
+}
 function renderCombinedChart(series, metric, plotWidth) {
   const buckets = downsampleBuckets(series.buckets, plotWidth);
   const maxValue = Math.max(...buckets.map((bucket) => bucket.value), 0);
   const lines = [];
-  const tickValues = Array.from({ length: 5 }, (_, index) => {
-    const inverseIndex = 4 - index;
-    return maxValue === 0 ? 0 : maxValue * inverseIndex / 4;
+  const chartRowCount = 4;
+  const tickValues = Array.from({ length: chartRowCount + 1 }, (_, index) => {
+    const inverseIndex = chartRowCount - index;
+    return maxValue === 0 ? 0 : maxValue * inverseIndex / chartRowCount;
   });
   const labelWidth = tickValues.reduce(
     (maxWidth, value) => Math.max(maxWidth, visibleWidth(formatAxisValue(value, metric))),
     0
   );
+  const barLevels = buckets.map((bucket) => getBarLevel(bucket.value, maxValue, chartRowCount));
   tickValues.forEach((tickValue, tickIndex) => {
     if (tickIndex === tickValues.length - 1) {
       lines.push(
@@ -7502,18 +8381,7 @@ function renderCombinedChart(series, metric, plotWidth) {
       );
       return;
     }
-    const threshold = tickValue;
-    const glyphs = buckets.map((bucket) => {
-      if (maxValue === 0) {
-        return " ";
-      }
-      const ratio = bucket.value / maxValue;
-      const level = Math.max(0, Math.min(8, Math.round(ratio * 8)));
-      if (bucket.value >= threshold && level > 0) {
-        return sparklineBlocks[level];
-      }
-      return " ";
-    }).join("");
+    const glyphs = barLevels.map((barLevel) => renderCombinedChartCell(barLevel, tickIndex, chartRowCount)).join("");
     lines.push(`${formatAxisValue(tickValue, metric).padStart(labelWidth)} \u2524${glyphs}`);
   });
   const startLabel = formatDateLabel(series.buckets[0]?.date ?? "");
@@ -7597,12 +8465,14 @@ function renderTerminalTrendsReport(trendsData, options) {
       ...renderSourceLines(trendsData.sourceSeries, trendsData.metric, terminalWidth ?? 80)
     );
   } else {
+    const chartView = getCombinedChartView(trendsData.totalSeries);
+    if (chartView.notes.length > 0) {
+      lines.push(...chartView.notes);
+    }
     const plotWidth = Math.max(16, (terminalWidth ?? 80) - 14);
-    const chartLines = renderCombinedChart(
-      trendsData.totalSeries,
-      trendsData.metric,
-      plotWidth
-    ).map((line) => useColor ? accent(line) : line);
+    const chartLines = renderCombinedChart(chartView.chartSeries, trendsData.metric, plotWidth).map(
+      (line) => useColor ? accent(line) : line
+    );
     lines.push(...chartLines);
   }
   lines.push("");
@@ -7628,6 +8498,13 @@ function renderTrendsReport(trendsData, format, options = {}) {
 }
 
 // src/trends/aggregate-trends.ts
+var VALUE_PRECISION_SCALE = 1e12;
+function addValue(left, right) {
+  return Math.round((left + right) * VALUE_PRECISION_SCALE) / VALUE_PRECISION_SCALE;
+}
+function divideValue(value, divisor) {
+  return Math.round(value / divisor * VALUE_PRECISION_SCALE) / VALUE_PRECISION_SCALE;
+}
 function toTrendBucket(row, metric) {
   return {
     date: row.periodKey,
@@ -7656,12 +8533,12 @@ function buildTrendSummary(buckets) {
       observedDayCount: 0
     };
   }
-  const total = buckets.reduce((sum, bucket) => sum + bucket.value, 0);
+  const total = buckets.reduce((sum, bucket) => addValue(sum, bucket.value), 0);
   const observedBuckets = buckets.filter((bucket) => bucket.observed);
   if (observedBuckets.length === 0) {
     return {
       total,
-      average: buckets.length > 0 ? total / buckets.length : 0,
+      average: buckets.length > 0 ? divideValue(total, buckets.length) : 0,
       peak: {
         date: "",
         value: 0
@@ -7677,7 +8554,7 @@ function buildTrendSummary(buckets) {
   );
   return {
     total,
-    average: buckets.length > 0 ? total / buckets.length : 0,
+    average: buckets.length > 0 ? divideValue(total, buckets.length) : 0,
     peak: {
       date: peak.date,
       value: peak.value
@@ -7697,6 +8574,46 @@ function buildSeries(source, rowsByDate, dateKeys, metric) {
     summary: buildTrendSummary(buckets)
   };
 }
+function createEmptyUsageRow(periodKey, rowType, source) {
+  return rowType === "period_combined" ? {
+    rowType,
+    periodKey,
+    source: "combined",
+    models: [],
+    modelBreakdown: [],
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0
+  } : {
+    rowType,
+    periodKey,
+    source,
+    models: [],
+    modelBreakdown: [],
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0
+  };
+}
+function addRowTotals(target, row) {
+  return {
+    ...target,
+    inputTokens: target.inputTokens + row.inputTokens,
+    outputTokens: target.outputTokens + row.outputTokens,
+    reasoningTokens: target.reasoningTokens + row.reasoningTokens,
+    cacheReadTokens: target.cacheReadTokens + row.cacheReadTokens,
+    cacheWriteTokens: target.cacheWriteTokens + row.cacheWriteTokens,
+    totalTokens: target.totalTokens + row.totalTokens,
+    costUsd: row.costUsd !== void 0 ? addValue(target.costUsd ?? 0, row.costUsd) : target.costUsd,
+    costIncomplete: target.costIncomplete === true || row.costIncomplete === true ? true : void 0
+  };
+}
 function toCombinedRowsByDate(rows) {
   const combinedByDate = /* @__PURE__ */ new Map();
   const sourceOnlyByDate = /* @__PURE__ */ new Map();
@@ -7708,9 +8625,8 @@ function toCombinedRowsByDate(rows) {
       combinedByDate.set(row.periodKey, row);
       continue;
     }
-    if (!sourceOnlyByDate.has(row.periodKey)) {
-      sourceOnlyByDate.set(row.periodKey, row);
-    }
+    const existingSourceOnlyRow = sourceOnlyByDate.get(row.periodKey) ?? createEmptyUsageRow(row.periodKey, "period_combined", "combined");
+    sourceOnlyByDate.set(row.periodKey, addRowTotals(existingSourceOnlyRow, row));
   }
   const resolved = /* @__PURE__ */ new Map();
   for (const [date, row] of sourceOnlyByDate) {
@@ -7731,7 +8647,8 @@ function toSourceSeries(rows, dateKeys, options) {
       continue;
     }
     const sourceRows = rowsBySource.get(row.source) ?? /* @__PURE__ */ new Map();
-    sourceRows.set(row.periodKey, row);
+    const existingSourceRow = sourceRows.get(row.periodKey) ?? createEmptyUsageRow(row.periodKey, "period_source", row.source);
+    sourceRows.set(row.periodKey, addRowTotals(existingSourceRow, row));
     rowsBySource.set(row.source, sourceRows);
   }
   const observedSources = [...rowsBySource.keys()].sort((left, right) => {
@@ -7878,36 +8795,48 @@ async function buildTrendsData(options, deps = {}) {
   const timezone = options.timezone?.trim() ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
   validateTimezone(timezone);
   const resolved = resolveTrendsOptions(options, timezone, now);
-  const dataset = await buildUsageEventDataset(
-    {
-      ...options,
-      timezone,
-      since: resolved.fetchDateRange?.from ?? options.since,
-      until: resolved.fetchDateRange?.to ?? options.until
-    },
-    deps
+  const dataset = await measureRuntimeProfileStage(
+    deps.runtimeProfile,
+    "trends.dataset.total",
+    () => buildUsageEventDataset(
+      {
+        ...options,
+        timezone,
+        since: resolved.fetchDateRange?.from ?? options.since,
+        until: resolved.fetchDateRange?.to ?? options.until
+      },
+      deps
+    )
   );
   const pricingResult = resolved.metric === "cost" ? await applyPricingToUsageEventDataset(dataset, deps, "auto") : {
     pricedEvents: dataset.filteredEvents,
     pricingOrigin: "none",
     pricingWarning: void 0
   };
-  const dailyRows = aggregateUsage(pricingResult.pricedEvents, {
-    granularity: "daily",
-    timezone: dataset.normalizedInputs.timezone,
-    sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id),
-    includeModelBreakdown: false
-  });
+  const dailyRows = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "trends.aggregate_usage",
+    () => aggregateUsage(pricingResult.pricedEvents, {
+      granularity: "daily",
+      timezone: dataset.normalizedInputs.timezone,
+      sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id),
+      includeModelBreakdown: false
+    })
+  );
   const observedDates = dailyRows.filter((row) => row.rowType !== "grand_total").map((row) => row.periodKey).sort();
   const outputDateRange = resolveOutputDateRange(options, resolved.today, resolved.days, [
     ...new Set(observedDates)
   ]);
-  const trends = aggregateTrends(filterRowsToDateRange(dailyRows, outputDateRange), {
-    dateRange: outputDateRange,
-    metric: resolved.metric,
-    bySource: options.bySource === true,
-    sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id)
-  });
+  const trends = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "trends.aggregate",
+    () => aggregateTrends(filterRowsToDateRange(dailyRows, outputDateRange), {
+      dateRange: outputDateRange,
+      metric: resolved.metric,
+      bySource: options.bySource === true,
+      sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id)
+    })
+  );
   const diagnostics = buildUsageDiagnostics({
     adaptersToParse: dataset.adaptersToParse,
     successfulParseResults: dataset.successfulParseResults,
@@ -7915,7 +8844,8 @@ async function buildTrendsData(options, deps = {}) {
     pricingOrigin: pricingResult.pricingOrigin,
     pricingWarning: pricingResult.pricingWarning,
     activeEnvOverrides: dataset.readEnvVarOverrides(),
-    timezone: dataset.normalizedInputs.timezone
+    timezone: dataset.normalizedInputs.timezone,
+    runtimeProfile: deps.runtimeProfile?.snapshot()
   });
   return {
     metric: resolved.metric,
@@ -7928,22 +8858,59 @@ async function buildTrendsData(options, deps = {}) {
 
 // src/cli/run-trends-report.ts
 var trendsReportFormats = ["terminal", "json"];
-async function prepareTrendsReport(options) {
+async function prepareTrendsReport(options, deps = {}) {
   return prepareReport({
     commandOptions: options,
     supportedFormats: trendsReportFormats,
-    buildData: () => buildTrendsData(options),
+    buildData: () => buildTrendsData(options, deps),
     getDiagnostics: (trendsData) => trendsData.diagnostics,
+    runtimeProfile: deps.runtimeProfile,
     render: (trendsData, format) => renderTrendsReport(trendsData, format)
   });
 }
 async function runTrendsReport(options) {
-  const preparedReport = await prepareTrendsReport(options);
+  const runtimeProfile = createRuntimeProfileCollector();
+  const preparedReport = await prepareTrendsReport(options, { runtimeProfile });
   await runPreparedReport({
     preparedReport,
     emitCommonDiagnostics: emitDiagnostics,
-    getEnvVarOverrides: (diagnostics) => diagnostics.activeEnvOverrides
+    getEnvVarOverrides: (diagnostics) => diagnostics.activeEnvOverrides,
+    getRuntimeProfile: (diagnostics) => diagnostics.runtimeProfile
+  });
+}
+
+// src/cli/build-usage-data.ts
+async function buildUsageData(granularity, options, deps = {}) {
+  const dataset = await measureRuntimeProfileStage(
+    deps.runtimeProfile,
+    "usage.dataset.total",
+    () => buildUsageEventDataset(options, deps)
+  );
+  const { pricedEvents, pricingOrigin, pricingWarning } = await applyPricingToUsageEventDataset(
+    dataset,
+    deps,
+    "auto"
+  );
+  const rows = measureRuntimeProfileStageSync(
+    deps.runtimeProfile,
+    "usage.aggregate",
+    () => aggregateUsage(pricedEvents, {
+      granularity,
+      timezone: dataset.normalizedInputs.timezone,
+      sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id)
+    })
+  );
+  const diagnostics = buildUsageDiagnostics({
+    adaptersToParse: dataset.adaptersToParse,
+    successfulParseResults: dataset.successfulParseResults,
+    sourceFailures: dataset.sourceFailures,
+    pricingOrigin,
+    pricingWarning,
+    activeEnvOverrides: dataset.readEnvVarOverrides(),
+    timezone: dataset.normalizedInputs.timezone,
+    runtimeProfile: deps.runtimeProfile?.snapshot()
   });
+  return assembleUsageDataResult(pricedEvents, rows, diagnostics);
 }
 
 // src/render/markdown-table.ts
@@ -8271,13 +9238,14 @@ function resolveTableLayout(options) {
 function resolveShareFileName(granularity) {
   return `usage-${granularity}-share.svg`;
 }
-async function prepareUsageReport(granularity, options) {
+async function prepareUsageReport(granularity, options, deps = {}) {
   const tableLayout = resolveTableLayout(options);
   return prepareReport({
     commandOptions: options,
     supportedFormats: usageReportFormats,
-    buildData: () => buildUsageData(granularity, options),
+    buildData: () => buildUsageData(granularity, options, deps),
     getDiagnostics: (usageData) => usageData.diagnostics,
+    runtimeProfile: deps.runtimeProfile,
     createShareArtifact: options.share ? (usageData) => ({
       fileName: resolveShareFileName(granularity),
       svg: renderUsageShareSvg(usageData, granularity),
@@ -8290,11 +9258,13 @@ async function prepareUsageReport(granularity, options) {
   });
 }
 async function runUsageReport(granularity, options) {
-  const preparedReport = await prepareUsageReport(granularity, options);
+  const runtimeProfile = createRuntimeProfileCollector();
+  const preparedReport = await prepareUsageReport(granularity, options, { runtimeProfile });
   await runPreparedReport({
     preparedReport,
     emitCommonDiagnostics: emitDiagnostics,
     getEnvVarOverrides: (diagnostics) => diagnostics.activeEnvOverrides,
+    getRuntimeProfile: (diagnostics) => diagnostics.runtimeProfile,
     warnOnTerminalOverflow: true
   });
 }
@@ -8342,7 +9312,7 @@ function registerSharedReportOptions(command, profile) {
     collectRepeatedOption
   ).option("--since <YYYY-MM-DD>", "Inclusive start date filter").option("--until <YYYY-MM-DD>", "Inclusive end date filter").option("--timezone <iana>", "Timezone for bucketing", defaultTimezone).option(
     "--provider <name>",
-    "Billing-provider filter (substring match, optional; e.g. openai, anthropic, google)"
+    "Billing-provider filter (normalized to billing entity; e.g. openai, anthropic, google)"
   ).option(
     "--model <name>",
     "Filter by model (repeatable/comma-separated; exact when exact match exists after source/provider/date filters, otherwise substring)",
@@ -8661,6 +9631,15 @@ var { packageName, packageVersion } = loadPackageMetadataFromRuntime();
 var updateRuntimeConfig = getUpdateNotifierRuntimeConfig();
 var cli = createCli({ version: packageVersion });
 async function main() {
+  if (process.env[UPDATE_CHECK_REFRESH_ENV_VAR] === "1") {
+    await refreshUpdateCheckCache({
+      packageName,
+      currentVersion: packageVersion,
+      cacheTtlMs: updateRuntimeConfig.cacheTtlMs,
+      fetchTimeoutMs: updateRuntimeConfig.fetchTimeoutMs
+    });
+    return;
+  }
   const updateResult = await checkForUpdatesAndMaybeRestart({
     packageName,
     currentVersion: packageVersion,