repospend 0.0.8 → 0.1.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // apps/server/src/cli.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 
 // packages/core/src/aggregate.ts
 function summarize(sessions) {
@@ -51,7 +51,12 @@ function groupByRepo(sessions) {
   }));
 }
 function groupByModel(sessions) {
-  return groupBy(sessions, (session) => session.model ?? "unknown-model", (session) => session.model ?? "Model not recorded");
+  const groups = groupBy(sessions, (session) => session.model ?? "unknown-model", (session) => session.model ?? "Model not recorded");
+  const unknownModelSessions = sessions.filter((session) => !session.model);
+  if (unknownModelSessions.length > 0 && unknownModelSessions.every(isClaudeSyntheticZeroUsageSession)) {
+    return groups.map((group) => group.id === "unknown-model" ? { ...group, label: "Claude synthetic / no usage" } : group);
+  }
+  return groups;
 }
 function groupBySourceApp(sessions) {
   return groupBy(sessions, (session) => session.sourceApp, (session) => session.sourceApp);
@@ -100,6 +105,9 @@ function groupBy(sessions, keyFn, labelFn) {
   }
   return [...groups.values()].sort((a, b) => (b.estimatedCostUsd ?? 0) - (a.estimatedCostUsd ?? 0) || b.totalTokens - a.totalTokens);
 }
+function isClaudeSyntheticZeroUsageSession(session) {
+  return session.warnings.includes("claude_synthetic_zero_usage");
+}
 function toCsv(sessions) {
   const columns = [
     "id",
@@ -195,7 +203,8 @@ function unique(values) {
   return [...new Set(values)].sort();
 }
 
-// packages/core/src/config.ts
+// packages/core/src/cache.ts
+import crypto from "node:crypto";
 import fs2 from "node:fs";
 import path2 from "node:path";
 
@@ -203,12 +212,99 @@ import path2 from "node:path";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+
+// packages/types/src/index.ts
+function normalizePricingModelId(model) {
+  return model.toLowerCase().replace(/^github_copilot\//, "").replace(/^github-copilot\//, "").replace(/^copilot\//, "").replace(/claude-(opus|sonnet|haiku)-(\d+)\.(\d+)(?=$|[-.])/, "claude-$1-$2-$3");
+}
+function claudePricingFamilyModel(model, isUsable = () => true) {
+  const families = [
+    "claude-opus-4-7",
+    "claude-opus-4-6",
+    "claude-opus-4-5",
+    "claude-opus-4-1",
+    "claude-opus-4",
+    "claude-sonnet-4-6",
+    "claude-sonnet-4-5",
+    "claude-sonnet-4",
+    "claude-haiku-4-5",
+    "claude-3-5-haiku"
+  ];
+  const normalized = normalizePricingModelId(model);
+  if (normalized === "claude-opus-4-6-fast-mode") return void 0;
+  return families.find((candidate) => (normalized === candidate || normalized.startsWith(`${candidate}-`) || normalized.startsWith(`${candidate}.`)) && isUsable(candidate));
+}
+function copilotPricingFamilyModel(model, isUsable = () => true) {
+  const normalized = normalizePricingModelId(model);
+  const claudeFamily = claudePricingFamilyModel(normalized, isUsable);
+  if (claudeFamily) return claudeFamily;
+  if ((normalized === "gpt-4.1" || normalized.startsWith("gpt-4.1-") || normalized.startsWith("gpt-41")) && isUsable("gpt-4.1")) return "gpt-4.1";
+  if ((normalized === "gemini-2.5-pro" || normalized.startsWith("gemini-2.5-pro-")) && isUsable("gemini-2.5-pro")) return "gemini-2.5-pro";
+  if ((normalized === "gemini-3-flash" || normalized.startsWith("gemini-3-flash-")) && isUsable("gemini-3-flash")) return "gemini-3-flash";
+  if ((normalized === "gemini-3.1-pro" || normalized.startsWith("gemini-3.1-pro-")) && isUsable("gemini-3.1-pro")) return "gemini-3.1-pro";
+  if ((normalized === "gemini-3.5-flash" || normalized.startsWith("gemini-3.5-flash-")) && isUsable("gemini-3.5-flash")) return "gemini-3.5-flash";
+  if ((normalized === "raptor-mini" || normalized.startsWith("raptor-mini-") || normalized.startsWith("oswe-vscode")) && isUsable("raptor-mini")) return "raptor-mini";
+  if ((normalized === "lark" || normalized.startsWith("lark-")) && isUsable("lark")) return "lark";
+  if ((normalized === "goldeneye" || normalized.startsWith("goldeneye-")) && isUsable("goldeneye")) return "goldeneye";
+  return void 0;
+}
+function parseVersionedModel(normalized) {
+  if (normalized.includes("fast-mode")) return void 0;
+  const claude = normalized.match(/^(claude-(?:opus|sonnet|haiku))-(\d+)(?:-(\d+))?/);
+  if (claude) {
+    const minor = claude[3] ? Number(claude[3]) : 0;
+    return { tier: claude[1], version: Number(claude[2]) + minor / 100 };
+  }
+  const gpt = normalized.match(/^(gpt)-(\d)(?:\.(\d+))?(-[a-z][a-z0-9-]*)?$/);
+  if (gpt) {
+    const minor = gpt[3] ? Number(gpt[3]) : 0;
+    return { tier: `gpt${gpt[4] ?? ""}`, version: Number(gpt[2]) + minor / 100 };
+  }
+  return void 0;
+}
+function versionedFallbackModel(model, knownModels, isUsable = () => true) {
+  const target = parseVersionedModel(normalizePricingModelId(model));
+  if (!target) return void 0;
+  let best;
+  for (const candidate of knownModels) {
+    const parsed = parseVersionedModel(normalizePricingModelId(candidate));
+    if (!parsed || parsed.tier !== target.tier || parsed.version > target.version) continue;
+    if (!isUsable(candidate)) continue;
+    if (!best || parsed.version > best.version) best = { id: candidate, version: parsed.version };
+  }
+  return best?.id;
+}
+function isCopilotAliasModel(model) {
+  const normalized = normalizePricingModelId(model);
+  return normalized.startsWith("raptor-mini") || normalized.startsWith("oswe-vscode") || normalized === "lark" || normalized.startsWith("lark-") || normalized.startsWith("goldeneye");
+}
+function positiveRate(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isUsableModelPricing(pricing) {
+  return positiveRate(pricing?.inputPerMillion) && positiveRate(pricing?.outputPerMillion);
+}
+function findModelPricing(model, pricing) {
+  const lower = normalizePricingModelId(model);
+  const exact = pricing[model] ?? pricing[lower];
+  if (isUsableModelPricing(exact)) return exact;
+  const versioned = versionedFallbackModel(lower, Object.keys(pricing), (candidate) => isUsableModelPricing(pricing[candidate]));
+  if (versioned) return pricing[versioned];
+  const claudeFamily = claudePricingFamilyModel(lower, (candidate) => isUsableModelPricing(pricing[candidate]));
+  if (claudeFamily) return pricing[claudeFamily];
+  const copilotFamily = copilotPricingFamilyModel(lower, (candidate) => isUsableModelPricing(pricing[candidate]));
+  if (copilotFamily) return pricing[copilotFamily];
+  return void 0;
+}
+
+// packages/core/src/pricing.ts
 var pricingInfo = {
-  sourceName: "Bundled OpenAI and Claude API pricing",
+  sourceName: "Bundled API-equivalent model pricing",
   sourceUrl: "https://developers.openai.com/api/docs/pricing",
   sourceUrls: [
     { label: "OpenAI pricing reference", url: "https://developers.openai.com/api/docs/pricing" },
-    { label: "Claude pricing reference", url: "https://platform.claude.com/docs/en/about-claude/pricing" }
+    { label: "Claude pricing reference", url: "https://platform.claude.com/docs/en/about-claude/pricing" },
+    { label: "GitHub Copilot model pricing reference", url: "https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing" }
   ],
   unit: "USD per 1M tokens",
   updatedAt: "2026-05-18",
@@ -237,8 +333,19 @@ var defaultPricing = {
   "gpt-5-pro": { inputPerMillion: 15, outputPerMillion: 120, reasoningOutputPerMillion: 120 },
   "gpt-5-mini": { inputPerMillion: 0.25, cachedInputPerMillion: 0.025, outputPerMillion: 2, reasoningOutputPerMillion: 2 },
   "gpt-5-nano": { inputPerMillion: 0.05, cachedInputPerMillion: 5e-3, outputPerMillion: 0.4, reasoningOutputPerMillion: 0.4 },
+  "gpt-4.1": { inputPerMillion: 2, cachedInputPerMillion: 0.5, outputPerMillion: 8 },
+  "gemini-2.5-pro": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, note: "GitHub Copilot supported Google-hosted model; API-equivalent estimate, not a Copilot bill." },
+  "gemini-3-flash": { inputPerMillion: 0.5, cachedInputPerMillion: 0.05, outputPerMillion: 3, note: "GitHub Copilot supported Google-hosted model; API-equivalent estimate, not a Copilot bill." },
+  "gemini-3.1-pro": { inputPerMillion: 2, cachedInputPerMillion: 0.2, outputPerMillion: 12, note: "GitHub Copilot supported Google-hosted model; API-equivalent estimate, not a Copilot bill." },
+  "gemini-3.5-flash": { inputPerMillion: 1.5, cachedInputPerMillion: 0.15, outputPerMillion: 9, note: "GitHub Copilot supported Google-hosted model; API-equivalent estimate, not a Copilot bill." },
+  "raptor-mini": { inputPerMillion: 0.25, cachedInputPerMillion: 0.025, outputPerMillion: 2, note: "GitHub Copilot fine-tuned model using GPT-5 mini pricing." },
+  "oswe-vscode-prime": { inputPerMillion: 0.25, cachedInputPerMillion: 0.025, outputPerMillion: 2, note: "GitHub Copilot Raptor mini internal model id." },
+  "lark": { inputPerMillion: 0.25, cachedInputPerMillion: 0.025, outputPerMillion: 2, note: "GitHub Copilot preview model; estimated with lightweight Copilot pricing." },
+  "goldeneye": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, note: "GitHub Copilot fine-tuned model using GPT-5.1-Codex pricing." },
+  "claude-opus-4-8": { inputPerMillion: 5, cacheCreationInputPerMillion: 6.25, cachedInputPerMillion: 0.5, outputPerMillion: 25 },
   "claude-opus-4-7": { inputPerMillion: 5, cacheCreationInputPerMillion: 6.25, cachedInputPerMillion: 0.5, outputPerMillion: 25 },
   "claude-opus-4-6": { inputPerMillion: 5, cacheCreationInputPerMillion: 6.25, cachedInputPerMillion: 0.5, outputPerMillion: 25 },
+  "claude-opus-4-6-fast-mode": { inputPerMillion: 0, cacheCreationInputPerMillion: 0, cachedInputPerMillion: 0, outputPerMillion: 0, note: "GitHub Copilot supported model, but public per-token pricing is not listed separately. RepoSpend leaves API-equivalent pricing unset." },
   "claude-opus-4-5": { inputPerMillion: 5, cacheCreationInputPerMillion: 6.25, cachedInputPerMillion: 0.5, outputPerMillion: 25 },
   "claude-opus-4-1": { inputPerMillion: 15, cacheCreationInputPerMillion: 18.75, cachedInputPerMillion: 1.5, outputPerMillion: 75 },
   "claude-opus-4": { inputPerMillion: 15, cacheCreationInputPerMillion: 18.75, cachedInputPerMillion: 1.5, outputPerMillion: 75 },
@@ -286,67 +393,266 @@ function calculateCostUsd(usage, pricing) {
   const cost = billableInput / 1e6 * modelPricing.inputPerMillion + usage.cachedInputTokens / 1e6 * cachedRate + cacheCreationInput / 1e6 * cacheCreationRate + usage.outputTokens / 1e6 * modelPricing.outputPerMillion + usage.reasoningTokens / 1e6 * reasoningRate;
   return Number(cost.toFixed(6));
 }
-function findModelPricing(model, pricing) {
-  const lower = model.toLowerCase();
-  const exactPricing = pricing[model] ?? pricing[lower];
-  if (isUsablePricing(exactPricing)) return exactPricing;
-  const familyPricing = claudeFamilyPricing(lower, pricing);
-  if (isUsablePricing(familyPricing)) return familyPricing;
-  return void 0;
+
+// packages/core/src/cache.ts
+var activeCacheVersion = "parse-v1";
+var preparedCacheRoot;
+function parseCacheRoot() {
+  return path2.join(repospendHome(), "cache", activeCacheVersion);
+}
+function readJsonCache(namespace, keyParts) {
+  const cachePath = cacheEntryPath(namespace, keyParts);
+  if (!cachePath || !fs2.existsSync(cachePath)) return void 0;
+  try {
+    return JSON.parse(fs2.readFileSync(cachePath, "utf8"));
+  } catch {
+    fs2.rmSync(cachePath, { force: true });
+    return void 0;
+  }
 }
-function claudeFamilyPricing(model, pricing) {
-  const families = [
-    "claude-opus-4-7",
-    "claude-opus-4-6",
-    "claude-opus-4-5",
-    "claude-opus-4-1",
-    "claude-opus-4",
-    "claude-sonnet-4-6",
-    "claude-sonnet-4-5",
-    "claude-sonnet-4",
-    "claude-haiku-4-5",
-    "claude-3-5-haiku"
-  ];
-  const family = families.find((candidate) => model === candidate || model.startsWith(`${candidate}-`));
-  return family ? pricing[family] : void 0;
+function writeJsonCache(namespace, keyParts, value) {
+  const cachePath = cacheEntryPath(namespace, keyParts);
+  if (!cachePath) return;
+  try {
+    fs2.mkdirSync(path2.dirname(cachePath), { recursive: true });
+    fs2.writeFileSync(cachePath, `${JSON.stringify(value)}
+`);
+  } catch {
+  }
+}
+function clearRepoSpendCache() {
+  const target = path2.join(repospendHome(), "cache");
+  const removed = fs2.existsSync(target);
+  fs2.rmSync(target, { recursive: true, force: true });
+  preparedCacheRoot = void 0;
+  return { path: target, removed };
+}
+function cacheEntryPath(namespace, keyParts) {
+  prepareCacheRoot();
+  const safeNamespace = namespace.replace(/[^a-z0-9_-]/gi, "-");
+  const key = crypto.createHash("sha256").update(JSON.stringify(keyParts)).digest("hex");
+  return path2.join(parseCacheRoot(), safeNamespace, `${key}.json`);
 }
-function isUsablePricing(pricing) {
-  return typeof pricing?.inputPerMillion === "number" && pricing.inputPerMillion > 0 && typeof pricing.outputPerMillion === "number" && pricing.outputPerMillion > 0;
+function prepareCacheRoot() {
+  const root = path2.join(repospendHome(), "cache");
+  if (preparedCacheRoot === root) return;
+  preparedCacheRoot = root;
+  try {
+    fs2.mkdirSync(parseCacheRoot(), { recursive: true });
+    for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== activeCacheVersion) {
+        fs2.rmSync(path2.join(root, entry.name), { recursive: true, force: true });
+      }
+    }
+  } catch {
+  }
 }
 
 // packages/core/src/config.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
 function configPath() {
-  return path2.join(repospendHome(), "config.json");
+  return path3.join(repospendHome(), "config.json");
 }
 function loadConfig() {
   return loadConfigWithWarnings().config;
 }
 function loadConfigWithWarnings() {
   const localConfigPath = configPath();
-  if (!fs2.existsSync(localConfigPath)) {
+  if (!fs3.existsSync(localConfigPath)) {
     return { config: {}, warnings: [] };
   }
   try {
-    return { config: JSON.parse(fs2.readFileSync(localConfigPath, "utf8")), warnings: [] };
+    return { config: JSON.parse(fs3.readFileSync(localConfigPath, "utf8")), warnings: [] };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return { config: {}, warnings: [`Unable to parse ${localConfigPath}: ${message}`] };
   }
 }
+function saveConfig(config) {
+  const localConfigPath = configPath();
+  fs3.mkdirSync(path3.dirname(localConfigPath), { recursive: true });
+  fs3.writeFileSync(localConfigPath, `${JSON.stringify(config, null, 2)}
+`);
+  return loadConfig();
+}
 function normalizePathForMatch(inputPath) {
-  return path2.resolve(inputPath).replace(/\/+$/, "");
+  return path3.resolve(inputPath).replace(/\/+$/, "");
 }
 function aliasForPath(repoRoot, config) {
   const resolvedRoot = normalizePathForMatch(repoRoot);
   const match = config.repos?.find(
     (repo) => repo.paths.some((repoPath) => {
       const candidate = normalizePathForMatch(repoPath);
-      return resolvedRoot === candidate || resolvedRoot.startsWith(`${candidate}${path2.sep}`);
+      return resolvedRoot === candidate || resolvedRoot.startsWith(`${candidate}${path3.sep}`);
     })
   );
   return match?.name;
 }
 
+// packages/core/src/data-confidence.ts
+function buildDataConfidence(input) {
+  const sessions = input.sessions;
+  const availableSources = input.sources.filter((source) => source.available);
+  const importedSessions = input.sourceStats.reduce((sum2, source) => sum2 + (source.sessionsImported ?? 0), 0);
+  const tokenDataSessions = sessions.filter((session) => session.totalTokens > 0);
+  const missingTokenSessions = sessions.filter((session) => session.totalTokens === 0 || session.warnings.includes("missing_token_breakdown"));
+  const pricedTokenSessions = tokenDataSessions.filter((session) => session.estimatedCostUsd !== void 0);
+  const unpricedTokenSessions = tokenDataSessions.filter((session) => session.estimatedCostUsd === void 0);
+  const highConfidenceTokenSessions = tokenDataSessions.filter((session) => session.tokenConfidence === "high");
+  const unknownRepoSessions = sessions.filter((session) => session.warnings.includes("repo_unverified_no_git_root"));
+  const verifiedRepoSessions = sessions.filter((session) => !unknownRepoSessions.includes(session));
+  const unknownSurfaceSessions = sessions.filter((session) => (session.detectedSurface ?? "unknown") === "unknown");
+  const parseIssueCount = Math.max(
+    input.scan.parseFailureCount ?? 0,
+    input.sourceStats.reduce((sum2, source) => sum2 + (source.parseFailureCount ?? 0), 0)
+  );
+  const sourceWarningCount = input.sources.reduce((sum2, source) => sum2 + source.warnings.length, 0);
+  const tokenDataPct = ratio(tokenDataSessions.length, sessions.length);
+  const pricingCoveragePct = tokenDataSessions.length > 0 ? ratio(pricedTokenSessions.length, tokenDataSessions.length) : sessions.length > 0 ? 0 : 1;
+  const highConfidenceTokenPct = tokenDataSessions.length > 0 ? ratio(highConfidenceTokenSessions.length, tokenDataSessions.length) : sessions.length > 0 ? 0 : 1;
+  const verifiedRepoPct = ratio(verifiedRepoSessions.length, sessions.length);
+  const parseHealthPct = parseIssueCount === 0 ? 1 : 1 - ratio(parseIssueCount, Math.max(input.scan.rawSessionCount ?? sessions.length, sessions.length, 1));
+  const rawScore = Math.round(100 * (tokenDataPct * 0.3 + pricingCoveragePct * 0.25 + verifiedRepoPct * 0.18 + highConfidenceTokenPct * 0.12 + Math.max(parseHealthPct, 0) * 0.15));
+  const score = emptyDataScore(availableSources.length, importedSessions) ?? rawScore;
+  const issues = dataConfidenceIssues({
+    sessions,
+    availableSources,
+    importedSessions,
+    tokenDataSessions,
+    missingTokenSessions,
+    unpricedTokenSessions,
+    unknownRepoSessions,
+    unknownSurfaceSessions,
+    parseIssueCount,
+    sourceWarningCount
+  });
+  return {
+    score,
+    label: score >= 80 ? "High" : score >= 55 ? "Medium" : "Low",
+    sessionCount: sessions.length,
+    sourceCount: availableSources.length,
+    tokenDataSessions: tokenDataSessions.length,
+    missingTokenSessions: missingTokenSessions.length,
+    pricedTokenSessions: pricedTokenSessions.length,
+    unpricedTokenSessions: unpricedTokenSessions.length,
+    highConfidenceTokenSessions: highConfidenceTokenSessions.length,
+    verifiedRepoSessions: verifiedRepoSessions.length,
+    unknownRepoSessions: unknownRepoSessions.length,
+    unknownSurfaceSessions: unknownSurfaceSessions.length,
+    parseIssueCount,
+    sourceWarningCount,
+    tokenDataPct,
+    pricingCoveragePct,
+    highConfidenceTokenPct,
+    verifiedRepoPct,
+    issues
+  };
+}
+function dataConfidenceIssues({
+  sessions,
+  availableSources,
+  importedSessions,
+  tokenDataSessions,
+  missingTokenSessions,
+  unpricedTokenSessions,
+  unknownRepoSessions,
+  unknownSurfaceSessions,
+  parseIssueCount,
+  sourceWarningCount
+}) {
+  const issues = [];
+  if (availableSources.length === 0) {
+    issues.push({
+      id: "no-local-sources",
+      title: "No local source data found",
+      detail: "RepoSpend did not find enabled local Codex, Claude Code, GitHub Copilot, or experimental Cursor data paths.",
+      tone: "critical",
+      affectedSessionIds: []
+    });
+  } else if (sessions.length === 0 && importedSessions === 0) {
+    issues.push({
+      id: "no-sessions-imported",
+      title: "No sessions imported",
+      detail: "Source paths exist, but no local sessions were imported for the current scan window.",
+      tone: "attention",
+      affectedSessionIds: []
+    });
+  }
+  if (tokenDataSessions.length === 0 && sessions.length > 0) {
+    issues.push({
+      id: "no-token-data",
+      title: "No token-bearing sessions",
+      detail: "Sessions were imported, but local files did not include token counts that RepoSpend can price or roll up.",
+      tone: "critical",
+      affectedSessionIds: sessions.map((session) => session.id)
+    });
+  } else if (missingTokenSessions.length > 0) {
+    issues.push({
+      id: "missing-token-data",
+      title: "Some sessions are missing token data",
+      detail: `${missingTokenSessions.length} session${missingTokenSessions.length === 1 ? "" : "s"} have no token total or are missing a full token breakdown.`,
+      tone: "attention",
+      affectedSessionIds: missingTokenSessions.map((session) => session.id)
+    });
+  }
+  if (unpricedTokenSessions.length > 0) {
+    issues.push({
+      id: "unpriced-token-sessions",
+      title: "Some token-bearing sessions are unpriced",
+      detail: `${unpricedTokenSessions.length} token-bearing session${unpricedTokenSessions.length === 1 ? "" : "s"} cannot show API-equivalent cost because pricing or token split coverage is missing.`,
+      tone: "attention",
+      affectedSessionIds: unpricedTokenSessions.map((session) => session.id)
+    });
+  }
+  if (parseIssueCount > 0) {
+    issues.push({
+      id: "parse-issues",
+      title: "Parser issues detected",
+      detail: `${parseIssueCount} local file${parseIssueCount === 1 ? "" : "s"} reported parse issues or skipped records.`,
+      tone: "attention",
+      affectedSessionIds: sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).map((session) => session.id)
+    });
+  }
+  if (unknownRepoSessions.length > 0) {
+    issues.push({
+      id: "unknown-repo-grouping",
+      title: "Some repo grouping is unverified",
+      detail: `${unknownRepoSessions.length} session${unknownRepoSessions.length === 1 ? "" : "s"} could not be tied to a verified Git root.`,
+      tone: "attention",
+      affectedSessionIds: unknownRepoSessions.map((session) => session.id)
+    });
+  }
+  if (unknownSurfaceSessions.length > 0) {
+    issues.push({
+      id: "unknown-surfaces",
+      title: "Some app surfaces are unknown",
+      detail: `${unknownSurfaceSessions.length} session${unknownSurfaceSessions.length === 1 ? "" : "s"} did not include enough metadata to identify the app or surface.`,
+      tone: "attention",
+      affectedSessionIds: unknownSurfaceSessions.map((session) => session.id)
+    });
+  }
+  if (sourceWarningCount > 0) {
+    issues.push({
+      id: "source-warnings",
+      title: "Source warnings were reported",
+      detail: `${sourceWarningCount} source warning${sourceWarningCount === 1 ? " was" : "s were"} reported during local discovery.`,
+      tone: "attention",
+      affectedSessionIds: []
+    });
+  }
+  return issues;
+}
+function ratio(numerator, denominator) {
+  if (denominator <= 0) return 1;
+  return numerator / denominator;
+}
+function emptyDataScore(availableSourceCount, importedSessions) {
+  if (availableSourceCount === 0) return 0;
+  if (importedSessions === 0) return 50;
+  return void 0;
+}
+
 // packages/core/src/filters.ts
 function filterUsage(sessions, filters) {
   return sessions.filter((session) => {
@@ -427,7 +733,20 @@ function repoWarnings(group, sessions) {
   return warnings;
 }
 function compactNumber(value) {
-  return new Intl.NumberFormat(void 0, { maximumFractionDigits: 1, notation: "compact" }).format(value);
+  if (!Number.isFinite(value)) return "0";
+  const sign = value < 0 ? "-" : "";
+  const absolute = Math.abs(value);
+  const units = [
+    { threshold: 1e12, suffix: "T" },
+    { threshold: 1e9, suffix: "B" },
+    { threshold: 1e6, suffix: "M" },
+    { threshold: 1e3, suffix: "K" }
+  ];
+  const unit = units.find((item) => absolute >= item.threshold);
+  if (!unit) return new Intl.NumberFormat(void 0, { maximumFractionDigits: 1 }).format(value);
+  const scaled = absolute / unit.threshold;
+  const formatted = new Intl.NumberFormat(void 0, { maximumFractionDigits: 1 }).format(scaled);
+  return `${sign}${formatted}${unit.suffix}`;
 }
 function unique2(values) {
   return [...new Set(values)].sort();
@@ -591,7 +910,7 @@ var healthSignalDetectors = [
       return {
         id: "command-friction",
         tone: "attention",
-        title: "Important command issue rate looks high",
+        title: "Possible failed command rate looks high",
         detail: `${percent(commandIssueRate)} of detected shell commands look like blocking, repeated, or token-expensive issues in this filtered view.`,
         action: "Look for repeated setup, dependency, permission, test, or build issues in the Sessions page.",
         actionTarget: "sessions",
@@ -662,9 +981,9 @@ var healthSignalDetectors = [
         tone: "attention",
         title: "Some sessions cannot be priced",
         detail: `${count(unknownCostSessions.length, "session")} are missing a model price or detailed token split.`,
-        action: "Open Settings and add model rates, or inspect older Codex sessions that only expose raw totals.",
-        actionTarget: "settings",
-        actionLabel: "Open settings",
+        action: "Review the affected sessions first. Add a model rate only when the session has token details but no usable price.",
+        actionTarget: "sessions",
+        actionLabel: "Review unpriced sessions",
         metric: count(unknownCostSessions.length, "session"),
         critical: true,
         affectedSessionIds: unknownCostSessions.map((session) => session.id)
@@ -758,7 +1077,7 @@ function buildWasteSignals(sessions) {
 var wasteSignalDetectors = [
   wasteSignalDetector("high-token-no-edit", "High-token no-edit sessions", "Large sessions where local events did not show file edits.", (session) => (session.fileEditCount ?? 0) === 0 && session.totalTokens >= 1e6),
   wasteSignalDetector("high-token-low-output", "High-token low-output sessions", "Large sessions where most tokens were input or cached context.", (session) => session.totalTokens >= 1e6 && session.outputTokens / Math.max(session.totalTokens, 1) < 0.03),
-  wasteSignalDetector("command-issue-sessions", "Command issue sessions", "Sessions with blocking, repeated, or token-expensive command issues.", (session) => importantCommandFailures(session) > 0),
+  wasteSignalDetector("command-issue-sessions", "Possible failed command sessions", "Sessions with blocking, repeated, or token-expensive command failures.", (session) => importantCommandFailures(session) > 0),
   wasteSignalDetector("unknown-repos", "Unknown repo sessions", "Repo root could not be verified from local Git metadata.", (session) => session.warnings.includes("repo_unverified_no_git_root")),
   wasteSignalDetector("unknown-surfaces", "Unknown surface sessions", "Local logs did not identify VS Code, terminal, exec, or app surface.", (session) => (session.detectedSurface ?? "unknown") === "unknown"),
   wasteSignalDetector("repeated-errors", "Repeated error signals", "Repeated-error hints found in session warnings.", (session) => session.warnings.some((warning) => warning.includes("repeated_error")))
@@ -810,7 +1129,20 @@ function percent(value) {
   return `${new Intl.NumberFormat(void 0, { maximumFractionDigits: 1 }).format(value * 100)}%`;
 }
 function compactNumber2(value) {
-  return new Intl.NumberFormat(void 0, { maximumFractionDigits: 1, notation: "compact" }).format(value);
+  if (!Number.isFinite(value)) return "0";
+  const sign = value < 0 ? "-" : "";
+  const absolute = Math.abs(value);
+  const units = [
+    { threshold: 1e12, suffix: "T" },
+    { threshold: 1e9, suffix: "B" },
+    { threshold: 1e6, suffix: "M" },
+    { threshold: 1e3, suffix: "K" }
+  ];
+  const unit = units.find((item) => absolute >= item.threshold);
+  if (!unit) return new Intl.NumberFormat(void 0, { maximumFractionDigits: 1 }).format(value);
+  const scaled = absolute / unit.threshold;
+  const formatted = new Intl.NumberFormat(void 0, { maximumFractionDigits: 1 }).format(scaled);
+  return `${sign}${formatted}${unit.suffix}`;
 }
 function currency(value, minimumFractionDigits, maximumFractionDigits) {
   return `$${new Intl.NumberFormat(void 0, { maximumFractionDigits, minimumFractionDigits }).format(value)}`;
@@ -853,24 +1185,25 @@ function buildDashboardSnapshot(input) {
     hours: groupByHour(sessions),
     models: groupByModel(sessions),
     sourceApps,
-    health: buildUsageHealth({ sessions, summary, repos, sourceApps, scan })
+    health: buildUsageHealth({ sessions, summary, repos, sourceApps, scan }),
+    confidence: buildDataConfidence({ sources: input.sources, sourceStats: input.sourceStats, sessions, scan })
   };
 }
 function isDashboardVisibleSession(session) {
-  return session.totalTokens > 0 || session.sourceClient === "claude" || session.sourceClient === "cursor";
+  return session.totalTokens > 0 || session.sourceClient === "claude" || session.sourceClient === "cursor" || session.sourceClient === "copilot";
 }
 
 // packages/core/src/repo.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 function normalizeRoot(p) {
   const stripped = p.startsWith("\\\\?\\") ? p.slice(4) : p;
   return stripped.replace(/^([a-zA-Z]):/, (_, letter) => letter.toUpperCase() + ":");
 }
-function findGitRoot(cwd, fileSystem = fs3) {
-  let current = normalizeRoot(path3.resolve(cwd));
+function findGitRoot(cwd, fileSystem = fs4) {
+  let current = normalizeRoot(path4.resolve(cwd));
   while (true) {
-    const gitPath = path3.join(current, ".git");
+    const gitPath = path4.join(current, ".git");
     if (fileSystem.existsSync(gitPath)) {
       try {
         const stat = fileSystem.statSync(gitPath);
@@ -881,19 +1214,19 @@ function findGitRoot(cwd, fileSystem = fs3) {
         return current;
       }
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       return void 0;
     }
     current = parent;
   }
 }
-function resolveRepoInfo(cwd, config = {}, fileSystem = fs3) {
+function resolveRepoInfo(cwd, config = {}, fileSystem = fs4) {
   const warnings = [];
   const gitRoot = safeFindGitRoot(cwd, fileSystem);
   const repoRoot = gitRoot ?? fallbackWorkspaceRoot(cwd);
   const alias = aliasForPath(repoRoot, config);
-  const repoName = alias ?? (path3.basename(repoRoot) || "unknown-workspace");
+  const repoName = alias ?? (path4.basename(repoRoot) || "unknown-workspace");
   const gitMeta = gitRoot ? readGitMetadata(gitRoot, fileSystem) : { remote: void 0, branch: void 0 };
   if (!gitRoot) {
     warnings.push("repo_unverified_no_git_root");
@@ -915,23 +1248,23 @@ function safeFindGitRoot(cwd, fileSystem) {
   }
 }
 function fallbackWorkspaceRoot(cwd) {
-  const resolved = normalizeRoot(path3.resolve(cwd || process.cwd()));
-  const home = process.env.HOME ? normalizeRoot(path3.resolve(process.env.HOME)) : void 0;
-  if (home && (resolved === home || resolved.startsWith(`${home}${path3.sep}`))) {
-    const relative = path3.relative(home, resolved).split(path3.sep).filter(Boolean);
+  const resolved = normalizeRoot(path4.resolve(cwd || process.cwd()));
+  const home = process.env.HOME ? normalizeRoot(path4.resolve(process.env.HOME)) : void 0;
+  if (home && (resolved === home || resolved.startsWith(`${home}${path4.sep}`))) {
+    const relative = path4.relative(home, resolved).split(path4.sep).filter(Boolean);
     const first = relative[0];
-    return first ? path3.join(home, first) : home;
+    return first ? path4.join(home, first) : home;
   }
-  const parts = resolved.split(path3.sep).filter(Boolean);
-  return `${path3.sep}${parts.slice(0, Math.min(parts.length, 3)).join(path3.sep)}`;
+  const parts = resolved.split(path4.sep).filter(Boolean);
+  return `${path4.sep}${parts.slice(0, Math.min(parts.length, 3)).join(path4.sep)}`;
 }
 function readGitMetadata(repoRoot, fileSystem) {
-  const gitPath = path3.join(repoRoot, ".git");
+  const gitPath = path4.join(repoRoot, ".git");
   try {
     const stat = fileSystem.statSync(gitPath);
     const gitDir = stat.isFile() ? resolveGitFile(repoRoot, fileSystem.readFileSync(gitPath, "utf8")) : gitPath;
-    const configPath2 = path3.join(gitDir, "config");
-    const headPath = path3.join(gitDir, "HEAD");
+    const configPath2 = path4.join(gitDir, "config");
+    const headPath = path4.join(gitDir, "HEAD");
     const remote = fileSystem.existsSync(configPath2) ? parseRemote(fileSystem.readFileSync(configPath2, "utf8")) : void 0;
     const branch = fileSystem.existsSync(headPath) ? parseBranch(fileSystem.readFileSync(headPath, "utf8")) : void 0;
     return { remote, branch };
@@ -942,9 +1275,9 @@ function readGitMetadata(repoRoot, fileSystem) {
 function resolveGitFile(repoRoot, contents) {
   const match = contents.match(/^gitdir:\s*(.+)$/m);
   if (!match?.[1]) {
-    return path3.join(repoRoot, ".git");
+    return path4.join(repoRoot, ".git");
   }
-  return path3.resolve(repoRoot, match[1].trim());
+  return path4.resolve(repoRoot, match[1].trim());
 }
 function parseRemote(config) {
   const originMatch = config.match(/\[remote "origin"\][\s\S]*?\n\s*url\s*=\s*(.+)/);
@@ -957,9 +1290,9 @@ function parseBranch(head) {
 
 // packages/core/src/sources/codex.ts
 import { spawnSync } from "node:child_process";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os2 from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import Database from "better-sqlite3";
 
@@ -967,8 +1300,9 @@ import Database from "better-sqlite3";
 function analyzeAgentFriction(records, totalTokens) {
   const analysis = emptyAgentFrictionAnalysis();
   const messages = [];
+  const toolCallsById = indexToolCallsById(records);
   for (const record of records) {
-    applyActionMetadata(analysis, record, messages);
+    applyActionMetadata(analysis, record, messages, toolCallsById);
   }
   finalizeCommandIssues(analysis, totalTokens);
   return analysis;
@@ -994,7 +1328,7 @@ function emptyAgentFrictionAnalysis() {
     assistantMessageCount: 0
   };
 }
-function applyActionMetadata(analysis, record, messages) {
+function applyActionMetadata(analysis, record, messages, toolCallsById) {
   if (!record || typeof record !== "object") return;
   const object = record;
   const payload = firstObject(object.payload) ?? object;
@@ -1005,12 +1339,73 @@ function applyActionMetadata(analysis, record, messages) {
   const text = JSON.stringify(record).toLowerCase();
   const isTool = type?.includes("tool") || type?.includes("function_call") || text.includes('"tool_call"') || text.includes('"function_call"');
   if (isTool) analysis.toolCallCount += 1;
-  const isNonZeroCommand = text.includes("exit_code") && !text.includes('"exit_code":0') && !text.includes('"exit_code": 0');
-  if (isNonZeroCommand) analysis.commandIssues.push(classifyCommandIssue(record, analysis.commandIssues));
+  const isNonZeroCommand = hasNonZeroCommandExit(record);
+  if (isNonZeroCommand) analysis.commandIssues.push(classifyCommandIssue(record, analysis.commandIssues, commandTextForToolOutput(record, toolCallsById)));
   if (/\b(exec_command|shell|bash|zsh|command)\b/.test(text)) analysis.shellCommandCount += 1;
   if (/\b(read_file|view_image|cat |sed |rg |grep |open_file)\b/.test(text)) analysis.fileReadCount += 1;
   if (/\b(apply_patch|write_file|edit|patch|created|deleted)\b/.test(text)) analysis.fileEditCount += 1;
 }
+function indexToolCallsById(records) {
+  const calls = /* @__PURE__ */ new Map();
+  const sessionCommands = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!record || typeof record !== "object") continue;
+    const object = record;
+    const payload = firstObject(object.payload) ?? object;
+    const type = `${stringValue(object.type) ?? ""} ${stringValue(payload.type) ?? ""}`.toLowerCase();
+    const callId = stringValue(payload.call_id ?? object.call_id ?? payload.callId ?? object.callId);
+    if (type.includes("function_call_output") || type.includes("custom_tool_call_output") || type.includes("tool_result")) {
+      const output = stringValue(payload.output ?? object.output);
+      const sessionId = output?.match(/\bProcess running with session ID\s+(\d+)\b/i)?.[1];
+      const command3 = callId ? calls.get(callId) : void 0;
+      if (sessionId && command3) sessionCommands.set(sessionId, command3);
+      continue;
+    }
+    if (!type.includes("function_call") && !type.includes("custom_tool_call") && !type.includes("tool_call")) continue;
+    const command2 = toolCallCommandText(payload, sessionCommands) ?? toolCallCommandText(object, sessionCommands);
+    if (callId && command2) calls.set(callId, command2);
+  }
+  return calls;
+}
+function commandTextForToolOutput(record, toolCallsById) {
+  if (!record || typeof record !== "object") return void 0;
+  const object = record;
+  const payload = firstObject(object.payload) ?? object;
+  const callId = stringValue(payload.call_id ?? object.call_id ?? payload.callId ?? object.callId);
+  return callId ? toolCallsById.get(callId) : void 0;
+}
+function toolCallCommandText(object, sessionCommands) {
+  const name = `${stringValue(object.name) ?? ""} ${stringValue(object.recipient_name) ?? ""}`.toLowerCase();
+  const args2 = object.arguments ?? object.args ?? object.input;
+  const parsedArgs = typeof args2 === "string" ? parseJsonObject(args2) : firstObject(args2);
+  const sessionId = parsedArgs ? idValue(parsedArgs.session_id) : void 0;
+  if (sessionId && sessionCommands.has(sessionId)) return sessionCommands.get(sessionId);
+  const command2 = parsedArgs ? extractCommandText(parsedArgs) : void 0;
+  if (command2) return command2;
+  if ((name.includes("exec_command") || name.includes("shell")) && typeof args2 === "string" && args2.trim()) return args2;
+  const toolName = stringValue(object.name) ?? stringValue(object.recipient_name);
+  if (!toolName) return void 0;
+  return sessionId ? `${toolName} session ${sessionId}` : toolName;
+}
+function hasNonZeroCommandExit(record) {
+  if (!record || typeof record !== "object") return false;
+  const object = record;
+  const payload = firstObject(object.payload) ?? object;
+  const type = `${stringValue(object.type) ?? ""} ${stringValue(payload.type) ?? ""}`.toLowerCase();
+  const isCommandRecord = /(function_call_output|custom_tool_call_output|tool_result|exec_command|shell|command)/.test(type) || Boolean(extractCommandText(payload) ?? extractCommandText(object));
+  const explicitExitCode = exitCodeValue(payload) ?? exitCodeValue(object);
+  if (explicitExitCode !== void 0) return isCommandRecord && explicitExitCode !== 0;
+  const output = stringValue(payload.output) ?? stringValue(object.output);
+  if (!output || !/(function_call_output|custom_tool_call_output|tool_result|exec_command)/.test(type)) return false;
+  const processExitCode = output.match(/\bProcess exited with code\s+(-?\d+)\b/i)?.[1];
+  return processExitCode !== void 0 && Number(processExitCode) !== 0;
+}
+function exitCodeValue(object) {
+  const value = object.exit_code ?? object.exitCode;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) return Number(value);
+  return void 0;
+}
 function finalizeCommandIssues(analysis, totalTokens) {
   const repeatedCommands = /* @__PURE__ */ new Map();
   const repeatableIssues = analysis.commandIssues.filter((issue2) => issue2.classification !== "harmless_nonzero" && issue2.classification !== "exploratory_miss");
@@ -1055,30 +1450,38 @@ function issuePriority(issue2) {
   return severityScore * 10 + impactScore;
 }
 function commandIssueReason(issue2) {
-  if (issue2.severity === "critical") return "Repeated or blocking command issue that may have stopped progress.";
-  if (issue2.severity === "warning") return "Non-zero command event classified as important for this session.";
+  if (issue2.severity === "critical") return "Repeated or blocking command failure that may have stopped progress.";
+  if (issue2.severity === "warning") return "Non-zero command event classified as worth reviewing for this session.";
   if (issue2.classification === "exploratory_miss") return "Likely exploratory command that found no result.";
   if (issue2.classification === "harmless_nonzero") return "Likely harmless non-zero exit during normal shell exploration.";
   return "Non-zero command event with limited local context.";
 }
-function classifyCommandIssue(record, previousIssues) {
+function classifyCommandIssue(record, previousIssues, commandHint) {
   const raw = JSON.stringify(record);
   const text = raw.toLowerCase();
-  const command2 = extractCommandText(record) ?? compactCommandText(raw);
-  const category = commandCategory(text);
+  const command2 = commandHint ?? extractCommandText(record) ?? compactCommandText(raw);
+  const commandText = command2.toLowerCase();
+  const classificationText = commandHint ? `${commandText} ${commandOutputText(record) ?? ""}` : text;
+  const category = commandCategory(commandHint ? commandText : text);
   const commandKey = normalizeCommand(command2);
   const repeated = previousIssues.filter((issue2) => issue2.command === commandKey).length + 1 >= 3;
-  if (isHarmlessNonZero(text)) {
-    return { command: commandKey, category, classification: isExploratoryMiss(text) ? "exploratory_miss" : "harmless_nonzero", severity: "ignored", impact: "low" };
+  if (isHarmlessNonZero(classificationText)) {
+    return { command: commandKey, category, classification: isExploratoryMiss(classificationText) ? "exploratory_miss" : "harmless_nonzero", severity: "ignored", impact: "low" };
   }
-  if (isImportantFailure(text, category) || repeated) {
-    return { command: commandKey, category, classification: "blocking_failure", severity: repeated ? "critical" : importantSeverity(text, category), impact: repeated ? "high" : importantImpact(category) };
+  if (isImportantFailure(classificationText, category) || repeated) {
+    return { command: commandKey, category, classification: "blocking_failure", severity: repeated ? "critical" : importantSeverity(classificationText, category), impact: repeated ? "high" : importantImpact(category) };
   }
   if (category === "search" || category === "filesystem") {
     return { command: commandKey, category, classification: "exploratory_miss", severity: "ignored", impact: "low" };
   }
   return { command: commandKey, category, classification: "unknown", severity: "info", impact: "low" };
 }
+function commandOutputText(record) {
+  if (!record || typeof record !== "object") return void 0;
+  const object = record;
+  const payload = firstObject(object.payload) ?? object;
+  return stringValue(payload.output ?? object.output)?.toLowerCase().slice(0, 2e3);
+}
 function isHarmlessNonZero(text) {
   return /\b(rg|grep)\b/.test(text) || /git\s+(diff|status)/.test(text) || /\bfind\b/.test(text) || /\btest\s+(-f|-d|-e)\b/.test(text) || /\b(ls|cat)\b/.test(text) && /(optional|exists|existence|not found|no such file)/.test(text);
 }
@@ -1158,9 +1561,21 @@ function compactCommandText(text) {
 function firstObject(...values) {
   return values.find((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
 }
+function parseJsonObject(value) {
+  try {
+    return firstObject(JSON.parse(value));
+  } catch {
+    return void 0;
+  }
+}
 function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function idValue(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return void 0;
+}
 function applyMessageCount(analysis, messages, role, payload, object) {
   const message = extractMessageText(payload) ?? extractMessageText(object);
   if (!message) return;
@@ -1398,36 +1813,44 @@ function numberFromKeys(object, keys) {
 }
 
 // packages/core/src/sources/codex.ts
+var codexSessionCacheVersion = "codex-session-v1";
 var nativeSqliteRebuildAttempted = false;
 function scanCodex(options) {
-  const codexHome = options.codexHome ?? path4.join(os2.homedir(), ".codex");
-  const statePath = path4.join(codexHome, "state_5.sqlite");
-  const sessionsPath = path4.join(codexHome, "sessions");
+  const codexHome = options.codexHome ?? path5.join(os2.homedir(), ".codex");
+  const statePath = path5.join(codexHome, "state_5.sqlite");
+  const sessionsPath = path5.join(codexHome, "sessions");
+  const configPath2 = path5.join(codexHome, "config.toml");
+  const configExists = fs5.existsSync(configPath2);
+  const serviceTier = readCodexServiceTier(configPath2);
   const warnings = [];
   const sessions = [];
-  const stateExists = fs4.existsSync(statePath);
-  const sessionsExists = fs4.existsSync(sessionsPath);
+  const stateExists = fs5.existsSync(statePath);
+  const sessionsExists = fs5.existsSync(sessionsPath);
   if (!stateExists) {
     warnings.push(`Codex SQLite state not found at ${statePath}`);
   }
   if (!sessionsExists) {
     warnings.push(`Codex sessions directory not found at ${sessionsPath}`);
   }
-  const sessionFiles = sessionsExists ? indexSessionFiles(sessionsPath, warnings) : /* @__PURE__ */ new Map();
+  const sessionFiles = sessionsExists ? indexSessionFiles(sessionsPath, warnings, options.scanWindow) : /* @__PURE__ */ new Map();
   if (stateExists) {
     const stateSessions = readThreads(statePath, sessionFiles, options, warnings);
     sessions.push(...stateSessions);
   }
   if (sessionsExists) {
-    sessions.push(...readStandaloneSessions(sessionFiles, options).filter((session) => !hasImportedSession(sessions, session)));
+    sessions.push(...readStandaloneSessions(remainingStandaloneSessionFiles(sessionFiles, sessions), options).filter((session) => !hasImportedSession(sessions, session)));
   }
   return {
     source: {
       id: "codex",
       label: "Codex",
       available: stateExists || sessionsExists,
-      paths: [statePath, sessionsPath],
-      warnings
+      paths: configExists ? [statePath, sessionsPath, configPath2] : [statePath, sessionsPath],
+      warnings,
+      serviceTier,
+      serviceTierSource: serviceTier ? "current_config" : void 0,
+      serviceTierConfidence: serviceTier ? "medium" : void 0,
+      serviceTierDetail: serviceTier ? `Current Codex config service_tier: ${serviceTier}` : void 0
     },
     sessions,
     stats: {
@@ -1443,10 +1866,23 @@ function scanCodex(options) {
       sessionsImported: sessions.length,
       parseFailureCount: sessions.filter((session) => session.parseStatus === "failed").length,
       unreadableFileCount: sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("unable_to_read_session_file:"))).length,
+      serviceTier,
+      serviceTierSource: serviceTier ? "current_config" : void 0,
+      serviceTierConfidence: serviceTier ? "medium" : void 0,
+      serviceTierDetail: serviceTier ? `Current Codex config service_tier: ${serviceTier}` : void 0,
       lastScannedAt: (/* @__PURE__ */ new Date()).toISOString()
     }
   };
 }
+function readCodexServiceTier(configPath2) {
+  try {
+    const text = fs5.readFileSync(configPath2, "utf8");
+    const match = text.match(/^\s*service_tier\s*=\s*["']?([^"'\s#]+)["']?/m);
+    return match?.[1]?.trim().toLowerCase() || void 0;
+  } catch {
+    return void 0;
+  }
+}
 function readThreads(statePath, sessionFiles, options, warnings) {
   let db;
   try {
@@ -1462,8 +1898,8 @@ function readThreads(statePath, sessionFiles, options, warnings) {
       warnings.push("Codex threads table has no recognized columns.");
       return [];
     }
-    const importedModels = readImportedModelMap(options.codexHome ?? path4.join(os2.homedir(), ".codex"), warnings);
-    const rows = db.prepare(`SELECT ${selectedColumns.map((column) => `"${column}"`).join(", ")} FROM threads`).all();
+    const importedModels = readImportedModelMap(options.codexHome ?? path5.join(os2.homedir(), ".codex"), warnings);
+    const rows = db.prepare(`SELECT ${selectedColumns.map((column) => `"${column}"`).join(", ")} FROM threads`).all().filter((row) => rowMatchesScanWindow(row, options.scanWindow));
     const sessions = rows.map((row, index) => threadToUsage(row, index, sessionFiles, options, importedModels));
     return attributeSubagentsToParentSurfaces(sessions, rows);
   } catch (error) {
@@ -1522,7 +1958,7 @@ function attemptNativeSqliteRebuild(warnings) {
     warnings.push("Codex SQLite native module mismatch detected, but RepoSpend could not locate its package root for an automatic rebuild.");
     return false;
   }
-  const packageManager = fs4.existsSync(path4.join(packageRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  const packageManager = fs5.existsSync(path5.join(packageRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
   const result = spawnSync(packageManager, ["rebuild", "better-sqlite3"], {
     cwd: packageRoot,
     encoding: "utf8",
@@ -1536,8 +1972,8 @@ function attemptNativeSqliteRebuild(warnings) {
 }
 function findRepoSpendPackageRoot() {
   const starts = [
-    process.argv[1] ? path4.dirname(fs4.realpathSync(process.argv[1])) : void 0,
-    path4.dirname(fileURLToPath(import.meta.url)),
+    process.argv[1] ? path5.dirname(fs5.realpathSync(process.argv[1])) : void 0,
+    path5.dirname(fileURLToPath(import.meta.url)),
     process.cwd()
   ].filter((item) => Boolean(item));
   for (const start of starts) {
@@ -1547,17 +1983,17 @@ function findRepoSpendPackageRoot() {
   return void 0;
 }
 function findPackageRootNamedRepoSpend(start) {
-  let current = path4.resolve(start);
+  let current = path5.resolve(start);
   while (true) {
-    const packagePath = path4.join(current, "package.json");
-    if (fs4.existsSync(packagePath)) {
+    const packagePath = path5.join(current, "package.json");
+    if (fs5.existsSync(packagePath)) {
       try {
-        const packageJson = JSON.parse(fs4.readFileSync(packagePath, "utf8"));
+        const packageJson = JSON.parse(fs5.readFileSync(packagePath, "utf8"));
         if (packageJson.name === "repospend") return current;
       } catch {
       }
     }
-    const parent = path4.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -1619,7 +2055,7 @@ function threadToUsage(row, index, sessionFiles, options, importedModels = /* @_
     messageCount: sessionBreakdown.messageCount,
     rawTokenTotal: dbTokens || sessionBreakdown.totalTokens || void 0,
     warnings,
-    codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
+    codexHome: options.codexHome ?? path5.join(os2.homedir(), ".codex"),
     durationMs: durationMs(startedAt, endedAt),
     rawEventCount: sessionBreakdown.rawEventCount,
     parseStatus: sessionBreakdown.parseStatus,
@@ -1693,7 +2129,7 @@ function readStandaloneSessions(sessionFiles, options) {
       messageCount: breakdown.messageCount,
       rawTokenTotal: breakdown.totalTokens || void 0,
       warnings: [...repo.warnings, ...breakdown.warnings],
-      codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
+      codexHome: options.codexHome ?? path5.join(os2.homedir(), ".codex"),
       durationMs: durationMs(breakdown.startedAt, breakdown.endedAt),
       rawEventCount: breakdown.rawEventCount,
       parseStatus: breakdown.parseStatus,
@@ -1738,13 +2174,18 @@ function hasImportedSession(sessions, candidate) {
     return Boolean(candidatePath && sessionPath && candidatePath === sessionPath);
   });
 }
+function remainingStandaloneSessionFiles(sessionFiles, importedSessions) {
+  const importedIds = new Set(importedSessions.map((session) => session.id).filter(Boolean));
+  const importedPaths = new Set(importedSessions.map((session) => comparableSourcePath(session.sourcePath)).filter(Boolean));
+  return new Map([...sessionFiles.entries()].filter(([id, sourcePath]) => !importedIds.has(id) && !importedPaths.has(comparableSourcePath(sourcePath))));
+}
 function readImportedModelMap(codexHome, warnings) {
-  const importsPath = path4.join(codexHome, "external_agent_session_imports.json");
+  const importsPath = path5.join(codexHome, "external_agent_session_imports.json");
   const models = /* @__PURE__ */ new Map();
-  if (!fs4.existsSync(importsPath)) return models;
+  if (!fs5.existsSync(importsPath)) return models;
   let parsed;
   try {
-    parsed = JSON.parse(fs4.readFileSync(importsPath, "utf8"));
+    parsed = JSON.parse(fs5.readFileSync(importsPath, "utf8"));
   } catch (error) {
     warnings.push(`Unable to read Codex external import index at ${importsPath}: ${errorMessage(error)}`);
     return models;
@@ -1754,7 +2195,7 @@ function readImportedModelMap(codexHome, warnings) {
     const item = asRecord(record);
     const importedThreadId = stringValue2(item?.imported_thread_id);
     const sourcePath = normalizeVerbatimPath(stringValue2(item?.source_path));
-    if (!importedThreadId || !sourcePath || !fs4.existsSync(sourcePath)) continue;
+    if (!importedThreadId || !sourcePath || !fs5.existsSync(sourcePath)) continue;
     const model = readImportedSourceModel(sourcePath, warnings);
     if (model) models.set(importedThreadId, { model, provider: providerForModel(model) });
   }
@@ -1764,7 +2205,7 @@ function readImportedSourceModel(sourcePath, warnings) {
   const counts = /* @__PURE__ */ new Map();
   let content;
   try {
-    content = fs4.readFileSync(sourcePath, "utf8");
+    content = fs5.readFileSync(sourcePath, "utf8");
   } catch (error) {
     warnings.push(`Unable to read Codex external import source at ${sourcePath}: ${errorMessage(error)}`);
     return void 0;
@@ -1802,12 +2243,13 @@ function normalizeVerbatimPath(value) {
 function comparableSourcePath(value) {
   return normalizeVerbatimPath(value)?.replace(/\\/g, "/");
 }
-function indexSessionFiles(sessionsPath, warnings) {
+function indexSessionFiles(sessionsPath, warnings, scanWindow) {
   const files = /* @__PURE__ */ new Map();
   try {
     walk(sessionsPath, (filePath) => {
       if (!/\.(jsonl|json|log)$/i.test(filePath)) return;
-      const id = path4.basename(filePath).replace(/\.(jsonl|json|log)$/i, "");
+      if (!fileMayOverlapScanWindow(filePath, scanWindow)) return;
+      const id = path5.basename(filePath).replace(/\.(jsonl|json|log)$/i, "");
       files.set(id, filePath);
     });
   } catch (error) {
@@ -1815,9 +2257,26 @@ function indexSessionFiles(sessionsPath, warnings) {
   }
   return files;
 }
+function rowMatchesScanWindow(row, scanWindow) {
+  if (!scanWindow?.fromMs && !scanWindow?.toMs) return true;
+  const updatedAt = timestampMs(row.updated_at);
+  const createdAt = timestampMs(row.created_at);
+  const latestTimestamp = updatedAt ?? createdAt;
+  if (scanWindow.fromMs !== void 0 && latestTimestamp !== void 0 && latestTimestamp < scanWindow.fromMs) return false;
+  if (scanWindow.toMs !== void 0 && createdAt !== void 0 && createdAt > scanWindow.toMs) return false;
+  return true;
+}
+function fileMayOverlapScanWindow(filePath, scanWindow) {
+  if (!scanWindow?.fromMs) return true;
+  try {
+    return fs5.statSync(filePath).mtimeMs >= scanWindow.fromMs;
+  } catch {
+    return true;
+  }
+}
 function walk(root, onFile) {
-  for (const entry of fs4.readdirSync(root, { withFileTypes: true })) {
-    const fullPath = path4.join(root, entry.name);
+  for (const entry of fs5.readdirSync(root, { withFileTypes: true })) {
+    const fullPath = path5.join(root, entry.name);
     if (entry.isDirectory()) {
       walk(fullPath, onFile);
     } else if (entry.isFile()) {
@@ -1826,9 +2285,12 @@ function walk(root, onFile) {
   }
 }
 function readSessionBreakdown(filePath) {
+  const cacheKey = sessionBreakdownCacheKey(filePath);
+  const cached = cacheKey ? readJsonCache("codex-session", cacheKey) : void 0;
+  if (cached) return cached;
   const breakdown = emptyBreakdown();
   try {
-    const text = fs4.readFileSync(filePath, "utf8");
+    const text = fs5.readFileSync(filePath, "utf8");
     const parse = parseSessionRecords(text);
     const records = parse.records;
     breakdown.rawEventCount = records.length;
@@ -1860,8 +2322,22 @@ function readSessionBreakdown(filePath) {
     breakdown.parseErrors.push(message);
     breakdown.warnings.push(message);
   }
+  if (cacheKey) writeJsonCache("codex-session", cacheKey, breakdown);
   return breakdown;
 }
+function sessionBreakdownCacheKey(filePath) {
+  try {
+    const stat = fs5.statSync(filePath);
+    return {
+      version: codexSessionCacheVersion,
+      filePath: path5.resolve(filePath),
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    };
+  } catch {
+    return void 0;
+  }
+}
 function parseSessionRecords(text) {
   const trimmed = text.trim();
   if (!trimmed) return { records: [], errors: [] };
@@ -1966,7 +2442,7 @@ function emptyBreakdown() {
   };
 }
 function fallbackCwdFromPath(filePath) {
-  return filePath ? path4.dirname(filePath) : process.cwd();
+  return filePath ? path5.dirname(filePath) : process.cwd();
 }
 function applySessionMetadata(breakdown, record) {
   if (!record || typeof record !== "object") return;
@@ -2146,6 +2622,12 @@ function dateValue2(value) {
   }
   return void 0;
 }
+function timestampMs(value) {
+  const date = dateValue2(value);
+  if (!date) return void 0;
+  const timestamp3 = new Date(date).getTime();
+  return Number.isFinite(timestamp3) ? timestamp3 : void 0;
+}
 function errorMessage(error) {
   const message = error instanceof Error ? error.message : String(error);
   if (message.includes("NODE_MODULE_VERSION") && message.includes("better_sqlite3.node")) {
@@ -2157,24 +2639,25 @@ function errorMessage(error) {
 }
 
 // packages/core/src/sources/claude.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import os3 from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 function scanClaude(options) {
   const claudeHome = options.claudeHome ?? defaultClaudeHome();
-  const historyPath = path5.join(claudeHome, "history.jsonl");
+  const historyPath = path6.join(claudeHome, "history.jsonl");
   const warnings = [];
   const discovery = discoverClaudeSessionFiles(claudeHome, warnings, Boolean(options.claudeHome));
-  const historyExists = fs5.existsSync(historyPath);
-  const orderedFiles = discovery.files.map((file) => ({ file, mtimeMs: safeMtimeMs(file.filePath) })).sort((a, b) => a.mtimeMs - b.mtimeMs);
+  const historyExists = fs6.existsSync(historyPath);
+  const orderedFiles = discovery.files.map((file) => ({ file, mtimeMs: safeMtimeMs(file.filePath) })).filter(({ mtimeMs }) => !options.scanWindow?.fromMs || mtimeMs >= options.scanWindow.fromMs).sort((a, b) => a.mtimeMs - b.mtimeMs);
   const usageSelection = selectClaudeUsageOccurrences(orderedFiles.map(({ file }) => file));
   const sessions = orderedFiles.flatMap(({ file }, index) => claudeFileToUsages(file, index, options, usageSelection));
+  const serviceTierSummary = summarizeServiceTiers(sessions.map((session) => session.serviceTier), "Claude session usage");
   const historyEntryCount = countHistoryEntries(historyPath);
   const parseFailureCount = sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).length;
   const unreadableFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("unable_to_read_session_file:"))).length;
   const malformedFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("jsonl_line_"))).length;
-  const projectsPath = path5.join(claudeHome, "projects");
-  if (!discovery.projectsPaths.some((candidate) => fs5.existsSync(candidate))) {
+  const projectsPath = path6.join(claudeHome, "projects");
+  if (!discovery.projectsPaths.some((candidate) => fs6.existsSync(candidate))) {
     warnings.push(`Claude Code projects directory not found at ${projectsPath}`);
   }
   return {
@@ -2183,7 +2666,8 @@ function scanClaude(options) {
       label: "Claude Code",
       available: discovery.files.length > 0 || historyExists,
       paths: unique3([...discovery.projectsPaths, historyPath, ...discovery.desktopSessionRoots]),
-      warnings
+      warnings,
+      ...serviceTierSummary
     },
     sessions,
     stats: {
@@ -2193,7 +2677,7 @@ function scanClaude(options) {
       claudeHome,
       projectsPath,
       historyPath,
-      projectsExists: discovery.projectsPaths.some((candidate) => fs5.existsSync(candidate)),
+      projectsExists: discovery.projectsPaths.some((candidate) => fs6.existsSync(candidate)),
       historyExists,
       sessionFileCount: discovery.files.length,
       projectDirCount: discovery.projectDirs.size,
@@ -2202,6 +2686,7 @@ function scanClaude(options) {
       unreadableFileCount,
       malformedFileCount,
       historyEntryCount,
+      ...serviceTierSummary,
       lastScannedAt: (/* @__PURE__ */ new Date()).toISOString()
     }
   };
@@ -2209,7 +2694,7 @@ function scanClaude(options) {
 function discoverClaudeSessionFiles(claudeHome, warnings, explicitHome) {
   const files = [];
   const projectDirs = /* @__PURE__ */ new Set();
-  const projectsPaths = explicitHome ? [path5.join(claudeHome, "projects")] : unique3([...configuredClaudeHomes(claudeHome).map((root) => path5.join(root, "projects")), path5.join(os3.homedir(), ".config", "claude", "projects")]);
+  const projectsPaths = explicitHome ? [path6.join(claudeHome, "projects")] : unique3([...configuredClaudeHomes(claudeHome).map((root) => path6.join(root, "projects")), path6.join(os3.homedir(), ".config", "claude", "projects")]);
   for (const projectsPath of projectsPaths) {
     collectProjectFiles(projectsPath, files, projectDirs, warnings);
   }
@@ -2226,16 +2711,16 @@ function discoverClaudeSessionFiles(claudeHome, warnings, explicitHome) {
 }
 function configuredClaudeHomes(primaryHome) {
   if (process.env.CLAUDE_CONFIG_DIR) {
-    return process.env.CLAUDE_CONFIG_DIR.split(",").map((item) => item.trim()).filter(Boolean).map((item) => path5.resolve(item));
+    return process.env.CLAUDE_CONFIG_DIR.split(",").map((item) => item.trim()).filter(Boolean).map((item) => path6.resolve(item));
   }
   return [primaryHome];
 }
 function collectProjectFiles(projectsPath, files, projectDirs, warnings) {
-  if (!fs5.existsSync(projectsPath)) return;
+  if (!fs6.existsSync(projectsPath)) return;
   try {
-    for (const entry of fs5.readdirSync(projectsPath, { withFileTypes: true })) {
+    for (const entry of fs6.readdirSync(projectsPath, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const projectDir = path5.join(projectsPath, entry.name);
+      const projectDir = path6.join(projectsPath, entry.name);
       projectDirs.add(projectDir);
       walk2(projectDir, 5, (filePath) => {
         if (filePath.endsWith(".jsonl")) files.push({ filePath, projectDir, projectsPath });
@@ -2246,15 +2731,15 @@ function collectProjectFiles(projectsPath, files, projectDirs, warnings) {
   }
 }
 function collectDesktopSessionFiles(root, files, projectDirs, warnings) {
-  if (!fs5.existsSync(root)) return;
+  if (!fs6.existsSync(root)) return;
   try {
     walk2(root, 8, (filePath) => {
       if (!filePath.endsWith(".jsonl")) return;
-      const parts = filePath.split(path5.sep);
+      const parts = filePath.split(path6.sep);
       const projectsIndex = parts.lastIndexOf("projects");
       const hasProjectSegment = projectsIndex >= 0 && projectsIndex < parts.length - 2;
-      const projectsPath = hasProjectSegment ? parts.slice(0, projectsIndex + 1).join(path5.sep) || path5.sep : root;
-      const projectDir = hasProjectSegment ? parts.slice(0, projectsIndex + 2).join(path5.sep) || path5.sep : path5.dirname(filePath);
+      const projectsPath = hasProjectSegment ? parts.slice(0, projectsIndex + 1).join(path6.sep) || path6.sep : root;
+      const projectDir = hasProjectSegment ? parts.slice(0, projectsIndex + 2).join(path6.sep) || path6.sep : path6.dirname(filePath);
       projectDirs.add(projectDir);
       files.push({ filePath, projectDir, projectsPath });
     });
@@ -2264,9 +2749,9 @@ function collectDesktopSessionFiles(root, files, projectDirs, warnings) {
 }
 function walk2(root, maxDepth, onFile, depth = 0) {
   if (depth > maxDepth) return;
-  for (const entry of fs5.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs6.readdirSync(root, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".git") continue;
-    const fullPath = path5.join(root, entry.name);
+    const fullPath = path6.join(root, entry.name);
     if (entry.isDirectory()) {
       walk2(fullPath, maxDepth, onFile, depth + 1);
     } else if (entry.isFile()) {
@@ -2280,14 +2765,17 @@ function claudeFileToUsages(file, index, options, usageSelection) {
   return segments.map(({ breakdown: segment, suffix }) => claudeBreakdownToUsage(file, index, options, segment, suffix));
 }
 function claudeBreakdownToUsage(file, index, options, breakdown, idSuffix = "") {
-  const id = breakdown.id ?? (path5.basename(file.filePath).replace(/\.jsonl$/i, "") || `claude-session-${index}`);
+  const id = breakdown.id ?? (path6.basename(file.filePath).replace(/\.jsonl$/i, "") || `claude-session-${index}`);
   const fallbackCwd = inferProjectPath(file.projectDir, file.projectsPath);
   const cwd = breakdown.cwd ?? fallbackCwd;
   const repo = resolveRepoInfo(cwd, options.config);
   const warnings = [...repo.warnings, ...breakdown.warnings];
   const entrypoint = breakdown.entrypoint ?? inferClaudeEntrypointFromPath(file.filePath);
   if (!breakdown.cwd) warnings.push("repo_inferred_from_claude_project_dir");
+  if (!breakdown.model && breakdown.usageCount === 0 && breakdown.syntheticZeroUsageCount > 0) warnings.push("claude_synthetic_zero_usage");
   const hasTokenBreakdown = breakdown.totalTokens > 0 && breakdown.usageCount > 0;
+  const serviceTierSummary = summarizeClaudeServiceTier(breakdown.serviceTiers, breakdown.serviceSpeeds);
+  const serviceSpeedSummary = summarizeServiceTiers(breakdown.serviceSpeeds, "Claude usage.speed");
   const usage = {
     id: `${id}${idSuffix}`,
     sourceClient: "claude",
@@ -2325,6 +2813,18 @@ function claudeBreakdownToUsage(file, index, options, breakdown, idSuffix = "")
     detectedSurface: claudeSurface(entrypoint),
     surfaceConfidence: "medium",
     surfaceReason: entrypoint ? `Claude Code entrypoint: ${entrypoint}` : "Claude Code transcript",
+    serviceTier: serviceTierSummary.serviceTier,
+    serviceTierSource: serviceTierSummary.serviceTier ? "session_usage" : void 0,
+    serviceTierConfidence: serviceTierSummary.serviceTier ? "high" : void 0,
+    serviceTierDetail: serviceTierSummary.serviceTierDetail,
+    sourceMetadata: breakdown.serviceTiers.length || breakdown.serviceSpeeds.length ? {
+      claude: {
+        serviceTiers: breakdown.serviceTiers,
+        speeds: breakdown.serviceSpeeds,
+        serviceTier: serviceTierSummary.serviceTier,
+        speed: serviceSpeedSummary.serviceTier
+      }
+    } : void 0,
     userPromptCount: breakdown.userPromptCount,
     assistantMessageCount: breakdown.assistantMessageCount,
     toolCallCount: breakdown.toolCallCount,
@@ -2352,12 +2852,12 @@ function claudeBreakdownToUsage(file, index, options, breakdown, idSuffix = "")
   };
 }
 function inferClaudeEntrypointFromPath(filePath) {
-  return filePath.split(path5.sep).includes("local-agent-mode-sessions") ? "local-agent" : void 0;
+  return filePath.split(path6.sep).includes("local-agent-mode-sessions") ? "local-agent" : void 0;
 }
 function readClaudeBreakdown(filePath, usageSelection) {
   const breakdown = emptyBreakdown2();
   try {
-    const text = fs5.readFileSync(filePath, "utf8");
+    const text = fs6.readFileSync(filePath, "utf8");
     const parse = parseJsonLines2(text);
     breakdown.rawEventCount = parse.records.length;
     breakdown.parseErrors = parse.errors;
@@ -2395,6 +2895,8 @@ function applyClaudeRecord(breakdown, record, usageSelection, usageOccurrenceKey
     applyPromptTimeline2(breakdown, role, message.content, timestamp3);
     const usage = firstObject4(message.usage);
     const usageTokens = usage ? usageTotal(usage) : 0;
+    const rawModel = stringValue3(message.model);
+    if (rawModel === "<synthetic>" && usage && usageTokens === 0) breakdown.syntheticZeroUsageCount += 1;
     const model = normalizeClaudeModel(message.model);
     if (model && (usageTokens > 0 || !breakdown.model)) breakdown.model = model;
     const selectedUsage = usageTokens > 0 ? usageSelection.usageByOccurrence.get(usageOccurrenceKey) : void 0;
@@ -2412,7 +2914,7 @@ function selectClaudeUsageOccurrences(files) {
   for (const file of files) {
     let parse;
     try {
-      parse = parseJsonLines2(fs5.readFileSync(file.filePath, "utf8"));
+      parse = parseJsonLines2(fs6.readFileSync(file.filePath, "utf8"));
     } catch {
       continue;
     }
@@ -2446,14 +2948,16 @@ function usageDedupKey(record, message) {
   return `${requestId}:${messageId}`;
 }
 function occurrenceKey(filePath, recordIndex) {
-  return `${path5.resolve(filePath)}:${recordIndex}`;
+  return `${path6.resolve(filePath)}:${recordIndex}`;
 }
 function cloneUsage(usage) {
   return {
     input_tokens: numberValue(usage.input_tokens),
     cache_read_input_tokens: numberValue(usage.cache_read_input_tokens),
     cache_creation_input_tokens: numberValue(usage.cache_creation_input_tokens),
-    output_tokens: numberValue(usage.output_tokens)
+    output_tokens: numberValue(usage.output_tokens),
+    service_tier: stringValue3(usage.service_tier),
+    speed: stringValue3(usage.speed)
   };
 }
 function mergeUsageMax(target, usage) {
@@ -2461,6 +2965,8 @@ function mergeUsageMax(target, usage) {
   target.cache_read_input_tokens = Math.max(numberValue(target.cache_read_input_tokens), numberValue(usage.cache_read_input_tokens));
   target.cache_creation_input_tokens = Math.max(numberValue(target.cache_creation_input_tokens), numberValue(usage.cache_creation_input_tokens));
   target.output_tokens = Math.max(numberValue(target.output_tokens), numberValue(usage.output_tokens));
+  target.service_tier ??= stringValue3(usage.service_tier);
+  target.speed ??= stringValue3(usage.speed);
 }
 function applyUsage(breakdown, usage) {
   const input = numberValue(usage.input_tokens);
@@ -2472,6 +2978,8 @@ function applyUsage(breakdown, usage) {
   breakdown.cacheCreationInputTokens += cacheCreation;
   breakdown.outputTokens += output;
   breakdown.usageCount += 1;
+  pushUnique(breakdown.serviceTiers, normalizedServiceTier(usage.service_tier));
+  pushUnique(breakdown.serviceSpeeds, normalizedServiceTier(usage.speed));
 }
 function segmentClaudeBreakdownByDayAndModel(breakdown) {
   const events = breakdown.usageEvents.filter((event) => event.timestamp);
@@ -2581,9 +3089,46 @@ function emptyBreakdown2() {
     parseErrors: [],
     promptTimeline: [],
     warnings: [],
-    usageEvents: []
+    usageEvents: [],
+    serviceTiers: [],
+    serviceSpeeds: [],
+    syntheticZeroUsageCount: 0
+  };
+}
+function summarizeClaudeServiceTier(serviceTiers, speeds) {
+  const tierSummary = summarizeServiceTiers(serviceTiers, "Claude usage.service_tier");
+  return tierSummary.serviceTier ? tierSummary : summarizeServiceTiers(speeds, "Claude usage.speed");
+}
+function summarizeServiceTiers(values, source) {
+  const uniqueValues = unique3(values.filter((value) => Boolean(value)));
+  if (uniqueValues.length === 0) return {};
+  if (uniqueValues.length === 1) {
+    const serviceTier = uniqueValues[0];
+    if (!serviceTier) return {};
+    return {
+      serviceTier,
+      serviceTierSource: "session_usage",
+      serviceTierConfidence: "high",
+      serviceTierDetail: serviceTierDetail(source, uniqueValues)
+    };
+  }
+  return {
+    serviceTier: "mixed",
+    serviceTierSource: "session_usage",
+    serviceTierConfidence: "high",
+    serviceTierDetail: serviceTierDetail(source, uniqueValues)
   };
 }
+function serviceTierDetail(source, values) {
+  return `${source}: ${unique3(values).join(", ")}`;
+}
+function normalizedServiceTier(value) {
+  const tier = stringValue3(value)?.trim().toLowerCase();
+  return tier || void 0;
+}
+function pushUnique(target, value) {
+  if (value && !target.includes(value)) target.push(value);
+}
 function applyPromptTimeline2(breakdown, role, content, timestamp3) {
   if (breakdown.promptTimeline.length >= 80 || role !== "user" && role !== "assistant") return;
   const text = extractClaudeMessageText(content);
@@ -2610,12 +3155,12 @@ function normalizeTimelineText2(text) {
   return text.replace(/\s+/g, " ").trim().slice(0, 1e3);
 }
 function inferProjectPath(projectDir, projectsPath) {
-  const name = path5.basename(projectDir);
+  const name = path6.basename(projectDir);
   if (name.startsWith("-")) {
-    return `${path5.sep}${name.slice(1).split("-").filter(Boolean).join(path5.sep)}`;
+    return `${path6.sep}${name.slice(1).split("-").filter(Boolean).join(path6.sep)}`;
   }
-  const relative = path5.relative(projectsPath, projectDir);
-  return relative && !relative.startsWith("..") ? path5.join(projectsPath, relative) : projectDir;
+  const relative = path6.relative(projectsPath, projectDir);
+  return relative && !relative.startsWith("..") ? path6.join(projectsPath, relative) : projectDir;
 }
 function inferOutcome2(breakdown) {
   if (breakdown.parseStatus === "failed") return "failed";
@@ -2639,20 +3184,20 @@ function claudeSourceAppLabel(entrypoint) {
   return "Claude Code";
 }
 function defaultClaudeHome() {
-  return process.env.CLAUDE_CONFIG_DIR?.split(",").map((item) => item.trim()).filter(Boolean)[0] ?? path5.join(os3.homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR?.split(",").map((item) => item.trim()).filter(Boolean)[0] ?? path6.join(os3.homedir(), ".claude");
 }
 function defaultDesktopSessionRoots() {
   const home = os3.homedir();
-  const xdg = process.env.XDG_CONFIG_HOME || path5.join(home, ".config");
+  const xdg = process.env.XDG_CONFIG_HOME || path6.join(home, ".config");
   return [
-    path5.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
-    path5.join(xdg, "Claude", "local-agent-mode-sessions")
+    path6.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
+    path6.join(xdg, "Claude", "local-agent-mode-sessions")
   ];
 }
 function uniqueSessionFiles(files) {
   const seen = /* @__PURE__ */ new Set();
   return files.filter((file) => {
-    const key = path5.resolve(file.filePath);
+    const key = path6.resolve(file.filePath);
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -2662,10 +3207,10 @@ function unique3(values) {
   return [...new Set(values)];
 }
 function countHistoryEntries(historyPath) {
-  if (!fs5.existsSync(historyPath)) return 0;
+  if (!fs6.existsSync(historyPath)) return 0;
   let entryCount = 0;
   try {
-    for (const line of fs5.readFileSync(historyPath, "utf8").split(/\r?\n/).filter(Boolean)) {
+    for (const line of fs6.readFileSync(historyPath, "utf8").split(/\r?\n/).filter(Boolean)) {
       try {
         JSON.parse(line);
         entryCount += 1;
@@ -2725,62 +3270,65 @@ function errorMessage2(error) {
 }
 function safeMtimeMs(filePath) {
   try {
-    return fs5.statSync(filePath).mtimeMs;
+    return fs6.statSync(filePath).mtimeMs;
   } catch {
     return 0;
   }
 }
 
-// packages/core/src/sources/cursor.ts
-import fs6 from "node:fs";
+// packages/core/src/sources/copilot.ts
+import fs7 from "node:fs";
 import os4 from "node:os";
-import path6 from "node:path";
-import Database2 from "better-sqlite3";
-var parserVersion = "cursor-v1";
-var maxJsonlBytes = 20 * 1024 * 1024;
-var maxDatabaseBytes = 100 * 1024 * 1024;
-var cursorStoragePrefixes = ["cursor.", "anysphere."];
-var interestingTerms = ["cursor", "composer", "aichat", "ai_chat", "aiservice", "agent-transcript", "prompttokenbreakdown"];
-function scanCursor(options) {
-  const cursorHome = options.cursorHome ?? path6.join(os4.homedir(), ".cursor");
-  const discovery = discoverCursorFiles(cursorHome, Boolean(options.cursorHome));
-  const jsonlCandidates = discovery.jsonlFiles.map((filePath) => cursorJsonlToCandidate(filePath, cursorHome));
-  const databaseCandidates = discovery.databaseFiles.flatMap((filePath) => cursorDatabaseToCandidates(filePath, cursorHome, discovery.warnings));
-  const candidates = dedupeCandidates([...jsonlCandidates, ...databaseCandidates]);
-  const sessions = candidates.map((candidate, index) => candidateToUsage(candidate, index, options));
-  const parseFailureCount = sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).length;
-  const unreadableFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("unable_to_read_"))).length;
-  const malformedFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("jsonl_line_") || error.startsWith("sqlite_json_parse:"))).length;
-  if (!fs6.existsSync(cursorHome)) {
-    discovery.warnings.push(`Cursor home directory not found at ${cursorHome}`);
-  }
-  if (!fs6.existsSync(discovery.statePath)) {
-    discovery.warnings.push(`Cursor global state database not found at ${discovery.statePath}`);
+import path7 from "node:path";
+var maxJsonlBytes = 50 * 1024 * 1024;
+var copilotOtelEnv = "COPILOT_OTEL_FILE_EXPORTER_PATH";
+function scanCopilot(options) {
+  const copilotHome = options.copilotHome ?? path7.join(os4.homedir(), ".copilot");
+  const discovery = discoverCopilotFiles(copilotHome, Boolean(options.copilotHome), options.codeUserRoots);
+  const files = discovery.files.filter((file) => fileMayOverlapScanWindow2(file.filePath, options.scanWindow));
+  const sessionMap = /* @__PURE__ */ new Map();
+  const fileStats = [];
+  for (const [index, file] of files.entries()) {
+    const read = readCopilotFile(file, index);
+    fileStats.push(read.stats);
+    for (const breakdown of read.breakdowns) {
+      mergeBreakdown(sessionMap, breakdown);
+    }
   }
+  applyModelHints(sessionMap, discovery.modelHints);
+  const sessions = [...sessionMap.values()].sort((a, b) => (a.startedAt ?? "").localeCompare(b.startedAt ?? "")).map((breakdown, index) => breakdownToUsage(breakdown, index, options));
+  const parseFailureCount = fileStats.filter((stats) => stats.parseFailed).length;
+  const unreadableFileCount = fileStats.filter((stats) => stats.unreadable).length;
+  const malformedFileCount = fileStats.filter((stats) => stats.malformed).length;
+  if (!fs7.existsSync(copilotHome)) discovery.warnings.push(`GitHub Copilot home directory not found at ${copilotHome}`);
+  if (!fs7.existsSync(discovery.otelPath)) discovery.warnings.push(`GitHub Copilot OpenTelemetry directory not found at ${discovery.otelPath}`);
+  const otelFiles = files.filter((file) => file.kind === "otel").length;
+  const debugLogFiles = files.filter((file) => file.kind === "debug").length;
+  const transcriptFiles = files.filter((file) => file.kind === "transcript").length;
+  const sessionStateFiles = files.filter((file) => file.kind === "session_state").length;
   return {
     source: {
-      id: "cursor",
-      label: "Cursor",
-      available: discovery.jsonlFiles.length > 0 || discovery.databaseFiles.length > 0,
-      paths: unique4([cursorHome, discovery.projectsPath, discovery.statePath, discovery.workspaceStoragePath, ...discovery.roots]),
+      id: "copilot",
+      label: "GitHub Copilot",
+      available: files.length > 0,
+      paths: unique4([copilotHome, discovery.otelPath, discovery.workspaceStoragePath, ...discovery.codeUserRoots, ...files.map((file) => file.filePath), ...[...discovery.modelHints.values()].map((hint) => hint.sourcePath)]),
       warnings: discovery.warnings
     },
     sessions,
     stats: {
-      sourceId: "cursor",
-      sourceLabel: "Cursor",
-      homePath: cursorHome,
-      cursorHome,
-      globalStoragePath: discovery.globalStoragePath,
+      sourceId: "copilot",
+      sourceLabel: "GitHub Copilot",
+      homePath: copilotHome,
+      copilotHome,
+      otelPath: discovery.otelPath,
       workspaceStoragePath: discovery.workspaceStoragePath,
-      projectsPath: discovery.projectsPath,
-      statePath: discovery.statePath,
-      projectsExists: fs6.existsSync(discovery.projectsPath),
-      stateExists: fs6.existsSync(discovery.statePath),
-      sessionsExists: discovery.jsonlFiles.length > 0,
-      sessionFileCount: discovery.jsonlFiles.length,
-      databaseFileCount: discovery.databaseFiles.length,
-      skippedFileCount: discovery.skippedFileCount,
+      otelExists: fs7.existsSync(discovery.otelPath),
+      sessionsExists: files.length > 0,
+      sessionFileCount: files.length,
+      otelFileCount: otelFiles,
+      debugLogFileCount: debugLogFiles,
+      transcriptFileCount: transcriptFiles,
+      sessionStateFileCount: sessionStateFiles,
       sessionsImported: sessions.length,
       parseFailureCount,
       unreadableFileCount,
@@ -2789,141 +3337,966 @@ function scanCursor(options) {
     }
   };
 }
-function discoverCursorFiles(cursorHome, explicitHome) {
+function discoverCopilotFiles(copilotHome, explicitHome, explicitCodeUserRoots) {
   const warnings = [];
-  const appPaths = defaultCursorAppPaths();
-  const roots = explicitHome ? [cursorHome] : unique4([cursorHome, appPaths.statePath, ...cursorOwnedGlobalStorageRoots(appPaths.globalStoragePath), ...cursorOwnedWorkspaceStorageRoots(appPaths.workspaceStoragePath)]);
-  const jsonlFiles = [];
-  const databaseFiles = [];
-  let skippedFileCount = 0;
-  for (const root of roots) {
-    if (!fs6.existsSync(root)) continue;
-    try {
-      if (isReadableRegularFile(root, maxDatabaseBytes)) {
-        databaseFiles.push(root);
-        continue;
-      }
-      walk3(root, 10, (filePath) => {
-        const lower = filePath.toLowerCase();
-        if (lower.endsWith(".jsonl")) {
-          if (isReadableRegularFile(filePath, maxJsonlBytes)) jsonlFiles.push(filePath);
-          else skippedFileCount += 1;
-          return;
-        }
-        if (/\.(sqlite|db|vscdb)$/i.test(filePath)) {
-          if (isReadableRegularFile(filePath, maxDatabaseBytes)) databaseFiles.push(filePath);
-          else skippedFileCount += 1;
-        }
-      });
-    } catch (error) {
-      warnings.push(`Unable to inspect Cursor path ${root}: ${errorMessage3(error)}`);
-    }
+  const otelPath = path7.join(copilotHome, "otel");
+  const codeUserRoots = explicitCodeUserRoots ?? (explicitHome ? [] : defaultCodeUserRoots());
+  const workspaceStoragePath = codeUserRoots[0] ? path7.join(codeUserRoots[0], "workspaceStorage") : "";
+  const files = [];
+  const modelHints = /* @__PURE__ */ new Map();
+  collectJsonlFiles(otelPath, "otel", "cli", void 0, files, warnings);
+  collectCopilotSessionStateFiles(copilotHome, files, warnings);
+  const explicitOtelPath = process.env[copilotOtelEnv]?.trim();
+  if (explicitOtelPath && isReadableRegularFile(explicitOtelPath, maxJsonlBytes)) {
+    files.push({ filePath: path7.resolve(explicitOtelPath), kind: "otel", surface: "cli", fallbackCwd: void 0 });
+  }
+  for (const userRoot of codeUserRoots) {
+    collectCodeCopilotFiles(userRoot, files, modelHints, warnings);
   }
   return {
-    roots,
-    projectsPath: path6.join(cursorHome, "projects"),
-    globalStoragePath: appPaths.globalStoragePath,
-    workspaceStoragePath: appPaths.workspaceStoragePath,
-    statePath: appPaths.statePath,
-    jsonlFiles: unique4(jsonlFiles).sort(cursorJsonlSort),
-    databaseFiles: unique4(databaseFiles).sort(),
-    skippedFileCount,
+    otelPath,
+    workspaceStoragePath,
+    files: uniqueFiles(files),
+    codeUserRoots,
+    modelHints,
     warnings
   };
 }
-function cursorOwnedGlobalStorageRoots(globalStoragePath) {
-  return cursorOwnedChildDirs(globalStoragePath);
+function collectCopilotSessionStateFiles(copilotHome, files, warnings) {
+  const sessionStateRoot = path7.join(copilotHome, "session-state");
+  if (!fs7.existsSync(sessionStateRoot)) return;
+  try {
+    for (const entry of fs7.readdirSync(sessionStateRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const sessionDir = path7.join(sessionStateRoot, entry.name);
+      const eventsPath = path7.join(sessionDir, "events.jsonl");
+      if (isReadableRegularFile(eventsPath, maxJsonlBytes)) {
+        files.push({ filePath: eventsPath, kind: "session_state", surface: "cli", fallbackCwd: cwdFromWorkspaceYaml(path7.join(sessionDir, "workspace.yaml")) });
+      }
+    }
+  } catch (error) {
+    warnings.push(`Unable to read GitHub Copilot session state at ${sessionStateRoot}: ${errorMessage3(error)}`);
+  }
 }
-function cursorOwnedWorkspaceStorageRoots(workspaceStoragePath) {
-  if (!fs6.existsSync(workspaceStoragePath)) return [];
-  const roots = [];
+function collectCodeCopilotFiles(userRoot, files, modelHints, warnings) {
+  const workspaceStorage = path7.join(userRoot, "workspaceStorage");
+  if (!fs7.existsSync(workspaceStorage)) return;
   try {
-    for (const workspace of fs6.readdirSync(workspaceStoragePath, { withFileTypes: true })) {
+    for (const workspace of fs7.readdirSync(workspaceStorage, { withFileTypes: true })) {
       if (!workspace.isDirectory()) continue;
-      roots.push(...cursorOwnedChildDirs(path6.join(workspaceStoragePath, workspace.name)));
+      const workspaceRoot = path7.join(workspaceStorage, workspace.name);
+      const copilotRoot = path7.join(workspaceRoot, "GitHub.copilot-chat");
+      if (!fs7.existsSync(copilotRoot)) continue;
+      const fallbackCwd = workspaceFolderFromStorageJson(path7.join(workspaceRoot, "workspace.json"));
+      collectJsonlFiles(path7.join(copilotRoot, "debug-logs"), "debug", "vscode", fallbackCwd, files, warnings);
+      collectJsonlFiles(path7.join(copilotRoot, "transcripts"), "transcript", "vscode", fallbackCwd, files, warnings);
+      collectCodeChatSessionModelHints(path7.join(workspaceRoot, "chatSessions"), modelHints, warnings);
     }
-  } catch {
-    return [];
+  } catch (error) {
+    warnings.push(`Unable to read GitHub Copilot VS Code storage at ${workspaceStorage}: ${errorMessage3(error)}`);
   }
-  return roots;
 }
-function cursorOwnedChildDirs(root) {
-  if (!fs6.existsSync(root)) return [];
+function collectCodeChatSessionModelHints(root, modelHints, warnings) {
+  if (!fs7.existsSync(root)) return;
   try {
-    return fs6.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && cursorStoragePrefixes.some((prefix) => entry.name.toLowerCase().startsWith(prefix))).map((entry) => path6.join(root, entry.name));
-  } catch {
+    walk3(root, 2, (filePath) => {
+      if (!filePath.endsWith(".jsonl") || !isReadableRegularFile(filePath, maxJsonlBytes)) return;
+      const hint = readCodeChatSessionModelHint(filePath);
+      if (hint) modelHints.set(hint.sessionId, { model: hint.model, sourcePath: filePath });
+    });
+  } catch (error) {
+    warnings.push(`Unable to read VS Code chat session metadata at ${root}: ${errorMessage3(error)}`);
+  }
+}
+function readCodeChatSessionModelHint(filePath) {
+  const fallbackSessionId = path7.basename(filePath).replace(/\.jsonl$/i, "");
+  let sessionId = fallbackSessionId;
+  let model;
+  try {
+    for (const record of parseJsonLines3(fs7.readFileSync(filePath, "utf8")).records) {
+      const body = firstObject5(record.v) ?? firstObject5(record.data) ?? record;
+      const metadata = firstObject5(body.metadata);
+      sessionId = stringValue4(body.sessionId) ?? stringValue4(metadata?.sessionId) ?? sessionId;
+      model = chatSessionSelectedModel(body) ?? chatSessionResolvedModel(body) ?? model;
+    }
+  } catch {
+    return void 0;
+  }
+  return sessionId && model ? { sessionId, model } : void 0;
+}
+function chatSessionSelectedModel(body) {
+  const inputState = firstObject5(body.inputState);
+  const selectedModel = firstObject5(inputState?.selectedModel) ?? firstObject5(body.selectedModel);
+  const metadata = firstObject5(selectedModel?.metadata);
+  return firstModelCandidate([
+    stringValue4(metadata?.version),
+    stringValue4(metadata?.family),
+    stringValue4(selectedModel?.id),
+    stringValue4(selectedModel?.identifier)
+  ]);
+}
+function chatSessionResolvedModel(body) {
+  const metadata = firstObject5(body.metadata);
+  const response = firstObject5(body.response);
+  const responseMetadata = firstObject5(response?.metadata);
+  return firstModelCandidate([
+    stringValue4(metadata?.resolvedModel),
+    stringValue4(responseMetadata?.resolvedModel)
+  ]);
+}
+function firstModelCandidate(values) {
+  for (const value of values) {
+    const normalized = value?.replace(/^github[-_]?copilot\//i, "").replace(/^copilot\//i, "").trim();
+    if (normalized && normalized.toLowerCase() !== "auto") return normalized;
+  }
+  return void 0;
+}
+function collectJsonlFiles(root, kind, surface, fallbackCwd, files, warnings) {
+  if (!fs7.existsSync(root)) return;
+  try {
+    walk3(root, 6, (filePath) => {
+      if (filePath.endsWith(".jsonl") && isReadableRegularFile(filePath, maxJsonlBytes)) {
+        files.push({ filePath, kind, surface, fallbackCwd });
+      }
+    });
+  } catch (error) {
+    warnings.push(`Unable to read GitHub Copilot path ${root}: ${errorMessage3(error)}`);
+  }
+}
+function readCopilotFile(file, index) {
+  const fallbackId = path7.basename(file.filePath).replace(/\.jsonl$/i, "") || `copilot-session-${index}`;
+  const fallbackTimestamp = fileModifiedDate(file.filePath);
+  const fallback = emptyBreakdown3(file, fallbackId);
+  try {
+    const parse = parseJsonLines3(fs7.readFileSync(file.filePath, "utf8"));
+    const traceContexts = collectTraceContexts(parse.records);
+    const candidates = parse.records.map((record, recordIndex) => usageCandidateFromRecord(record, recordIndex, fallbackTimestamp, traceContexts)).filter((candidate) => Boolean(candidate));
+    const selectedCandidates = uniqueCandidates(candidates.filter((candidate) => shouldEmitCandidate(candidate, candidates)));
+    const groups = /* @__PURE__ */ new Map();
+    fallback.rawEventCount = parse.records.length;
+    fallback.parseErrors = parse.errors;
+    fallback.parseStatus = parse.errors.length ? parse.records.length ? "partial" : "failed" : "ok";
+    if (file.kind === "transcript" || file.kind === "session_state") {
+      for (const record of parse.records) applyTranscriptRecord(fallback, record, file, file.kind === "transcript" ? fallbackTimestamp : void 0);
+    }
+    for (const candidate of selectedCandidates) {
+      const group = groups.get(candidate.sessionId) ?? emptyBreakdown3(file, candidate.sessionId);
+      group.rawEventCount = parse.records.length;
+      group.parseErrors = parse.errors;
+      group.parseStatus = parse.errors.length ? "partial" : "ok";
+      applyCandidate(group, candidate);
+      groups.set(candidate.sessionId, group);
+    }
+    const stats = statsFromParseErrors(parse.errors);
+    if (groups.size > 0) {
+      return { breakdowns: [...groups.values()].map((group) => mergeActivity(group, fallback)), stats };
+    }
+    if (fallback.messageCount > 0 || fallback.rawEventCount > 0 || fallback.parseErrors.length > 0) return { breakdowns: [fallbackWithMissingTokenWarning(fallback)], stats };
+    return { breakdowns: [], stats };
+  } catch (error) {
+    const breakdown = emptyBreakdown3(file, fallbackId);
+    const message = `unable_to_read_copilot_file:${errorMessage3(error)}`;
+    breakdown.parseStatus = "failed";
+    breakdown.parseErrors.push(message);
+    breakdown.warnings.push(message);
+    return { breakdowns: [breakdown], stats: { parseFailed: true, unreadable: true, malformed: false } };
+  }
+}
+function statsFromParseErrors(errors) {
+  return { parseFailed: errors.length > 0, unreadable: false, malformed: errors.some((error) => error.startsWith("jsonl_line_")) };
+}
+function collectTraceContexts(records) {
+  const contexts = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const traceId = traceIdFromRecord(record);
+    const attributes = firstObject5(record.attributes);
+    if (!traceId || !attributes) continue;
+    const context = contexts.get(traceId) ?? { model: void 0, sessionId: void 0, sessionPriority: 0 };
+    context.model ??= firstNonEmptyAttr(attributes, modelAttrs);
+    const session = bestSessionAttr(attributes);
+    if (session && session.priority > context.sessionPriority) {
+      context.sessionId = session.value;
+      context.sessionPriority = session.priority;
+    }
+    contexts.set(traceId, context);
+  }
+  return contexts;
+}
+function usageCandidateFromRecord(record, index, fallbackTimestamp, traceContexts) {
+  const attributes = firstObject5(record.attributes);
+  if (!attributes) return void 0;
+  const source = usageSource(record, attributes);
+  if (!source) return void 0;
+  const input = numberValue2(attributes["gen_ai.usage.input_tokens"]);
+  const output = numberValue2(attributes["gen_ai.usage.output_tokens"]);
+  const cached = numberValue2(attributes["gen_ai.usage.cache_read.input_tokens"]);
+  const cacheCreation = firstPositiveNumber(attributes, ["gen_ai.usage.cache_write.input_tokens", "gen_ai.usage.cache_creation.input_tokens"]);
+  const reasoning = firstPositiveNumber(attributes, ["gen_ai.usage.reasoning.output_tokens", "gen_ai.usage.reasoning_tokens"]);
+  const total = firstPositiveNumber(attributes, ["gen_ai.usage.total_tokens", "gen_ai.usage.total.token_count"]);
+  const outputWithFallback = output || outputTokensFromTotal(total, input, reasoning);
+  if (input + outputWithFallback + cached + cacheCreation + reasoning <= 0) return void 0;
+  const traceId = traceIdFromRecord(record);
+  const traceContext = traceId ? traceContexts.get(traceId) : void 0;
+  const session = bestSessionAttr(attributes)?.value ?? traceContext?.sessionId ?? traceId ?? "unknown-session";
+  const timestamp3 = timestampFromRecord(record) ?? fallbackTimestamp;
+  return {
+    source,
+    traceId,
+    responseId: stringValue4(attributes["gen_ai.response.id"]),
+    sessionId: session,
+    model: firstNonEmptyAttr(attributes, modelAttrs) ?? traceContext?.model,
+    timestamp: timestamp3,
+    durationMs: durationMsFromRecord(record),
+    inputTokens: input,
+    cachedInputTokens: cached,
+    cacheCreationInputTokens: cacheCreation,
+    outputTokens: outputWithFallback,
+    reasoningTokens: reasoning,
+    dedupKey: dedupKeyForRecord(source, record, attributes, traceId, session, timestamp3, index)
+  };
+}
+function outputTokensFromTotal(total, input, reasoning) {
+  return total > 0 && total >= input + reasoning ? total - input - reasoning : 0;
+}
+function usageSource(record, attributes) {
+  const operation = stringValue4(attributes["gen_ai.operation.name"]);
+  const eventName = stringValue4(attributes["event.name"]);
+  const name = stringValue4(record.name);
+  const body = stringValue4(record.body) ?? stringValue4(record._body);
+  const span = isSpanRecord(record);
+  if (span && (operation === "chat" || name?.startsWith("chat "))) return "chat_span";
+  if (!span && (eventName === "gen_ai.client.inference.operation.details" || body?.startsWith("GenAI inference:"))) return "inference_log";
+  if (!span && (eventName === "copilot_chat.agent.turn" || body?.startsWith("copilot_chat.agent.turn"))) return "agent_turn_log";
+  if (span && (operation === "invoke_agent" || name?.startsWith("invoke_agent "))) return "agent_summary_span";
+  return void 0;
+}
+function isSpanRecord(record) {
+  const type = stringValue4(record.type);
+  if (type) return type === "span";
+  return Boolean(stringValue4(record.name) && (stringValue4(record.spanId) || stringValue4(record.traceId) || record.startTime || record.endTime || record.duration || record.kind));
+}
+function shouldEmitCandidate(candidate, candidates) {
+  const has = (source, field, value) => Boolean(value && candidates.some((item) => item.source === source && item[field] === value));
+  if (candidate.source === "chat_span") return true;
+  if (candidate.source === "inference_log") return !has("chat_span", "traceId", candidate.traceId) && !has("chat_span", "responseId", candidate.responseId);
+  if (candidate.source === "agent_turn_log") {
+    return !has("chat_span", "traceId", candidate.traceId) && !has("inference_log", "traceId", candidate.traceId) && !has("chat_span", "responseId", candidate.responseId) && !has("inference_log", "responseId", candidate.responseId);
+  }
+  return !has("chat_span", "traceId", candidate.traceId) && !has("inference_log", "traceId", candidate.traceId) && !has("agent_turn_log", "traceId", candidate.traceId) && !has("chat_span", "responseId", candidate.responseId) && !has("inference_log", "responseId", candidate.responseId) && !has("agent_turn_log", "responseId", candidate.responseId);
+}
+function uniqueCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    if (seen.has(candidate.dedupKey)) return false;
+    seen.add(candidate.dedupKey);
+    return true;
+  });
+}
+var modelAttrs = ["gen_ai.response.model", "gen_ai.request.model"];
+var sessionAttrs = [
+  { key: "gen_ai.conversation.id", priority: 3 },
+  { key: "copilot_chat.session_id", priority: 3 },
+  { key: "copilot_chat.chat_session_id", priority: 3 },
+  { key: "session.id", priority: 3 },
+  { key: "github.copilot.interaction_id", priority: 2 },
+  { key: "gen_ai.response.id", priority: 1 }
+];
+function applyCandidate(breakdown, candidate) {
+  breakdown.id = candidate.sessionId;
+  breakdown.model = candidate.model ?? breakdown.model;
+  const candidateStartedAt = candidate.timestamp && candidate.durationMs ? new Date(Date.parse(candidate.timestamp) - candidate.durationMs).toISOString() : candidate.timestamp;
+  breakdown.startedAt = minDate2(breakdown.startedAt, candidateStartedAt);
+  breakdown.endedAt = maxDate2(breakdown.endedAt, candidate.timestamp);
+  applyTokenEvent(breakdown, {
+    dedupKey: candidate.dedupKey,
+    detailed: candidate.inputTokens > 0 || candidate.cachedInputTokens > 0 || candidate.cacheCreationInputTokens > 0 || candidate.reasoningTokens > 0,
+    inputTokens: candidate.inputTokens,
+    cachedInputTokens: candidate.cachedInputTokens,
+    cacheCreationInputTokens: candidate.cacheCreationInputTokens,
+    outputTokens: candidate.outputTokens,
+    reasoningTokens: candidate.reasoningTokens
+  });
+  breakdown.messageCount += 1;
+  breakdown.assistantMessageCount += 1;
+}
+function applyTranscriptRecord(breakdown, record, file, fallbackTimestamp) {
+  const data = firstObject5(record.data);
+  const timestamp3 = dateValue4(record.timestamp) ?? dateValue4(record.ts) ?? dateValue4(data?.startTime) ?? fallbackTimestamp;
+  const type = stringValue4(record.type);
+  const role = type?.startsWith("user.") ? "user" : type?.startsWith("assistant.") ? "assistant" : stringValue4(data?.role);
+  const sessionId = stringValue4(data?.sessionId) ?? stringValue4(record.sessionId) ?? stringValue4(record.sid);
+  if (sessionId) breakdown.id = sessionId;
+  if (timestamp3) {
+    breakdown.startedAt = minDate2(breakdown.startedAt, timestamp3);
+    breakdown.endedAt = maxDate2(breakdown.endedAt, timestamp3);
+  }
+  breakdown.cwd ??= stringValue4(data?.cwd) ?? stringValue4(record.cwd) ?? file.fallbackCwd;
+  const context = firstObject5(data?.context);
+  breakdown.cwd ??= stringValue4(context?.cwd) ?? stringValue4(context?.gitRoot);
+  const modelCandidate = stringValue4(data?.newModel) ?? stringValue4(data?.currentModel) ?? stringValue4(data?.model) ?? stringValue4(record.model);
+  if (modelCandidate && (modelCandidate !== "auto" || !breakdown.model)) breakdown.model = modelCandidate;
+  if (type === "session.start") breakdown.title ??= stringValue4(data?.title);
+  const outputTokens = numberValue2(data?.outputTokens);
+  if (outputTokens > 0) {
+    const partialSessionId = sessionId ?? breakdown.id ?? path7.basename(file.filePath);
+    applyTokenEvent(breakdown, {
+      dedupKey: `transcript-output:${file.filePath}:${partialSessionId}:${timestamp3 ?? "unknown"}:${breakdown.usageCount}`,
+      detailed: false,
+      inputTokens: 0,
+      cachedInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      outputTokens,
+      reasoningTokens: 0
+    });
+  }
+  if (role === "user" || role === "assistant") {
+    breakdown.messageCount += 1;
+    if (role === "user") breakdown.userPromptCount += 1;
+    if (role === "assistant") breakdown.assistantMessageCount += 1;
+    applyTimeline(breakdown, role, data?.content ?? record.content, timestamp3);
+  }
+  const toolRequests = Array.isArray(data?.toolRequests) ? data.toolRequests : [];
+  breakdown.toolCallCount += toolRequests.length;
+  for (const request of toolRequests) {
+    const object = firstObject5(request);
+    const name = stringValue4(object?.name)?.toLowerCase() ?? "";
+    const args2 = stringValue4(object?.arguments)?.toLowerCase() ?? "";
+    if (name.includes("terminal") || args2.includes('"command"')) breakdown.shellCommandCount += 1;
+    if (name.includes("edit") || args2.includes("edit")) breakdown.fileEditCount += 1;
+    if (name.includes("read") || args2.includes("read_file")) breakdown.fileReadCount += 1;
+  }
+}
+function breakdownToUsage(breakdown, index, options) {
+  const id = breakdown.id ?? `copilot-session-${index}`;
+  const cwd = breakdown.cwd ?? "";
+  const repo = breakdown.cwd ? resolveRepoInfo(breakdown.cwd, options.config) : unknownCopilotRepoInfo();
+  const hasTokenBreakdown = breakdown.inputTokens + breakdown.outputTokens + breakdown.reasoningTokens > 0 && breakdown.usageCount > 0;
+  const hasPricedBreakdown = hasTokenBreakdown && breakdown.inputTokens > 0;
+  const warnings = unique4([...repo.warnings, ...breakdown.warnings]);
+  if (hasTokenBreakdown && !hasPricedBreakdown) warnings.push("copilot_partial_token_breakdown");
+  const usage = {
+    id,
+    sourceClient: "copilot",
+    sourceApp: breakdown.surface === "cli" ? "Copilot CLI" : breakdown.surface === "vscode" ? "VS Code" : "GitHub Copilot",
+    sourceAppRaw: breakdown.surface,
+    sourcePath: breakdown.sourcePaths[0] ?? "",
+    repoRoot: repo.repoRoot,
+    repoName: repo.repoName,
+    cwd,
+    gitRemoteUrl: repo.gitRemoteUrl,
+    gitBranch: repo.gitBranch,
+    title: breakdown.title,
+    startedAt: breakdown.startedAt,
+    endedAt: breakdown.endedAt,
+    model: normalizeCopilotModel(breakdown.model),
+    provider: providerFromModel(breakdown.model),
+    inputTokens: breakdown.inputTokens,
+    cachedInputTokens: breakdown.cachedInputTokens,
+    cacheCreationInputTokens: breakdown.cacheCreationInputTokens,
+    outputTokens: breakdown.outputTokens,
+    reasoningTokens: breakdown.reasoningTokens,
+    reasoningOutputTokens: breakdown.reasoningTokens,
+    totalTokens: breakdown.inputTokens + breakdown.outputTokens + breakdown.reasoningTokens,
+    tokenAggregationMethod: hasTokenBreakdown ? "direct_usage" : "unknown",
+    tokenConfidence: hasTokenBreakdown ? "high" : "low",
+    tokenSnapshotCount: breakdown.usageCount,
+    estimatedCostUsd: void 0,
+    messageCount: breakdown.messageCount,
+    rawTokenTotal: hasTokenBreakdown ? breakdown.inputTokens + breakdown.outputTokens + breakdown.reasoningTokens : void 0,
+    warnings: hasTokenBreakdown ? warnings : unique4([...warnings, "missing_token_breakdown"]),
+    durationMs: durationMs3(breakdown.startedAt, breakdown.endedAt),
+    rawEventCount: breakdown.rawEventCount,
+    parseStatus: breakdown.parseStatus,
+    parseErrors: breakdown.parseErrors,
+    detectedSurface: breakdown.surface === "vscode" ? "vscode_extension" : "terminal_cli",
+    surfaceConfidence: breakdown.surface === "unknown" ? "low" : "high",
+    surfaceReason: breakdown.surface === "vscode" ? "GitHub Copilot VS Code workspace storage" : "GitHub Copilot OpenTelemetry export",
+    promptTimeline: breakdown.promptTimeline,
+    userPromptCount: breakdown.userPromptCount,
+    assistantMessageCount: breakdown.assistantMessageCount,
+    toolCallCount: breakdown.toolCallCount,
+    shellCommandCount: breakdown.shellCommandCount,
+    failedToolCallCount: breakdown.failedToolCallCount,
+    nonZeroCommandEvents: 0,
+    importantCommandFailures: 0,
+    harmlessNonZeroEvents: 0,
+    exploratoryMisses: 0,
+    repeatedFailureClusters: 0,
+    commandIssueSeverity: breakdown.failedToolCallCount > 0 ? "warning" : "none",
+    commandIssueImpact: breakdown.failedToolCallCount > 0 ? "medium" : "none",
+    topFailureType: breakdown.failedToolCallCount > 0 ? "unknown" : void 0,
+    commandIssueSamples: [],
+    fileReadCount: breakdown.fileReadCount,
+    fileEditCount: breakdown.fileEditCount,
+    sourceMetadata: { copilot: { sourcePaths: breakdown.sourcePaths, surface: breakdown.surface } }
+  };
+  const cost = hasPricedBreakdown ? calculateCostUsd(usage, options.pricing) : void 0;
+  return { ...usage, estimatedCostUsd: cost, warnings: hasPricedBreakdown && cost === void 0 ? [...usage.warnings, "unknown_pricing"] : usage.warnings };
+}
+function unknownCopilotRepoInfo() {
+  return {
+    repoRoot: "unknown-copilot-repo",
+    repoName: "Unknown repo/folder",
+    gitRemoteUrl: void 0,
+    gitBranch: void 0,
+    warnings: ["repo_unverified_no_git_root", "copilot_missing_cwd"]
+  };
+}
+function emptyBreakdown3(file, id) {
+  return {
+    id,
+    title: void 0,
+    cwd: file.fallbackCwd,
+    startedAt: void 0,
+    endedAt: void 0,
+    model: void 0,
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    usageCount: 0,
+    messageCount: 0,
+    userPromptCount: 0,
+    assistantMessageCount: 0,
+    toolCallCount: 0,
+    shellCommandCount: 0,
+    failedToolCallCount: 0,
+    fileReadCount: 0,
+    fileEditCount: 0,
+    rawEventCount: 0,
+    parseStatus: "ok",
+    parseErrors: [],
+    promptTimeline: [],
+    warnings: [],
+    sourcePaths: [file.filePath],
+    surface: file.surface,
+    tokenEvents: []
+  };
+}
+function mergeBreakdown(sessions, breakdown) {
+  const key = breakdown.id ?? breakdown.sourcePaths[0] ?? "unknown-session";
+  const existing = sessions.get(key);
+  if (!existing) {
+    sessions.set(key, breakdown);
+    return;
+  }
+  mergeActivity(existing, breakdown);
+  mergeTokenData(existing, breakdown);
+  existing.sourcePaths = unique4([...existing.sourcePaths, ...breakdown.sourcePaths]);
+}
+function mergeTokenData(target, source) {
+  if (source.usageCount <= 0) return;
+  const targetHadUsage = target.usageCount > 0;
+  const targetHasDetailed = hasDetailedTokenBreakdown(target);
+  const sourceHasDetailed = hasDetailedTokenBreakdown(source);
+  if (targetHadUsage) target.warnings = unique4([...target.warnings, "copilot_duplicate_session_merged"]);
+  if (targetHadUsage && targetHasDetailed && !sourceHasDetailed) return;
+  if (targetHadUsage && !targetHasDetailed && sourceHasDetailed) {
+    replaceTokenData(target, source);
+    return;
+  }
+  if (source.tokenEvents.length > 0) {
+    const existingKeys = new Set(target.tokenEvents.map((event) => event.dedupKey));
+    for (const event of source.tokenEvents) {
+      if (existingKeys.has(event.dedupKey)) continue;
+      applyTokenEvent(target, event);
+      existingKeys.add(event.dedupKey);
+    }
+    return;
+  }
+  applyTokenEvent(target, {
+    dedupKey: `merged-total:${source.sourcePaths.join("|")}:${source.usageCount}`,
+    detailed: sourceHasDetailed,
+    inputTokens: source.inputTokens,
+    cachedInputTokens: source.cachedInputTokens,
+    cacheCreationInputTokens: source.cacheCreationInputTokens,
+    outputTokens: source.outputTokens,
+    reasoningTokens: source.reasoningTokens
+  });
+}
+function replaceTokenData(target, source) {
+  target.inputTokens = source.inputTokens;
+  target.cachedInputTokens = source.cachedInputTokens;
+  target.cacheCreationInputTokens = source.cacheCreationInputTokens;
+  target.outputTokens = source.outputTokens;
+  target.reasoningTokens = source.reasoningTokens;
+  target.usageCount = source.usageCount;
+  target.tokenEvents = source.tokenEvents.map((event) => ({ ...event }));
+}
+function hasDetailedTokenBreakdown(breakdown) {
+  return breakdown.inputTokens > 0 || breakdown.cachedInputTokens > 0 || breakdown.cacheCreationInputTokens > 0 || breakdown.reasoningTokens > 0;
+}
+function applyTokenEvent(breakdown, event) {
+  if (breakdown.tokenEvents.some((existing) => existing.dedupKey === event.dedupKey)) return;
+  breakdown.inputTokens += event.inputTokens;
+  breakdown.cachedInputTokens += event.cachedInputTokens;
+  breakdown.cacheCreationInputTokens += event.cacheCreationInputTokens;
+  breakdown.outputTokens += event.outputTokens;
+  breakdown.reasoningTokens += event.reasoningTokens;
+  breakdown.usageCount += 1;
+  breakdown.tokenEvents.push({ ...event });
+}
+function applyModelHints(sessions, modelHints) {
+  for (const breakdown of sessions.values()) {
+    if (!breakdown.id) continue;
+    const hint = modelHints.get(breakdown.id);
+    if (!hint || hasKnownModel(breakdown.model)) continue;
+    breakdown.model = hint.model;
+    breakdown.sourcePaths = unique4([...breakdown.sourcePaths, hint.sourcePath]);
+  }
+}
+function hasKnownModel(model) {
+  const normalized = model?.trim().toLowerCase().replace(/^github[-_]?copilot\//, "").replace(/^copilot\//, "");
+  return Boolean(normalized && normalized !== "auto");
+}
+function mergeActivity(target, source) {
+  target.title ??= source.title;
+  target.cwd ??= source.cwd;
+  target.model ??= source.model;
+  target.startedAt = minDate2(target.startedAt, source.startedAt);
+  target.endedAt = maxDate2(target.endedAt, source.endedAt);
+  target.messageCount = Math.max(target.messageCount, source.messageCount);
+  target.userPromptCount = Math.max(target.userPromptCount, source.userPromptCount);
+  target.assistantMessageCount = Math.max(target.assistantMessageCount, source.assistantMessageCount);
+  target.toolCallCount = Math.max(target.toolCallCount, source.toolCallCount);
+  target.shellCommandCount = Math.max(target.shellCommandCount, source.shellCommandCount);
+  target.fileReadCount = Math.max(target.fileReadCount, source.fileReadCount);
+  target.fileEditCount = Math.max(target.fileEditCount, source.fileEditCount);
+  target.rawEventCount = Math.max(target.rawEventCount, source.rawEventCount);
+  target.parseErrors = unique4([...target.parseErrors, ...source.parseErrors]);
+  target.parseStatus = target.parseErrors.length ? "partial" : target.parseStatus;
+  target.promptTimeline = [...target.promptTimeline, ...source.promptTimeline].slice(0, 80);
+  target.warnings = unique4([...target.warnings, ...source.warnings]);
+  return target;
+}
+function fallbackWithMissingTokenWarning(breakdown) {
+  if (breakdown.usageCount === 0) breakdown.warnings.push("missing_token_breakdown");
+  return breakdown;
+}
+function parseJsonLines3(text) {
+  const records = [];
+  const errors = [];
+  text.split(/\r?\n/).forEach((line, index) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) records.push(parsed);
+    } catch (error) {
+      errors.push(`jsonl_line_${index + 1}:${errorMessage3(error)}`);
+    }
+  });
+  return { records, errors };
+}
+function applyTimeline(breakdown, role, content, timestamp3) {
+  if (breakdown.promptTimeline.length >= 80) return;
+  const text = typeof content === "string" ? content : void 0;
+  if (!text?.trim()) return;
+  breakdown.promptTimeline.push({ role, text: text.replace(/\s+/g, " ").trim().slice(0, 1e3), timestamp: timestamp3 });
+}
+function firstNonEmptyAttr(attributes, keys) {
+  return keys.map((key) => stringValue4(attributes[key])).find(Boolean);
+}
+function bestSessionAttr(attributes) {
+  return sessionAttrs.map((attr) => ({ value: stringValue4(attributes[attr.key]), priority: attr.priority })).filter((item) => Boolean(item.value)).sort((a, b) => b.priority - a.priority)[0];
+}
+function traceIdFromRecord(record) {
+  const spanContext = firstObject5(record.spanContext);
+  return stringValue4(record.traceId) ?? stringValue4(spanContext?.traceId);
+}
+function spanIdFromRecord(record) {
+  const spanContext = firstObject5(record.spanContext);
+  return stringValue4(record.spanId) ?? stringValue4(spanContext?.spanId);
+}
+function dedupKeyForRecord(source, record, attributes, traceId, sessionId, timestamp3, index) {
+  const spanId = spanIdFromRecord(record);
+  if ((source === "chat_span" || source === "agent_summary_span") && traceId && spanId) return `${traceId}:${spanId}`;
+  if (source === "inference_log" && traceId && spanId) return `log:${traceId}:${spanId}`;
+  if (source === "agent_turn_log") {
+    const turn = stringValue4(attributes["turn.index"]) ?? stringValue4(attributes["copilot_chat.turn.index"]) ?? `idx-${index}`;
+    return traceId ? `agent-turn:${traceId}:${turn}` : `agent-turn:${sessionId}:${turn}:${index}`;
+  }
+  return `${source}:${sessionId}:${timestamp3 ?? "unknown"}:${index}`;
+}
+function timestampFromRecord(record) {
+  return timestampMsFromParts(record.endTime) ?? timestampMsFromParts(record.startTime) ?? timestampMsFromParts(record.hrTime) ?? timestampMsFromParts(record._hrTime) ?? timestampMsFromScalar(record.timestamp) ?? timestampMsFromScalar(record.observedTimestamp) ?? timestampMsFromUnixNanos(record.timeUnixNano);
+}
+function timestampMsFromParts(value) {
+  if (!Array.isArray(value)) return void 0;
+  const seconds = numberValue2(value[0]);
+  const nanos = numberValue2(value[1]);
+  if (seconds <= 0) return void 0;
+  return new Date(seconds * 1e3 + Math.floor(nanos / 1e6)).toISOString();
+}
+function timestampMsFromScalar(value) {
+  const raw = numberValue2(value);
+  if (raw <= 0) return void 0;
+  const absolute = Math.abs(raw);
+  const ms = absolute >= 1e17 ? raw / 1e6 : absolute >= 1e14 ? raw / 1e3 : absolute >= 1e11 ? raw : raw * 1e3;
+  return new Date(ms).toISOString();
+}
+function timestampMsFromUnixNanos(value) {
+  const raw = numberValue2(value);
+  return raw > 0 ? new Date(Math.floor(raw / 1e6)).toISOString() : void 0;
+}
+function durationMsFromRecord(record) {
+  const start = timestampMs2(record.startTime);
+  const end = timestampMs2(record.endTime);
+  if (start !== void 0 && end !== void 0 && end > start) return end - start;
+  const duration = numberValue2(record.duration);
+  return duration > 0 ? duration >= 1e6 ? Math.floor(duration / 1e6) : duration : void 0;
+}
+function timestampMs2(value) {
+  const iso = timestampMsFromParts(value) ?? timestampMsFromScalar(value);
+  return iso ? Date.parse(iso) : void 0;
+}
+function defaultCodeUserRoots() {
+  const home = os4.homedir();
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path7.join(home, "AppData", "Roaming");
+    return ["Code", "Code - Insiders", "VSCodium"].map((name) => path7.join(appData, name, "User"));
+  }
+  if (process.platform === "darwin") {
+    return ["Code", "Code - Insiders", "VSCodium"].map((name) => path7.join(home, "Library", "Application Support", name, "User"));
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || path7.join(home, ".config");
+  return ["Code", "Code - Insiders", "VSCodium"].map((name) => path7.join(xdg, name, "User"));
+}
+function workspaceFolderFromStorageJson(filePath) {
+  try {
+    const parsed = JSON.parse(fs7.readFileSync(filePath, "utf8"));
+    const folder = stringValue4(parsed.folder);
+    if (!folder) return void 0;
+    return folder.startsWith("file://") ? decodeURIComponent(new URL(folder).pathname) : folder;
+  } catch {
+    return void 0;
+  }
+}
+function cwdFromWorkspaceYaml(filePath) {
+  try {
+    const text = fs7.readFileSync(filePath, "utf8");
+    const match = /^cwd:\s*(.+)$/m.exec(text);
+    return match?.[1]?.trim();
+  } catch {
+    return void 0;
+  }
+}
+function fileMayOverlapScanWindow2(filePath, scanWindow) {
+  if (!scanWindow?.fromMs && !scanWindow?.toMs) return true;
+  try {
+    const mtime = fs7.statSync(filePath).mtimeMs;
+    if (scanWindow.fromMs !== void 0 && mtime < scanWindow.fromMs) return false;
+    if (scanWindow.toMs !== void 0 && mtime > scanWindow.toMs) return false;
+  } catch {
+    return true;
+  }
+  return true;
+}
+function walk3(root, maxDepth, onFile, depth = 0) {
+  if (depth > maxDepth) return;
+  for (const entry of fs7.readdirSync(root, { withFileTypes: true })) {
+    const fullPath = path7.join(root, entry.name);
+    if (entry.isDirectory()) walk3(fullPath, maxDepth, onFile, depth + 1);
+    else if (entry.isFile()) onFile(fullPath);
+  }
+}
+function isReadableRegularFile(filePath, maxBytes) {
+  try {
+    const stat = fs7.statSync(filePath);
+    return stat.isFile() && stat.size <= maxBytes;
+  } catch {
+    return false;
+  }
+}
+function normalizeCopilotModel(model) {
+  if (!model) return void 0;
+  return normalizePricingModelId(model);
+}
+function providerFromModel(model) {
+  const normalized = normalizeCopilotModel(model);
+  if (!normalized) return "github-copilot";
+  if (normalized.includes("claude")) return "anthropic";
+  if (normalized.includes("gemini")) return "google";
+  if (isCopilotAliasModel(normalized)) return "github-copilot";
+  if (normalized.includes("gpt")) return "openai";
+  return "github-copilot";
+}
+function firstPositiveNumber(object, keys) {
+  return keys.map((key) => numberValue2(object[key])).find((value) => value > 0) ?? 0;
+}
+function firstObject5(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringValue4(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberValue2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.max(Math.trunc(value), 0);
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? Math.max(Math.trunc(parsed), 0) : 0;
+  }
+  return 0;
+}
+function dateValue4(value) {
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : void 0;
+  }
+  return timestampMsFromScalar(value);
+}
+function fileModifiedDate(filePath) {
+  try {
+    return new Date(fs7.statSync(filePath).mtimeMs).toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function minDate2(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return a < b ? a : b;
+}
+function maxDate2(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return a > b ? a : b;
+}
+function durationMs3(startedAt, endedAt) {
+  if (!startedAt || !endedAt) return void 0;
+  const start = Date.parse(startedAt);
+  const end = Date.parse(endedAt);
+  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : void 0;
+}
+function unique4(items) {
+  return [...new Set(items)];
+}
+function uniqueFiles(files) {
+  const seen = /* @__PURE__ */ new Set();
+  return files.filter((file) => {
+    const key = path7.resolve(file.filePath);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).sort((a, b) => a.filePath.localeCompare(b.filePath));
+}
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// packages/core/src/sources/cursor.ts
+import fs8 from "node:fs";
+import os5 from "node:os";
+import path8 from "node:path";
+import Database2 from "better-sqlite3";
+var parserVersion = "cursor-v1";
+var maxJsonlBytes2 = 20 * 1024 * 1024;
+var maxDatabaseBytes = 100 * 1024 * 1024;
+var cursorStoragePrefixes = ["cursor.", "anysphere."];
+var interestingTerms = ["cursor", "composer", "aichat", "ai_chat", "aiservice", "agent-transcript", "prompttokenbreakdown"];
+function scanCursor(options) {
+  const cursorHome = options.cursorHome ?? path8.join(os5.homedir(), ".cursor");
+  const discovery = discoverCursorFiles(cursorHome, Boolean(options.cursorHome));
+  const jsonlFiles = discovery.jsonlFiles.filter((filePath) => fileMayOverlapScanWindow3(filePath, options.scanWindow));
+  const databaseFiles = discovery.databaseFiles.filter((filePath) => fileMayOverlapScanWindow3(filePath, options.scanWindow));
+  const jsonlCandidates = jsonlFiles.map((filePath) => cursorJsonlToCandidate(filePath, cursorHome));
+  const databaseCandidates = databaseFiles.flatMap((filePath) => cursorDatabaseToCandidates(filePath, cursorHome, discovery.warnings));
+  const candidates = dedupeCandidates([...jsonlCandidates, ...databaseCandidates]);
+  const sessions = candidates.map((candidate, index) => candidateToUsage(candidate, index, options));
+  const parseFailureCount = sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).length;
+  const unreadableFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("unable_to_read_"))).length;
+  const malformedFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("jsonl_line_") || error.startsWith("sqlite_json_parse:"))).length;
+  if (!fs8.existsSync(cursorHome)) {
+    discovery.warnings.push(`Cursor home directory not found at ${cursorHome}`);
+  }
+  if (!fs8.existsSync(discovery.statePath)) {
+    discovery.warnings.push(`Cursor global state database not found at ${discovery.statePath}`);
+  }
+  return {
+    source: {
+      id: "cursor",
+      label: "Cursor",
+      available: discovery.jsonlFiles.length > 0 || discovery.databaseFiles.length > 0,
+      paths: unique5([cursorHome, discovery.projectsPath, discovery.statePath, discovery.workspaceStoragePath, ...discovery.roots]),
+      warnings: discovery.warnings
+    },
+    sessions,
+    stats: {
+      sourceId: "cursor",
+      sourceLabel: "Cursor",
+      homePath: cursorHome,
+      cursorHome,
+      globalStoragePath: discovery.globalStoragePath,
+      workspaceStoragePath: discovery.workspaceStoragePath,
+      projectsPath: discovery.projectsPath,
+      statePath: discovery.statePath,
+      projectsExists: fs8.existsSync(discovery.projectsPath),
+      stateExists: fs8.existsSync(discovery.statePath),
+      sessionsExists: jsonlFiles.length > 0,
+      sessionFileCount: jsonlFiles.length,
+      databaseFileCount: databaseFiles.length,
+      skippedFileCount: discovery.skippedFileCount,
+      sessionsImported: sessions.length,
+      parseFailureCount,
+      unreadableFileCount,
+      malformedFileCount,
+      lastScannedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function discoverCursorFiles(cursorHome, explicitHome) {
+  const warnings = [];
+  const appPaths = defaultCursorAppPaths();
+  const roots = explicitHome ? [cursorHome] : unique5([cursorHome, appPaths.statePath, ...cursorOwnedGlobalStorageRoots(appPaths.globalStoragePath), ...cursorOwnedWorkspaceStorageRoots(appPaths.workspaceStoragePath)]);
+  const jsonlFiles = [];
+  const databaseFiles = [];
+  let skippedFileCount = 0;
+  for (const root of roots) {
+    if (!fs8.existsSync(root)) continue;
+    try {
+      if (isReadableRegularFile2(root, maxDatabaseBytes)) {
+        databaseFiles.push(root);
+        continue;
+      }
+      walk4(root, 10, (filePath) => {
+        const lower = filePath.toLowerCase();
+        if (lower.endsWith(".jsonl")) {
+          if (isReadableRegularFile2(filePath, maxJsonlBytes2)) jsonlFiles.push(filePath);
+          else skippedFileCount += 1;
+          return;
+        }
+        if (/\.(sqlite|db|vscdb)$/i.test(filePath)) {
+          if (isReadableRegularFile2(filePath, maxDatabaseBytes)) databaseFiles.push(filePath);
+          else skippedFileCount += 1;
+        }
+      });
+    } catch (error) {
+      warnings.push(`Unable to inspect Cursor path ${root}: ${errorMessage4(error)}`);
+    }
+  }
+  return {
+    roots,
+    projectsPath: path8.join(cursorHome, "projects"),
+    globalStoragePath: appPaths.globalStoragePath,
+    workspaceStoragePath: appPaths.workspaceStoragePath,
+    statePath: appPaths.statePath,
+    jsonlFiles: unique5(jsonlFiles).sort(cursorJsonlSort),
+    databaseFiles: unique5(databaseFiles).sort(),
+    skippedFileCount,
+    warnings
+  };
+}
+function cursorOwnedGlobalStorageRoots(globalStoragePath) {
+  return cursorOwnedChildDirs(globalStoragePath);
+}
+function cursorOwnedWorkspaceStorageRoots(workspaceStoragePath) {
+  if (!fs8.existsSync(workspaceStoragePath)) return [];
+  const roots = [];
+  try {
+    for (const workspace of fs8.readdirSync(workspaceStoragePath, { withFileTypes: true })) {
+      if (!workspace.isDirectory()) continue;
+      roots.push(...cursorOwnedChildDirs(path8.join(workspaceStoragePath, workspace.name)));
+    }
+  } catch {
+    return [];
+  }
+  return roots;
+}
+function cursorOwnedChildDirs(root) {
+  if (!fs8.existsSync(root)) return [];
+  try {
+    return fs8.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && cursorStoragePrefixes.some((prefix) => entry.name.toLowerCase().startsWith(prefix))).map((entry) => path8.join(root, entry.name));
+  } catch {
     return [];
   }
 }
 function defaultCursorAppPaths() {
-  const home = os4.homedir();
+  const home = os5.homedir();
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? path6.join(home, "AppData", "Roaming");
-    const globalStoragePath2 = path6.join(appData, "Cursor", "User", "globalStorage");
+    const appData = process.env.APPDATA ?? path8.join(home, "AppData", "Roaming");
+    const globalStoragePath2 = path8.join(appData, "Cursor", "User", "globalStorage");
     return {
       globalStoragePath: globalStoragePath2,
-      workspaceStoragePath: path6.join(appData, "Cursor", "User", "workspaceStorage"),
-      statePath: path6.join(globalStoragePath2, "state.vscdb")
+      workspaceStoragePath: path8.join(appData, "Cursor", "User", "workspaceStorage"),
+      statePath: path8.join(globalStoragePath2, "state.vscdb")
     };
   }
   if (process.platform === "darwin") {
-    const globalStoragePath2 = path6.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
+    const globalStoragePath2 = path8.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
     return {
       globalStoragePath: globalStoragePath2,
-      workspaceStoragePath: path6.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage"),
-      statePath: path6.join(globalStoragePath2, "state.vscdb")
+      workspaceStoragePath: path8.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage"),
+      statePath: path8.join(globalStoragePath2, "state.vscdb")
     };
   }
-  const xdg = process.env.XDG_CONFIG_HOME || path6.join(home, ".config");
-  const globalStoragePath = path6.join(xdg, "Cursor", "User", "globalStorage");
+  const xdg = process.env.XDG_CONFIG_HOME || path8.join(home, ".config");
+  const globalStoragePath = path8.join(xdg, "Cursor", "User", "globalStorage");
   return {
     globalStoragePath,
-    workspaceStoragePath: path6.join(xdg, "Cursor", "User", "workspaceStorage"),
-    statePath: path6.join(globalStoragePath, "state.vscdb")
+    workspaceStoragePath: path8.join(xdg, "Cursor", "User", "workspaceStorage"),
+    statePath: path8.join(globalStoragePath, "state.vscdb")
   };
 }
-function walk3(root, maxDepth, onFile, depth = 0) {
+function walk4(root, maxDepth, onFile, depth = 0) {
   if (depth > maxDepth) return;
-  for (const entry of fs6.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs8.readdirSync(root, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "CachedData" || entry.name === "Cache") continue;
-    const fullPath = path6.join(root, entry.name);
+    const fullPath = path8.join(root, entry.name);
     if (entry.isDirectory()) {
-      walk3(fullPath, maxDepth, onFile, depth + 1);
+      walk4(fullPath, maxDepth, onFile, depth + 1);
     } else if (entry.isFile()) {
       onFile(fullPath);
     }
   }
 }
-function isReadableRegularFile(filePath, maxBytes) {
+function isReadableRegularFile2(filePath, maxBytes) {
   try {
-    fs6.accessSync(filePath, fs6.constants.R_OK);
-    const stat = fs6.statSync(filePath);
+    fs8.accessSync(filePath, fs8.constants.R_OK);
+    const stat = fs8.statSync(filePath);
     return stat.isFile() && stat.size <= maxBytes;
   } catch {
     return false;
   }
 }
 function cursorJsonlSort(a, b) {
-  const aTranscript = a.includes(`${path6.sep}agent-transcripts${path6.sep}`) ? 0 : 1;
-  const bTranscript = b.includes(`${path6.sep}agent-transcripts${path6.sep}`) ? 0 : 1;
+  const aTranscript = a.includes(`${path8.sep}agent-transcripts${path8.sep}`) ? 0 : 1;
+  const bTranscript = b.includes(`${path8.sep}agent-transcripts${path8.sep}`) ? 0 : 1;
   return aTranscript - bTranscript || a.localeCompare(b);
 }
+function fileMayOverlapScanWindow3(filePath, scanWindow) {
+  if (!scanWindow?.fromMs && !scanWindow?.toMs) return true;
+  const inferredTimestamp = timestampMs3(inferDateFromCursorPath(filePath));
+  if (scanWindow.fromMs !== void 0 && inferredTimestamp !== void 0 && inferredTimestamp < scanWindow.fromMs) return false;
+  if (scanWindow.toMs !== void 0 && inferredTimestamp !== void 0 && inferredTimestamp > scanWindow.toMs) return false;
+  if (scanWindow.fromMs === void 0) return true;
+  try {
+    return fs8.statSync(filePath).mtimeMs >= scanWindow.fromMs;
+  } catch {
+    return true;
+  }
+}
 function cursorJsonlToCandidate(filePath, cursorHome) {
-  const breakdown = emptyBreakdown3();
+  const breakdown = emptyBreakdown4();
   try {
-    const parse = parseJsonLines3(fs6.readFileSync(filePath, "utf8"));
+    const parse = parseJsonLines4(fs8.readFileSync(filePath, "utf8"));
     breakdown.rawEventCount = parse.records.length;
     breakdown.parseErrors = parse.errors;
     breakdown.parseStatus = parse.errors.length ? parse.records.length ? "partial" : "failed" : "ok";
     for (const record of parse.records) applyCursorRecord(breakdown, record);
     finalizeBreakdown(breakdown);
   } catch (error) {
-    const message = `unable_to_read_cursor_jsonl:${errorMessage3(error)}`;
+    const message = `unable_to_read_cursor_jsonl:${errorMessage4(error)}`;
     breakdown.parseStatus = "failed";
     breakdown.parseErrors.push(message);
     breakdown.warnings.push(message);
   }
-  if (!breakdown.id) breakdown.id = path6.basename(filePath).replace(/\.jsonl$/i, "") || void 0;
+  if (!breakdown.id) breakdown.id = path8.basename(filePath).replace(/\.jsonl$/i, "") || void 0;
+  const fallbackDate = inferDateFromCursorPath(filePath) ?? fileModifiedDate2(filePath);
+  if (fallbackDate) {
+    breakdown.startedAt ??= fallbackDate;
+    breakdown.endedAt ??= fallbackDate;
+  }
   return {
     sourcePath: filePath,
     surface: inferSurfaceFromPath(filePath),
@@ -2949,7 +4322,7 @@ function cursorDatabaseToCandidates(filePath, cursorHome, warnings) {
       }
     }
   } catch (error) {
-    warnings.push(`Unable to read Cursor SQLite database at ${filePath}: ${errorMessage3(error)}`);
+    warnings.push(`Unable to read Cursor SQLite database at ${filePath}: ${errorMessage4(error)}`);
   } finally {
     db?.close();
   }
@@ -2959,7 +4332,7 @@ function safeColumns(db, table, warnings) {
   try {
     return db.prepare(`PRAGMA table_info(${quoteIdentifier(table)})`).all();
   } catch (error) {
-    warnings.push(`Unable to inspect Cursor SQLite table ${table}: ${errorMessage3(error)}`);
+    warnings.push(`Unable to inspect Cursor SQLite table ${table}: ${errorMessage4(error)}`);
     return [];
   }
 }
@@ -2968,7 +4341,7 @@ function safeRows(db, table, columns, warnings) {
     const select = columns.map(quoteIdentifier).join(", ");
     return db.prepare(`SELECT ${select} FROM ${quoteIdentifier(table)} LIMIT 500`).all();
   } catch (error) {
-    warnings.push(`Unable to scan Cursor SQLite table ${table}: ${errorMessage3(error)}`);
+    warnings.push(`Unable to scan Cursor SQLite table ${table}: ${errorMessage4(error)}`);
     return [];
   }
 }
@@ -2996,11 +4369,11 @@ function candidateFromDatabaseRow(filePath, cursorHome, table, row) {
     if (!parsed.ok && text.trim().startsWith("{")) parseErrors.push(`sqlite_json_parse:${table}.${key}:${parsed.error}`);
   }
   if (!records.length) return void 0;
-  const breakdown = emptyBreakdown3();
+  const breakdown = emptyBreakdown4();
   breakdown.parseErrors = parseErrors;
   breakdown.parseStatus = parseErrors.length ? "partial" : "ok";
   breakdown.rawEventCount = records.length;
-  breakdown.matchedKeys = unique4(matchedKeys);
+  breakdown.matchedKeys = unique5(matchedKeys);
   for (const record of records) applyCursorRecord(breakdown, record);
   finalizeBreakdown(breakdown);
   if (isCursorMetadataOnlyBreakdown(breakdown)) return void 0;
@@ -3025,29 +4398,29 @@ function parseJsonBlob(text) {
   try {
     return { ok: true, value: JSON.parse(trimmed) };
   } catch (error) {
-    return { ok: false, error: errorMessage3(error) };
+    return { ok: false, error: errorMessage4(error) };
   }
 }
-function parseJsonLines3(text) {
+function parseJsonLines4(text) {
   const records = [];
   const errors = [];
   text.split(/\r?\n/).map((line, index) => ({ line: line.trim(), index })).filter(({ line }) => Boolean(line)).forEach(({ line, index }) => {
     try {
       records.push(JSON.parse(line));
     } catch (error) {
-      errors.push(`jsonl_line_${index + 1}:${errorMessage3(error)}`);
+      errors.push(`jsonl_line_${index + 1}:${errorMessage4(error)}`);
     }
   });
   return { records, errors };
 }
 function applyCursorRecord(breakdown, record) {
   const objects = collectObjects(record, 6, 150);
-  const root = firstObject5(record);
+  const root = firstObject6(record);
   const timestamp3 = firstValueByKeys(objects, ["timestamp", "createdAt", "created_at", "lastUpdatedAt", "conversationCheckpointLastUpdatedAt", "time", "date"]);
-  const date = dateValue4(timestamp3);
+  const date = dateValue5(timestamp3);
   if (date) {
-    breakdown.startedAt = minDate2(breakdown.startedAt, date);
-    breakdown.endedAt = maxDate2(breakdown.endedAt, date);
+    breakdown.startedAt = minDate3(breakdown.startedAt, date);
+    breakdown.endedAt = maxDate3(breakdown.endedAt, date);
   }
   breakdown.id ??= firstStringByKeys(objects, ["sessionId", "session_id", "conversationId", "conversation_id", "composerId", "composer_id", "chatId", "chat_id"]);
   breakdown.title ??= firstStringByKeys(objects, ["title", "name", "summary"]);
@@ -3092,13 +4465,13 @@ function collectObjects(value, maxDepth, maxObjects, objects = []) {
   for (const child of Object.values(object)) collectObjects(child, maxDepth - 1, maxObjects, objects);
   return objects;
 }
-function firstObject5(value) {
+function firstObject6(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function firstStringByKeys(objects, keys) {
   for (const object of objects) {
     for (const key of keys) {
-      const value = stringValue4(object[key]);
+      const value = stringValue5(object[key]);
       if (value) return value;
     }
   }
@@ -3121,7 +4494,7 @@ function firstPathByKeys(objects, keys) {
 function firstNumberByKeys(objects, keys) {
   for (const object of objects) {
     for (const key of keys) {
-      const value = numberValue2(object[key]);
+      const value = numberValue3(object[key]);
       if (value !== void 0) return value;
     }
   }
@@ -3131,7 +4504,7 @@ function inferRole(objects, root) {
   const role = firstStringByKeys(objects, ["role", "author", "speaker", "from"])?.toLowerCase();
   if (role === "user" || role === "human") return "user";
   if (role === "assistant" || role === "ai" || role === "agent") return "assistant";
-  const type = (stringValue4(root?.type) ?? stringValue4(root?.event) ?? "").toLowerCase();
+  const type = (stringValue5(root?.type) ?? stringValue5(root?.event) ?? "").toLowerCase();
   if (type.includes("user") || type.includes("prompt")) return "user";
   if (type.includes("assistant") || type.includes("response") || type.includes("completion")) return "assistant";
   return void 0;
@@ -3152,9 +4525,9 @@ function textFromUnknown(value) {
     const parts = value.map(textFromUnknown).filter((item) => Boolean(item));
     return parts.length ? parts.join("\n") : void 0;
   }
-  const object = firstObject5(value);
+  const object = firstObject6(value);
   if (!object) return void 0;
-  return stringValue4(object.text) ?? stringValue4(object.content) ?? stringValue4(object.value);
+  return stringValue5(object.text) ?? stringValue5(object.content) ?? stringValue5(object.value);
 }
 function extractUsage(objects) {
   const usageObjects = objects.filter((object) => Object.keys(object).some((key) => key.toLowerCase().includes("token") || key.toLowerCase() === "usage"));
@@ -3169,7 +4542,7 @@ function extractUsage(objects) {
   };
 }
 function applyToolSignals(breakdown, objects) {
-  const typeText = objects.flatMap((object) => [stringValue4(object.type), stringValue4(object.event), stringValue4(object.toolName), stringValue4(object.tool_name), stringValue4(object.name)]).filter((item) => Boolean(item)).join(" ").toLowerCase();
+  const typeText = objects.flatMap((object) => [stringValue5(object.type), stringValue5(object.event), stringValue5(object.toolName), stringValue5(object.tool_name), stringValue5(object.name)]).filter((item) => Boolean(item)).join(" ").toLowerCase();
   if (typeText.includes("tool")) breakdown.toolCallCount += 1;
   if (typeText.includes("terminal") || typeText.includes("shell") || typeText.includes("command")) breakdown.shellCommandCount += 1;
   if (typeText.includes("read")) breakdown.fileReadCount += 1;
@@ -3178,9 +4551,9 @@ function applyToolSignals(breakdown, objects) {
 }
 function looksFailed(object) {
   if (object.isError === true || object.is_error === true || object.error === true) return true;
-  const status = stringValue4(object.status)?.toLowerCase();
+  const status = stringValue5(object.status)?.toLowerCase();
   if (status === "failed" || status === "error") return true;
-  const exitCode = numberValue2(object.exitCode ?? object.exit_code ?? object.statusCode ?? object.status_code);
+  const exitCode = numberValue3(object.exitCode ?? object.exit_code ?? object.statusCode ?? object.status_code);
   return exitCode !== void 0 && exitCode !== 0;
 }
 function finalizeBreakdown(breakdown) {
@@ -3193,7 +4566,7 @@ function finalizeBreakdown(breakdown) {
 }
 function candidateToUsage(candidate, index, options) {
   const breakdown = candidate.breakdown;
-  const id = breakdown.id ?? `${path6.basename(candidate.sourcePath).replace(/\.(jsonl|sqlite|db|vscdb)$/i, "") || "cursor-session"}-${index}`;
+  const id = breakdown.id ?? `${path8.basename(candidate.sourcePath).replace(/\.(jsonl|sqlite|db|vscdb)$/i, "") || "cursor-session"}-${index}`;
   const cwd = breakdown.cwd ?? candidate.fallbackCwd ?? process.cwd();
   const repo = resolveRepoInfo(cwd, options.config);
   const hasTokenBreakdown = breakdown.inputTokens + breakdown.cachedInputTokens + breakdown.outputTokens + breakdown.reasoningTokens > 0;
@@ -3228,7 +4601,7 @@ function candidateToUsage(candidate, index, options) {
     messageCount: breakdown.messageCount,
     rawTokenTotal: breakdown.totalTokens || void 0,
     warnings: [...repo.warnings, ...breakdown.warnings, ...tokenWarnings, ...hasTokenBreakdown ? [] : ["missing_token_breakdown"]],
-    durationMs: durationMs3(breakdown.startedAt, breakdown.endedAt),
+    durationMs: durationMs4(breakdown.startedAt, breakdown.endedAt),
     rawEventCount: breakdown.rawEventCount,
     parseStatus: breakdown.parseStatus,
     parseErrors: breakdown.parseErrors,
@@ -3272,21 +4645,81 @@ function candidateToUsage(candidate, index, options) {
   };
 }
 function inferProjectPathFromCursorPath(filePath, cursorHome) {
-  const parts = filePath.split(path6.sep);
+  const parts = filePath.split(path8.sep);
   const projectsIndex = parts.lastIndexOf("projects");
   if (projectsIndex >= 0 && projectsIndex < parts.length - 1) {
     const projectId = parts[projectsIndex + 1];
+    const decodedProjectPath = decodeCursorProjectId(projectId);
+    if (decodedProjectPath) return decodedProjectPath;
     if (projectId?.startsWith("-")) {
-      return `${path6.sep}${projectId.slice(1).split("-").filter(Boolean).join(path6.sep)}`;
+      return `${path8.sep}${projectId.slice(1).split("-").filter(Boolean).join(path8.sep)}`;
+    }
+    if (projectId) return path8.join(cursorHome, "projects", projectId);
+  }
+  return void 0;
+}
+function inferDateFromCursorPath(filePath) {
+  const parts = filePath.split(path8.sep);
+  for (const part of parts) {
+    if (!/^\d{10,13}$/.test(part)) continue;
+    const date = dateValue5(Number(part));
+    if (date) return date;
+  }
+  return void 0;
+}
+function timestampMs3(value) {
+  if (!value) return void 0;
+  const timestamp3 = new Date(value).getTime();
+  return Number.isFinite(timestamp3) ? timestamp3 : void 0;
+}
+function fileModifiedDate2(filePath) {
+  try {
+    return fs8.statSync(filePath).mtime.toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function decodeCursorProjectId(projectId) {
+  if (!projectId) return void 0;
+  const id = projectId.startsWith("-") ? projectId.slice(1) : projectId;
+  const tokens2 = id.split("-").filter(Boolean);
+  if (tokens2.length < 2) return void 0;
+  const root = cursorProjectRoot(tokens2);
+  if (!root) return void 0;
+  const matched = matchEncodedPath(root.path, tokens2.slice(root.consumed));
+  if (matched) return matched;
+  return path8.join(root.path, ...tokens2.slice(root.consumed));
+}
+function cursorProjectRoot(tokens2) {
+  if (tokens2[0] === "Users" && tokens2[1]) return { path: path8.join(path8.sep, "Users", tokens2[1]), consumed: 2 };
+  if (tokens2[0] === "home" && tokens2[1]) return { path: path8.join(path8.sep, "home", tokens2[1]), consumed: 2 };
+  if (tokens2[0] === "tmp") return { path: path8.join(path8.sep, "tmp"), consumed: 1 };
+  if (/^[A-Za-z]$/.test(tokens2[0] ?? "") && tokens2[1]) return { path: `${tokens2[0]?.toUpperCase()}:\\`, consumed: 1 };
+  return void 0;
+}
+function matchEncodedPath(root, tokens2) {
+  if (!tokens2.length) return fs8.existsSync(root) ? root : void 0;
+  if (!fs8.existsSync(root)) return void 0;
+  try {
+    for (const entry of fs8.readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const entryTokens = entry.name.split("-").filter(Boolean);
+      if (!startsWithTokens(tokens2, entryTokens)) continue;
+      const matched = matchEncodedPath(path8.join(root, entry.name), tokens2.slice(entryTokens.length));
+      if (matched) return matched;
     }
-    if (projectId) return path6.join(cursorHome, "projects", projectId);
+  } catch {
+    return void 0;
   }
   return void 0;
 }
+function startsWithTokens(tokens2, prefix) {
+  return prefix.length <= tokens2.length && prefix.every((token, index) => tokens2[index] === token);
+}
 function inferSurfaceFromPath(filePath) {
   const lower = filePath.toLowerCase();
-  if (lower.includes(`${path6.sep}agent-transcripts${path6.sep}`) || lower.endsWith(".jsonl")) return "cli";
-  if (lower.includes(`${path6.sep}workspaceStorage${path6.sep}`.toLowerCase()) || lower.includes(`${path6.sep}globalStorage${path6.sep}`.toLowerCase()) || lower.endsWith(".vscdb")) return "desktop";
+  if (lower.includes(`${path8.sep}agent-transcripts${path8.sep}`) || lower.endsWith(".jsonl")) return "cli";
+  if (lower.includes(`${path8.sep}workspaceStorage${path8.sep}`.toLowerCase()) || lower.includes(`${path8.sep}globalStorage${path8.sep}`.toLowerCase()) || lower.endsWith(".vscdb")) return "desktop";
   return "unknown";
 }
 function cursorSourceAppLabel(surface) {
@@ -3312,7 +4745,7 @@ function inferOutcome3(breakdown) {
   if (breakdown.userPromptCount > 0 || breakdown.assistantMessageCount > 0) return "research_only";
   return "unknown";
 }
-function emptyBreakdown3() {
+function emptyBreakdown4() {
   return {
     id: void 0,
     title: void 0,
@@ -3395,10 +4828,10 @@ function mergeCursorBreakdowns(primary, secondary) {
     fileEditCount: Math.max(primary.fileEditCount, secondary.fileEditCount),
     rawEventCount: Math.max(primary.rawEventCount, secondary.rawEventCount),
     parseStatus: mergeParseStatus(primary.parseStatus, secondary.parseStatus),
-    parseErrors: unique4([...primary.parseErrors, ...secondary.parseErrors]),
+    parseErrors: unique5([...primary.parseErrors, ...secondary.parseErrors]),
     promptTimeline: primary.promptTimeline.length >= secondary.promptTimeline.length ? primary.promptTimeline : secondary.promptTimeline,
-    warnings: unique4([...primary.warnings, ...secondary.warnings, "cursor_duplicate_session_merged"]),
-    matchedKeys: unique4([...primary.matchedKeys, ...secondary.matchedKeys])
+    warnings: unique5([...primary.warnings, ...secondary.warnings, "cursor_duplicate_session_merged"]),
+    matchedKeys: unique5([...primary.matchedKeys, ...secondary.matchedKeys])
   };
 }
 function mergeParseStatus(a, b) {
@@ -3407,10 +4840,10 @@ function mergeParseStatus(a, b) {
   return "ok";
 }
 function optionalMinDate(current, candidate) {
-  return candidate ? minDate2(current, candidate) : current;
+  return candidate ? minDate3(current, candidate) : current;
 }
 function optionalMaxDate(current, candidate) {
-  return candidate ? maxDate2(current, candidate) : current;
+  return candidate ? maxDate3(current, candidate) : current;
 }
 function providerForModel2(model) {
   const normalized = model.toLowerCase();
@@ -3419,7 +4852,7 @@ function providerForModel2(model) {
   if (normalized.startsWith("gpt") || normalized.startsWith("o")) return "openai";
   return void 0;
 }
-function stringValue4(value) {
+function stringValue5(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
 function textValue(value) {
@@ -3427,24 +4860,24 @@ function textValue(value) {
   if (Buffer.isBuffer(value)) return value.toString("utf8");
   return void 0;
 }
-function numberValue2(value) {
+function numberValue3(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) return Number(value);
   return void 0;
 }
-function dateValue4(value) {
+function dateValue5(value) {
   if (typeof value === "number" && Number.isFinite(value)) return new Date(value < 1e10 ? value * 1e3 : value).toISOString();
   if (typeof value !== "string") return void 0;
   const date = new Date(value);
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
-function minDate2(current, candidate) {
+function minDate3(current, candidate) {
   return !current || candidate < current ? candidate : current;
 }
-function maxDate2(current, candidate) {
+function maxDate3(current, candidate) {
   return !current || candidate > current ? candidate : current;
 }
-function durationMs3(startedAt, endedAt) {
+function durationMs4(startedAt, endedAt) {
   if (!startedAt || !endedAt) return void 0;
   const start = new Date(startedAt).getTime();
   const end = new Date(endedAt).getTime();
@@ -3456,64 +4889,123 @@ function normalizeTimelineText3(text) {
 function roundCurrency2(value) {
   return Number(value.toFixed(6));
 }
-function unique4(values) {
+function unique5(values) {
   return [...new Set(values.filter(Boolean))];
 }
-function errorMessage3(error) {
+function errorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
 // packages/core/src/sources/index.ts
+var codexAdapter = { id: "codex", scan: scanCodex };
+var claudeAdapter = { id: "claude", scan: scanClaude };
+var copilotAdapter = { id: "copilot", scan: scanCopilot };
+var cursorAdapter = { id: "cursor", scan: scanCursor };
+var adapters = [
+  { adapter: codexAdapter, homeKey: "codexHome", homeOption: "codexHome" },
+  { adapter: claudeAdapter, homeKey: "claudeHome", homeOption: "claudeHome" },
+  { adapter: copilotAdapter, homeKey: "copilotHome", homeOption: "copilotHome" },
+  {
+    adapter: cursorAdapter,
+    homeKey: "cursorHome",
+    homeOption: "cursorHome",
+    enabled: (options) => options.config?.experimentalSources?.cursor === true || Boolean(options.cursorHome)
+  }
+];
 function scanUsageSources(options) {
-  const codex = scanCodex({
-    ...options.codexHome ? { codexHome: options.codexHome } : {},
-    ...options.config ? { config: options.config } : {},
-    pricing: options.pricing
-  });
-  const claude = scanClaude({
-    ...options.claudeHome ? { claudeHome: options.claudeHome } : {},
-    ...options.config ? { config: options.config } : {},
-    pricing: options.pricing
-  });
-  const cursor = scanCursor({
-    ...options.cursorHome ? { cursorHome: options.cursorHome } : {},
-    ...options.config ? { config: options.config } : {},
-    pricing: options.pricing
-  });
-  return {
-    sources: [codex.source, claude.source, cursor.source],
-    sourceStats: [codex.stats, claude.stats, cursor.stats],
-    sessions: [...codex.sessions, ...claude.sessions, ...cursor.sessions]
-  };
+  const sources = [];
+  const sourceStats = [];
+  const sessions = [];
+  for (const entry of adapters) {
+    if (entry.enabled && !entry.enabled(options)) continue;
+    const home = options[entry.homeKey];
+    const result = entry.adapter.scan({
+      ...home ? { [entry.homeOption]: home } : {},
+      ...options.config ? { config: options.config } : {},
+      ...options.scanWindow ? { scanWindow: options.scanWindow } : {},
+      pricing: options.pricing
+    });
+    sources.push(result.source);
+    sourceStats.push(result.stats);
+    sessions.push(...result.sessions);
+  }
+  return { sources, sourceStats, sessions };
 }
 
 // apps/server/src/data.ts
-import fs7 from "node:fs";
+import fs9 from "node:fs";
+import path9 from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var scanCacheTtlMs = 1e4;
 var scanCache;
+var warmScanInFlight = false;
+var warmScanChild;
+var warmedScanKeys = /* @__PURE__ */ new Set();
 function readDashboardData(filters = {}, options = {}) {
-  const raw = readRawUsageData();
+  const raw = readRawUsageData(filters);
   return buildDashboardSnapshot({ ...raw, sessions: displaySessions(raw.sessions, options), filters });
 }
 function clearScanCache() {
   scanCache = void 0;
+  warmScanInFlight = false;
+  warmScanChild?.kill();
+  warmScanChild = void 0;
+  warmedScanKeys.clear();
 }
-function readRawUsageData() {
+function readRawUsageData(filters = {}) {
   const cwd = runtimeCwd();
-  if (scanCache && scanCache.cwd === cwd && scanCache.expiresAt > Date.now()) {
+  const { config, warnings: configWarnings } = loadConfigWithWarnings();
+  const cacheKey = scanCacheKey({ cwd, filters, cursorEnabled: config.experimentalSources?.cursor === true });
+  if (scanCache && scanCache.key === cacheKey && scanCache.expiresAt > Date.now()) {
     return scanCache.data;
   }
-  const { config, warnings: configWarnings } = loadConfigWithWarnings();
   const pricing = loadPricingTable(resolvePricingPath(config));
-  const scan = scanUsageSources({ config, pricing });
+  const scanWindow = scanWindowFromFilters(filters);
+  const scan = scanUsageSources({
+    config,
+    pricing,
+    ...scanWindow ? { scanWindow } : {}
+  });
   const data = {
     sources: scan.sources.map((source) => ({ ...source, warnings: [...source.warnings, ...configWarnings] })),
     sourceStats: scan.sourceStats,
     sessions: scan.sessions
   };
-  scanCache = { cwd, data, expiresAt: Date.now() + scanCacheTtlMs };
+  scanCache = { key: cacheKey, data, expiresAt: Date.now() + scanCacheTtlMs };
   return data;
 }
+function warmDashboardCache(filters = {}, options = {}) {
+  const cwd = runtimeCwd();
+  const config = loadConfig();
+  const key = scanCacheKey({ cwd, filters, cursorEnabled: config.experimentalSources?.cursor === true });
+  if (scanCache?.key === key || warmedScanKeys.has(key)) return { started: false, key, reason: "already_warm" };
+  if (warmScanInFlight) return { started: false, key, reason: "warm_scan_in_flight" };
+  warmScanInFlight = true;
+  let child;
+  try {
+    child = spawn(process.execPath, [...process.execArgv, cliEntryPath(), "__warm-cache", ...warmCacheArgs(filters, options)], {
+      detached: true,
+      env: process.env,
+      stdio: "ignore"
+    });
+  } catch (error) {
+    warmScanInFlight = false;
+    return { started: false, key, reason: error instanceof Error ? error.message : String(error) };
+  }
+  warmScanChild = child;
+  child.once("error", () => {
+    warmScanInFlight = false;
+    if (warmScanChild === child) warmScanChild = void 0;
+  });
+  child.once("exit", (code) => {
+    warmScanInFlight = false;
+    if (warmScanChild === child) warmScanChild = void 0;
+    if (code === 0) warmedScanKeys.add(key);
+  });
+  child.unref();
+  return { started: true, key };
+}
 function parseFilters(query) {
   const filters = {};
   const source = listQuery(query.source);
@@ -3543,6 +5035,20 @@ function readPricingData() {
     models: loadPricingTable(pricingPath)
   };
 }
+function readConfigData() {
+  return {
+    path: configPath(),
+    config: loadConfig()
+  };
+}
+function writeConfigData(nextConfig) {
+  const saved = saveConfig(nextConfig);
+  clearScanCache();
+  return {
+    path: configPath(),
+    config: saved
+  };
+}
 function writePricingData(models) {
   const config = loadConfig();
   const pricingPath = resolvePricingPath(config);
@@ -3555,16 +5061,21 @@ function writePricingData(models) {
 }
 function clearRepoSpendLocalData() {
   const target = repospendHome();
-  const removed = fs7.existsSync(target);
-  fs7.rmSync(target, { recursive: true, force: true });
+  const removed = fs9.existsSync(target);
+  fs9.rmSync(target, { recursive: true, force: true });
   clearScanCache();
   return { path: target, removed };
 }
-function exportJson() {
-  return JSON.stringify(readDashboardData().sessions, null, 2);
+function clearRepoSpendParseCache() {
+  const result = clearRepoSpendCache();
+  clearScanCache();
+  return result;
+}
+function exportJson(filters = {}, options = {}) {
+  return JSON.stringify(readDashboardData(filters, options).sessions, null, 2);
 }
-function exportCsv() {
-  return toCsv(readDashboardData().sessions);
+function exportCsv(filters = {}, options = {}) {
+  return toCsv(readDashboardData(filters, options).sessions);
 }
 function stringQuery(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -3584,9 +5095,39 @@ function displaySessions(sessions, options) {
 function sourceScopedAppLabel(session) {
   const app = session.sourceApp || fallbackSurfaceLabel(session.detectedSurface);
   if (!app || app === "Unknown") return sourceClientLabel(session.sourceClient);
+  if (session.sourceClient === "copilot" && app === "Copilot CLI") return "GitHub Copilot CLI";
   if (!shouldScopeApp(app)) return app;
   return `${sourceClientLabel(session.sourceClient)} on ${app}`;
 }
+function scanWindowFromFilters(filters) {
+  const fromMs = filters.from ? lowerBound(filters.from) : void 0;
+  const toMs = filters.to ? upperBound(filters.to) : void 0;
+  const scanWindow = {};
+  if (fromMs !== void 0) scanWindow.fromMs = fromMs;
+  if (toMs !== void 0) scanWindow.toMs = toMs;
+  return scanWindow.fromMs === void 0 && scanWindow.toMs === void 0 ? void 0 : scanWindow;
+}
+function scanCacheKey({ cwd, filters, cursorEnabled }) {
+  return JSON.stringify({
+    cwd,
+    from: filters.from ?? "",
+    to: filters.to ?? "",
+    cursor: cursorEnabled
+  });
+}
+function warmCacheArgs(filters, options) {
+  const args2 = [];
+  if (filters.from) args2.push("--from", filters.from);
+  if (filters.to) args2.push("--to", filters.to);
+  if (options.splitSourceApps) args2.push("--splitSourceApps");
+  return args2;
+}
+function cliEntryPath() {
+  const currentDir = path9.dirname(fileURLToPath2(import.meta.url));
+  const sourceCli = path9.join(currentDir, "cli.ts");
+  if (fs9.existsSync(sourceCli)) return sourceCli;
+  return path9.join(currentDir, "cli.js");
+}
 function shouldScopeApp(app) {
   const normalized = app.toLowerCase();
   return normalized.includes("vs code") || normalized.includes("vscode") || normalized.includes("terminal") || normalized.includes("cli");
@@ -3594,6 +5135,7 @@ function shouldScopeApp(app) {
 function sourceClientLabel(source) {
   if (source === "codex") return "Codex";
   if (source === "claude") return "Claude Code";
+  if (source === "copilot") return "GitHub Copilot";
   if (source === "gemini-cli") return "Gemini CLI";
   if (source === "opencode") return "OpenCode";
   if (source === "cursor") return "Cursor";
@@ -3611,14 +5153,64 @@ function runtimeCwd() {
   return process.env.INIT_CWD || process.cwd();
 }
 
+// apps/server/src/cli-options.ts
+function parseCliFilters(args2) {
+  const filters = {};
+  const source = listOption(args2, ["--source"]).filter((value) => value !== "all");
+  const sourceApp = listOption(args2, ["--sourceApp", "--source-app", "--app"]);
+  const repo = listOption(args2, ["--repo"]);
+  const model = listOption(args2, ["--model"]);
+  const from = valueAfter(args2, "--from");
+  const to = valueAfter(args2, "--to");
+  if (source.length) filters.source = source;
+  if (sourceApp.length) filters.sourceApp = sourceApp;
+  if (repo.length) filters.repo = repo;
+  if (model.length) filters.model = model;
+  if (from) filters.from = from;
+  if (to) filters.to = to;
+  return filters;
+}
+function parseCliDateFilters(args2) {
+  const filters = {};
+  const from = valueAfter(args2, "--from");
+  const to = valueAfter(args2, "--to");
+  if (from) filters.from = from;
+  if (to) filters.to = to;
+  return filters;
+}
+function parseCliDashboardOptions(args2) {
+  return {
+    splitSourceApps: args2.includes("--splitSourceApps") || args2.includes("--split-source-apps")
+  };
+}
+function valueAfter(args2, flag) {
+  const index = args2.indexOf(flag);
+  const value = index >= 0 ? args2[index + 1] : void 0;
+  return value && !value.startsWith("--") ? value : void 0;
+}
+function listOption(args2, flags) {
+  const values = [];
+  for (const flag of flags) {
+    args2.forEach((arg, index) => {
+      if (arg === flag) {
+        const value = args2[index + 1];
+        if (value && !value.startsWith("--")) values.push(value);
+      } else if (arg.startsWith(`${flag}=`)) {
+        values.push(arg.slice(flag.length + 1));
+      }
+    });
+  }
+  return [...new Set(values.flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean))];
+}
+
 // apps/server/src/server.ts
-import fs8 from "node:fs";
-import path7 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import fs10 from "node:fs";
+import path10 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
 
-// apps/server/src/demo-data.ts
+// apps/server/src/demo/fixtures.ts
 var baseDate = "2026-05-18";
 var demoPricing = {
   ...defaultPricing,
@@ -3626,68 +5218,14 @@ var demoPricing = {
   "gpt-5.3-codex-spark": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14 },
   "claude-haiku-4-5-20251001": { inputPerMillion: 1, cacheCreationInputPerMillion: 1.25, cachedInputPerMillion: 0.1, outputPerMillion: 5 }
 };
-function demoModeEnabled() {
-  return process.env.REPOSPEND_DEMO_DATA === "lotr";
-}
-function readDemoDashboardData(filters = {}, options = {}) {
-  return buildDashboardSnapshot({
-    sources: demoSources,
-    sourceStats: demoSourceStats,
-    sessions: displaySessions(demoSessions, options),
-    filters
-  });
-}
-function readDemoRtkGain() {
+function issue(command2, category, severity, impact, reason) {
   return {
-    available: true,
-    rtkDetected: true,
-    rtkVersion: "rtk-demo 1.0.0",
-    rtkCodexHookStatus: "active",
-    rtkLastActivityAt: "2026-05-18T18:42:00.000Z",
-    rtkDataSource: "fictional demo data",
-    totalCommands: 248,
-    inputTokens: "18.4M",
-    outputTokens: "2.6M",
-    tokensSaved: "5.8M",
-    savedPercent: 23.9,
-    totalExecTime: "41m",
-    averageExecTime: "9.9s",
-    rtkTokensSaved: "5.8M",
-    rtkSavingsRate: 23.9,
-    rtkCommandsProcessed: 248,
-    rtkAverageCommandRuntime: "9.9s",
-    rtkTopSavingsCommands: [
-      { command: "rg", count: 74, saved: "1.9M", averageSavedPercent: 31.2, time: "8m" },
-      { command: "pnpm test", count: 18, saved: "840K", averageSavedPercent: 17.4, time: "12m" },
-      { command: "git diff", count: 39, saved: "620K", averageSavedPercent: 26.8, time: "2m" }
-    ],
-    rtkRecentActivity: [
-      "rg council-of-elrond planner",
-      "pnpm test --filter gondor-api",
-      "git diff -- shire-mobile"
-    ],
-    rtkDiscoverAvailable: true,
-    rtkDiscoverError: void 0,
-    rtkDiscoverSummary: "Total: 248 fictional command events scanned.",
-    rtkCoverageGaps: [
-      { command: "cat", count: 21, rtkEquivalent: "rtk sed", status: "easy win", estimatedSavings: "410K" },
-      { command: "grep", count: 13, rtkEquivalent: "rtk rg", status: "easy win", estimatedSavings: "360K" }
-    ],
-    rtkUnhandledCommands: [
-      { command: "palantirctl inspect", count: 5, example: "palantirctl inspect eye-of-sauron-alerts" }
-    ],
-    topCommands: [
-      { command: "rg", count: 74, saved: "1.9M", averageSavedPercent: 31.2, time: "8m" },
-      { command: "git", count: 46, saved: "720K", averageSavedPercent: 18.3, time: "3m" },
-      { command: "pnpm", count: 31, saved: "1.1M", averageSavedPercent: 16.8, time: "17m" }
-    ],
-    recentCommands: [
-      "rtk rg auth gates-of-moria",
-      "rtk pnpm test --filter palantir-observability",
-      "rtk git diff -- one-ring-infra"
-    ],
-    raw: "RepoSpend LOTR demo RTK output",
-    error: void 0
+    command: command2,
+    category,
+    classification: severity === "critical" ? "blocking_failure" : "warning",
+    severity,
+    impact,
+    reason
   };
 }
 var demoSources = [
@@ -3704,6 +5242,17 @@ var demoSources = [
     available: true,
     paths: ["/demo/middle-earth/claude/projects"],
     warnings: []
+  },
+  {
+    id: "copilot",
+    label: "GitHub Copilot",
+    available: true,
+    paths: [
+      "/demo/middle-earth/copilot/otel",
+      "/demo/middle-earth/copilot/session-state",
+      "/demo/middle-earth/vscode/User/workspaceStorage"
+    ],
+    warnings: []
   }
 ];
 var demoSourceStats = [
@@ -3735,6 +5284,26 @@ var demoSourceStats = [
     malformedFileCount: 0,
     projectDirCount: 4,
     lastScannedAt: "2026-05-18T19:01:00.000Z"
+  },
+  {
+    sourceId: "copilot",
+    sourceLabel: "GitHub Copilot",
+    homePath: "/demo/middle-earth/copilot",
+    copilotHome: "/demo/middle-earth/copilot",
+    otelPath: "/demo/middle-earth/copilot/otel",
+    workspaceStoragePath: "/demo/middle-earth/vscode/User/workspaceStorage",
+    otelExists: true,
+    sessionsExists: true,
+    otelFileCount: 5,
+    transcriptFileCount: 3,
+    debugLogFileCount: 2,
+    sessionStateFileCount: 2,
+    sessionFileCount: 10,
+    sessionsImported: 3,
+    parseFailureCount: 0,
+    unreadableFileCount: 0,
+    malformedFileCount: 0,
+    lastScannedAt: "2026-05-18T19:02:00.000Z"
   }
 ];
 var demoInputs = [
@@ -3911,6 +5480,32 @@ var demoInputs = [
     outcome: "completed",
     branch: "planner/elrond-v2"
   },
+  {
+    id: "lotr-session-015",
+    repo: "rivendell-dashboard",
+    title: "Use Copilot to draft council agenda actions",
+    sourceClient: "copilot",
+    sourceApp: "VS Code",
+    sourceAppRaw: "vscode.copilot-chat",
+    model: "lark-vscode-preview",
+    provider: "github-copilot",
+    hour: 14,
+    minute: 55,
+    durationMinutes: 36,
+    inputTokens: 51e4,
+    cachedInputTokens: 18e4,
+    outputTokens: 74e3,
+    reasoningTokens: 0,
+    prompts: 4,
+    replies: 7,
+    tools: 24,
+    commands: 6,
+    edits: 6,
+    reads: 29,
+    outcome: "completed",
+    branch: "planner/copilot-actions",
+    detectedSurface: "vscode_extension"
+  },
   {
     id: "lotr-session-007",
     repo: "palantir-observability",
@@ -3937,6 +5532,39 @@ var demoInputs = [
     harmlessNonZero: 2,
     exploratoryMisses: 3
   },
+  {
+    id: "lotr-session-016",
+    repo: "palantir-observability",
+    title: "Trace Copilot alert summaries through the seeing-stone feed",
+    sourceClient: "copilot",
+    sourceApp: "Copilot CLI",
+    sourceAppRaw: "copilot-cli",
+    model: "copilot/gpt-5-mini",
+    provider: "openai",
+    hour: 16,
+    minute: 35,
+    durationMinutes: 43,
+    inputTokens: 69e4,
+    cachedInputTokens: 21e4,
+    outputTokens: 88e3,
+    reasoningTokens: 0,
+    prompts: 5,
+    replies: 8,
+    tools: 30,
+    commands: 13,
+    edits: 3,
+    reads: 34,
+    outcome: "partial",
+    branch: "alerts/copilot-summaries",
+    warnings: ["copilot_partial_token_breakdown"],
+    importantFailures: 1,
+    topFailureType: "test",
+    detectedSurface: "terminal_cli",
+    tokenConfidence: "medium",
+    issueSamples: [
+      issue("pnpm test --filter palantir-alerts", "test", "warning", "medium", "A generated summary snapshot changed before the matcher was tightened.")
+    ]
+  },
   {
     id: "lotr-session-008",
     repo: "mordor-ci",
@@ -4012,6 +5640,32 @@ var demoInputs = [
     outcome: "completed",
     branch: "docs/ring-config"
   },
+  {
+    id: "lotr-session-017",
+    repo: "fellowship-docs",
+    title: "Ask Copilot to review the ring-config redaction guide",
+    sourceClient: "copilot",
+    sourceApp: "VS Code",
+    sourceAppRaw: "vscode.copilot-chat",
+    model: "copilot/claude-sonnet-4.5",
+    provider: "anthropic",
+    hour: 18,
+    minute: 42,
+    durationMinutes: 18,
+    inputTokens: 24e4,
+    cachedInputTokens: 96e3,
+    outputTokens: 31e3,
+    reasoningTokens: 0,
+    prompts: 2,
+    replies: 4,
+    tools: 12,
+    commands: 3,
+    edits: 2,
+    reads: 15,
+    outcome: "completed",
+    branch: "docs/copilot-redaction",
+    detectedSurface: "vscode_extension"
+  },
   {
     id: "lotr-session-011",
     repo: "one-ring-infra",
@@ -4119,6 +5773,74 @@ var demoInputs = [
     branch: "offline/bag-end"
   }
 ];
+
+// apps/server/src/demo/rtk.ts
+function readDemoRtkGain() {
+  return {
+    available: true,
+    rtkDetected: true,
+    rtkVersion: "rtk-demo 1.0.0",
+    rtkCodexHookStatus: "active",
+    rtkLastActivityAt: "2026-05-18T18:42:00.000Z",
+    rtkDataSource: "fictional demo data",
+    totalCommands: 248,
+    inputTokens: "18.4M",
+    outputTokens: "2.6M",
+    tokensSaved: "5.8M",
+    savedPercent: 23.9,
+    totalExecTime: "41m",
+    averageExecTime: "9.9s",
+    rtkTokensSaved: "5.8M",
+    rtkSavingsRate: 23.9,
+    rtkCommandsProcessed: 248,
+    rtkAverageCommandRuntime: "9.9s",
+    rtkTopSavingsCommands: [
+      { command: "rg", count: 74, saved: "1.9M", averageSavedPercent: 31.2, time: "8m" },
+      { command: "pnpm test", count: 18, saved: "840K", averageSavedPercent: 17.4, time: "12m" },
+      { command: "git diff", count: 39, saved: "620K", averageSavedPercent: 26.8, time: "2m" }
+    ],
+    rtkRecentActivity: [
+      "rg council-of-elrond planner",
+      "pnpm test --filter gondor-api",
+      "git diff -- shire-mobile"
+    ],
+    rtkDiscoverAvailable: true,
+    rtkDiscoverError: void 0,
+    rtkDiscoverSummary: "Total: 248 fictional command events scanned.",
+    rtkCoverageGaps: [
+      { command: "cat", count: 21, rtkEquivalent: "rtk sed", status: "easy win", estimatedSavings: "410K" },
+      { command: "grep", count: 13, rtkEquivalent: "rtk rg", status: "easy win", estimatedSavings: "360K" }
+    ],
+    rtkUnhandledCommands: [
+      { command: "palantirctl inspect", count: 5, example: "palantirctl inspect eye-of-sauron-alerts" }
+    ],
+    topCommands: [
+      { command: "rg", count: 74, saved: "1.9M", averageSavedPercent: 31.2, time: "8m" },
+      { command: "git", count: 46, saved: "720K", averageSavedPercent: 18.3, time: "3m" },
+      { command: "pnpm", count: 31, saved: "1.1M", averageSavedPercent: 16.8, time: "17m" }
+    ],
+    recentCommands: [
+      "rtk rg auth gates-of-moria",
+      "rtk pnpm test --filter palantir-observability",
+      "rtk git diff -- one-ring-infra"
+    ],
+    raw: "RepoSpend LOTR demo RTK output",
+    error: void 0
+  };
+}
+
+// apps/server/src/demo/index.ts
+function demoModeEnabled() {
+  return process.env.REPOSPEND_DEMO_DATA === "lotr";
+}
+function readDemoDashboardData(filters = {}, options = {}) {
+  return buildDashboardSnapshot({
+    sources: demoSources,
+    sourceStats: demoSourceStats,
+    sessions: displaySessions(demoSessions, options),
+    filters
+  });
+}
 var demoSessions = demoInputs.map(toSession);
 function toSession(input) {
   const start = timestamp2(input.hour, input.minute);
@@ -4207,16 +5929,6 @@ function detectedSurfaceForApp(sourceApp) {
 function timestamp2(hour, minute) {
   return `${baseDate}T${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}:00.000Z`;
 }
-function issue(command2, category, severity, impact, reason) {
-  return {
-    command: command2,
-    category,
-    classification: severity === "critical" ? "blocking_failure" : "warning",
-    severity,
-    impact,
-    reason
-  };
-}
 function demoReply(repo, edits, importantFailures) {
   if (importantFailures > 0) {
     return `Found the noisy path in ${repo}, separated the risky failures from ordinary exploration, and left a short list of follow-up checks.`;
@@ -4419,6 +6131,15 @@ function recentCommandLines(lines) {
 // apps/server/src/server.ts
 function createServer(options = {}) {
   const app = Fastify({ logger: false });
+  app.addHook("onRequest", async (request, reply) => {
+    if (!isProtectedLocalMutation(request.method, request.url)) return;
+    if (!isAllowedLocalHost(request.headers.host)) {
+      return reply.code(403).send({ error: "Mutating RepoSpend local settings requires a localhost Host header." });
+    }
+    if (!isAllowedLocalOrigin(request.headers.origin)) {
+      return reply.code(403).send({ error: "Mutating RepoSpend local settings requires a localhost Origin." });
+    }
+  });
   app.get("/api/health", async () => ({ ok: true, app: "RepoSpend", version: readPackageVersion() }));
   app.get("/api/dashboard", async (request) => {
     const query = request.query;
@@ -4427,6 +6148,7 @@ function createServer(options = {}) {
     const demoMode = demoModeEnabled();
     const data = demoMode ? readDemoDashboardData(filters, dashboardOptions) : readDashboardData(filters, dashboardOptions);
     const rtkGain = demoMode ? readDemoRtkGain() : await readRtkGain();
+    const configData = readConfigData();
     return {
       ...data,
       appVersion: readPackageVersion(),
@@ -4435,6 +6157,8 @@ function createServer(options = {}) {
         info: pricingInfo,
         ...readPricingData()
       },
+      config: configData.config,
+      configPath: configData.path,
       rtkGain
     };
   });
@@ -4442,20 +6166,32 @@ function createServer(options = {}) {
     info: pricingInfo,
     ...writePricingData(validatePricingBody(request.body))
   }));
+  app.put("/api/settings/config", async (request) => writeConfigData(validateConfigBody(request.body)));
   app.delete("/api/settings/local-data", async () => clearRepoSpendLocalData());
-  app.get("/api/export.json", async (_request, reply) => {
+  app.delete("/api/settings/cache", async () => {
+    if (demoModeEnabled()) return { path: "demo mode (cache disabled)", removed: false, demo: true };
+    return clearRepoSpendParseCache();
+  });
+  app.post("/api/cache/warm", async (request) => {
+    if (demoModeEnabled()) return { started: false, reason: "demo_mode" };
+    const query = request.query;
+    return warmDashboardCache(warmCacheFilters(), parseDashboardOptions(query));
+  });
+  app.get("/api/export.json", async (request, reply) => {
+    const query = request.query;
     reply.header("content-type", "application/json; charset=utf-8");
-    return exportJson();
+    return exportJson(parseFilters(query), parseDashboardOptions(query));
   });
-  app.get("/api/export.csv", async (_request, reply) => {
+  app.get("/api/export.csv", async (request, reply) => {
+    const query = request.query;
     reply.header("content-type", "text/csv; charset=utf-8");
     reply.header("content-disposition", 'attachment; filename="repospend-export.csv"');
-    return exportCsv();
+    return exportCsv(parseFilters(query), parseDashboardOptions(query));
   });
   if (options.serveWeb !== false) {
-    const serverDist = path7.dirname(fileURLToPath2(import.meta.url));
-    const packagedWebDist = path7.resolve(serverDist, "../web-dist");
-    const workspaceWebDist = path7.resolve(serverDist, "../../web/dist");
+    const serverDist = path10.dirname(fileURLToPath3(import.meta.url));
+    const packagedWebDist = path10.resolve(serverDist, "../web-dist");
+    const workspaceWebDist = path10.resolve(serverDist, "../../web/dist");
     const webDist = fsExists(packagedWebDist) ? packagedWebDist : workspaceWebDist;
     if (!fsExists(webDist)) {
       throw new Error(`RepoSpend web assets are missing. Expected ${packagedWebDist} in the published package, or ${workspaceWebDist} during local development. Run "pnpm pack:prepare" before packaging.`);
@@ -4476,13 +6212,13 @@ function createServer(options = {}) {
   return app;
 }
 function fsExists(inputPath) {
-  return Boolean(inputPath) && path7.isAbsolute(inputPath) && fs8.existsSync(inputPath);
+  return Boolean(inputPath) && path10.isAbsolute(inputPath) && fs10.existsSync(inputPath);
 }
 function readPackageVersion() {
-  const serverDist = path7.dirname(fileURLToPath2(import.meta.url));
-  const packagePath = path7.resolve(serverDist, "../package.json");
+  const serverDist = path10.dirname(fileURLToPath3(import.meta.url));
+  const packagePath = path10.resolve(serverDist, "../package.json");
   try {
-    const parsed = JSON.parse(fs8.readFileSync(packagePath, "utf8"));
+    const parsed = JSON.parse(fs10.readFileSync(packagePath, "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
@@ -4514,6 +6250,33 @@ function portCandidates(startPort, fallbackCount) {
 function isAddressInUse(error) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === "EADDRINUSE");
 }
+function isProtectedLocalMutation(method, url) {
+  if (method !== "PUT" && method !== "POST" && method !== "DELETE") return false;
+  return url.startsWith("/api/settings/") || url.startsWith("/api/cache/");
+}
+function isAllowedLocalHost(hostHeader) {
+  if (!hostHeader) return false;
+  const host = hostFromHeader(hostHeader).toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+function isAllowedLocalOrigin(originHeader) {
+  if (!originHeader) return true;
+  try {
+    return isAllowedLocalHost(new URL(originHeader).host);
+  } catch {
+    return false;
+  }
+}
+function hostFromHeader(hostHeader) {
+  const value = hostHeader.trim();
+  if (value.startsWith("[")) {
+    const end = value.indexOf("]");
+    return end >= 0 ? value.slice(1, end) : value;
+  }
+  const colonCount = (value.match(/:/g) ?? []).length;
+  if (colonCount === 1) return value.slice(0, value.indexOf(":"));
+  return value;
+}
 function validatePricingBody(body) {
   if (!body || typeof body !== "object" || Array.isArray(body)) {
     throw new Error("Expected JSON body with a models object.");
@@ -4544,6 +6307,31 @@ function validatePricingBody(body) {
   }
   return validated;
 }
+function validateConfigBody(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return {};
+  const input = body;
+  const config = {};
+  if (Array.isArray(input.repos)) config.repos = input.repos;
+  if (typeof input.pricingPath === "string") config.pricingPath = input.pricingPath;
+  const experimentalSources = input.experimentalSources;
+  if (experimentalSources && typeof experimentalSources === "object" && !Array.isArray(experimentalSources)) {
+    config.experimentalSources = {
+      cursor: experimentalSources.cursor === true
+    };
+  }
+  return config;
+}
+function warmCacheFilters() {
+  const days = 30;
+  const now = /* @__PURE__ */ new Date();
+  return {
+    from: dateOnly(new Date(now.getTime() - days * 24 * 60 * 60 * 1e3)),
+    to: dateOnly(now)
+  };
+}
+function dateOnly(value) {
+  return value.toISOString().slice(0, 10);
+}
 function finiteNumber(value) {
   if (value === "" || value === null || value === void 0) return void 0;
   const parsed = typeof value === "number" ? value : Number(value);
@@ -4561,23 +6349,27 @@ try {
     if (port !== requestedPort) console.log(`Port ${requestedPort} is already in use; using ${port} instead.`);
     console.log(`RepoSpend dashboard: ${url}`);
     openBrowser(url);
+  } else if (command === "__warm-cache") {
+    readDashboardData(parseCliDateFilters(args), parseCliDashboardOptions(args));
   } else if (command === "scan") {
-    const data = readDashboardData(cliFilters(args));
+    const data = readDashboardData(parseCliFilters(args), parseCliDashboardOptions(args));
     console.log(JSON.stringify({ sources: data.sources, sessionCount: data.sessions.length, summary: data.summary }, null, 2));
   } else if (command === "by-repo") {
-    printGroups(groupByRepo(readDashboardData(cliFilters(args)).sessions));
+    printGroups(groupByRepo(readDashboardData(parseCliFilters(args), parseCliDashboardOptions(args)).sessions));
   } else if (command === "by-day") {
-    printGroups(groupByDay(readDashboardData(cliFilters(args)).sessions));
+    printGroups(groupByDay(readDashboardData(parseCliFilters(args), parseCliDashboardOptions(args)).sessions));
   } else if (command === "by-hour") {
-    printGroups(groupByHour(readDashboardData(cliFilters(args)).sessions));
+    printGroups(groupByHour(readDashboardData(parseCliFilters(args), parseCliDashboardOptions(args)).sessions));
   } else if (command === "by-model") {
-    printGroups(groupByModel(readDashboardData(cliFilters(args)).sessions));
+    printGroups(groupByModel(readDashboardData(parseCliFilters(args), parseCliDashboardOptions(args)).sessions));
   } else if (command === "by-app") {
-    printGroups(groupBySourceApp(readDashboardData(cliFilters(args)).sessions));
+    printGroups(groupBySourceApp(readDashboardData(parseCliFilters(args), parseCliDashboardOptions(args)).sessions));
+  } else if (command === "doctor") {
+    printDoctor(readDashboardData(parseCliFilters(args), parseCliDashboardOptions(args)));
   } else if (command === "export") {
     const format = valueAfter(args, "--format") ?? "json";
-    const filters = cliFilters(args);
-    const sessions = readDashboardData(filters).sessions;
+    const filters = parseCliFilters(args);
+    const sessions = readDashboardData(filters, parseCliDashboardOptions(args)).sessions;
     console.log(format === "csv" ? toCsv(sessions) : JSON.stringify(sessions, null, 2));
   } else {
     console.error(`Unknown command: ${command}`);
@@ -4592,14 +6384,14 @@ function openBrowser(url) {
   if (process.env.REPOSPEND_NO_OPEN === "1" || process.env.CI === "true") return;
   const command2 = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args2 = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  const child = spawn(command2, args2, { detached: true, stdio: "ignore" });
+  const child = spawn2(command2, args2, { detached: true, stdio: "ignore" });
   child.on("error", () => {
   });
   child.unref();
 }
 function printGroups(groups) {
   if (!groups.length) {
-    console.log("No usage found. Scanned Codex, Claude Code, and Cursor local data paths.");
+    console.log("No usage found. Scanned enabled local data paths.");
     return;
   }
   const rows = groups.map((group) => ({
@@ -4610,18 +6402,42 @@ function printGroups(groups) {
   }));
   console.table(rows);
 }
-function cliFilters(args2) {
-  const source = valueAfter(args2, "--source");
-  if (!source || source === "all") return {};
-  return { source };
+function printDoctor(data) {
+  const confidence = data.confidence;
+  console.log(`RepoSpend data confidence: ${confidence.label} (${confidence.score}/100)`);
+  console.table([
+    { metric: "Sessions", value: confidence.sessionCount },
+    { metric: "Token data coverage", value: `${Math.round(confidence.tokenDataPct * 100)}% (${confidence.tokenDataSessions}/${confidence.sessionCount})` },
+    { metric: "Pricing coverage", value: `${Math.round(confidence.pricingCoveragePct * 100)}% (${confidence.pricedTokenSessions}/${confidence.tokenDataSessions})` },
+    { metric: "Repo grouping", value: `${Math.round(confidence.verifiedRepoPct * 100)}% verified (${confidence.verifiedRepoSessions}/${confidence.sessionCount})` },
+    { metric: "Parse issues", value: confidence.parseIssueCount },
+    { metric: "Source warnings", value: confidence.sourceWarningCount }
+  ]);
+  if (confidence.issues.length) {
+    console.table(confidence.issues.map((issue2) => ({
+      severity: issue2.tone,
+      issue: issue2.title,
+      detail: issue2.detail,
+      sessions: issue2.affectedSessionIds.length
+    })));
+  } else {
+    console.log("No data-confidence issues detected.");
+  }
+  console.table(data.sourceStats.map((source) => ({
+    source: source.sourceLabel ?? source.sourceId ?? "unknown",
+    imported: source.sessionsImported ?? 0,
+    files: source.sessionFileCount,
+    parseIssues: source.parseFailureCount ?? 0,
+    primaryData: sourcePrimaryDataFound(source) ? "found" : "missing"
+  })));
 }
-function valueAfter(args2, flag) {
-  const index = args2.indexOf(flag);
-  return index >= 0 ? args2[index + 1] : void 0;
+function sourcePrimaryDataFound(source) {
+  return Boolean(source.stateExists || source.sessionsExists || source.projectsExists || source.historyExists || source.otelExists || (source.otelFileCount ?? 0) > 0 || (source.databaseFileCount ?? 0) > 0);
 }
 function printHelp() {
   console.log(`RepoSpend commands:
   repospend serve
+  repospend doctor
   repospend scan
   repospend by-repo
   repospend by-day
@@ -4632,5 +6448,13 @@ function printHelp() {
   repospend export --format csv
 
 Options:
-  --source all|codex|claude|cursor`);
+  --source all|codex|claude|copilot|cursor
+  --sourceApp "VS Code" | --source-app "VS Code" | --app "VS Code"
+  --repo <repo name or path>
+  --model <model id>
+  --from YYYY-MM-DD
+  --to YYYY-MM-DD
+  --split-source-apps
+
+Cursor is experimental and only scans when enabled in ~/.repospend/config.json.`);
 }