repospend 0.0.2 → 0.0.3

package/dist/cli.js

@@ -110,6 +110,7 @@ function toCsv(sessions) {
     "provider",
     "inputTokens",
     "cachedInputTokens",
+    "cacheCreationInputTokens",
     "outputTokens",
     "reasoningTokens",
     "reasoningOutputTokens",
@@ -194,11 +195,15 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 var pricingInfo = {
-  sourceName: "OpenAI API pricing",
+  sourceName: "Bundled OpenAI and Claude API 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" }
+  ],
   unit: "USD per 1M tokens",
   updatedAt: "2026-05-18",
-  note: "RepoSpend estimates API-equivalent cost from local token counts and public API-style Standard short-context pricing. This is not your actual ChatGPT/Codex bill; subscriptions, credits, provider terms, long-context pricing, regional processing, or other billing factors can make your real cost different."
+  note: "RepoSpend estimates API-equivalent cost from local token counts and public API-style Standard pricing. This is not your actual bill; subscriptions, credits, provider terms, cache behavior, regional processing, or other billing factors can make your real cost different."
 };
 var defaultPricing = {
   "gpt-5.5": { inputPerMillion: 5, cachedInputPerMillion: 0.5, outputPerMillion: 30, reasoningOutputPerMillion: 30 },
@@ -220,7 +225,17 @@ var defaultPricing = {
   "gpt-5-codex": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, reasoningOutputPerMillion: 10 },
   "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-5-nano": { inputPerMillion: 0.05, cachedInputPerMillion: 5e-3, outputPerMillion: 0.4, reasoningOutputPerMillion: 0.4 },
+  "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-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 },
+  "claude-sonnet-4-6": { inputPerMillion: 3, cacheCreationInputPerMillion: 3.75, cachedInputPerMillion: 0.3, outputPerMillion: 15 },
+  "claude-sonnet-4-5": { inputPerMillion: 3, cacheCreationInputPerMillion: 3.75, cachedInputPerMillion: 0.3, outputPerMillion: 15 },
+  "claude-sonnet-4": { inputPerMillion: 3, cacheCreationInputPerMillion: 3.75, cachedInputPerMillion: 0.3, outputPerMillion: 15 },
+  "claude-haiku-4-5": { inputPerMillion: 1, cacheCreationInputPerMillion: 1.25, cachedInputPerMillion: 0.1, outputPerMillion: 5 },
+  "claude-3-5-haiku": { inputPerMillion: 0.8, cacheCreationInputPerMillion: 1, cachedInputPerMillion: 0.08, outputPerMillion: 4 }
 };
 function loadPricingTable(pricingPath) {
   if (!pricingPath) {
@@ -248,16 +263,45 @@ function calculateCostUsd(usage, pricing) {
   if (!usage.model) {
     return void 0;
   }
-  const modelPricing = pricing[usage.model] ?? pricing[usage.model.toLowerCase()];
+  const modelPricing = findModelPricing(usage.model, pricing);
   if (!modelPricing) {
     return void 0;
   }
-  const billableInput = Math.max(usage.inputTokens - usage.cachedInputTokens, 0);
+  const cacheCreationInput = usage.cacheCreationInputTokens ?? 0;
+  const billableInput = Math.max(usage.inputTokens - usage.cachedInputTokens - cacheCreationInput, 0);
   const cachedRate = modelPricing.cachedInputPerMillion ?? modelPricing.inputPerMillion;
+  const cacheCreationRate = modelPricing.cacheCreationInputPerMillion ?? modelPricing.inputPerMillion;
   const reasoningRate = modelPricing.reasoningOutputPerMillion ?? modelPricing.outputPerMillion;
-  const cost = billableInput / 1e6 * modelPricing.inputPerMillion + usage.cachedInputTokens / 1e6 * cachedRate + usage.outputTokens / 1e6 * modelPricing.outputPerMillion + usage.reasoningTokens / 1e6 * reasoningRate;
+  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;
+}
+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 isUsablePricing(pricing) {
+  return typeof pricing?.inputPerMillion === "number" && pricing.inputPerMillion > 0 && typeof pricing.outputPerMillion === "number" && pricing.outputPerMillion > 0;
+}
 
 // packages/core/src/config.ts
 function configPath() {
@@ -763,9 +807,9 @@ function pluralize(noun, value) {
 
 // packages/core/src/dashboard.ts
 function buildDashboardSnapshot(input) {
-  const allSessions = input.sessions.filter((session) => session.totalTokens > 0);
+  const allSessions = input.sessions.filter(isDashboardVisibleSession);
   const filteredSessions = filterUsage(input.sessions, input.filters ?? {});
-  const sessions = filteredSessions.filter((session) => session.totalTokens > 0);
+  const sessions = filteredSessions.filter(isDashboardVisibleSession);
   const summary = summarize(sessions);
   const repos = buildRepoRollups(sessions);
   const sourceApps = groupBySourceApp(sessions);
@@ -796,6 +840,9 @@ function buildDashboardSnapshot(input) {
     health: buildUsageHealth({ sessions, summary, repos, sourceApps, scan })
   };
 }
+function isDashboardVisibleSession(session) {
+  return session.totalTokens > 0 || session.sourceClient === "claude";
+}
 
 // packages/core/src/repo.ts
 import fs3 from "node:fs";
@@ -943,30 +990,30 @@ function applyActionMetadata(analysis, record) {
 }
 function finalizeCommandIssues(analysis, totalTokens) {
   const repeatedCommands = /* @__PURE__ */ new Map();
-  const repeatableIssues = analysis.commandIssues.filter((issue) => issue.classification !== "harmless_nonzero" && issue.classification !== "exploratory_miss");
-  for (const issue of repeatableIssues) {
-    repeatedCommands.set(issue.command, (repeatedCommands.get(issue.command) ?? 0) + 1);
+  const repeatableIssues = analysis.commandIssues.filter((issue2) => issue2.classification !== "harmless_nonzero" && issue2.classification !== "exploratory_miss");
+  for (const issue2 of repeatableIssues) {
+    repeatedCommands.set(issue2.command, (repeatedCommands.get(issue2.command) ?? 0) + 1);
   }
   const repeatedFailures = [...repeatedCommands.entries()].filter(([, count2]) => count2 >= 3);
   if (repeatedFailures.length > 0) {
     analysis.repeatedFailureClusters = repeatedFailures.length;
-    for (const issue of analysis.commandIssues) {
-      if (repeatedCommands.get(issue.command) >= 3 && issue.classification !== "harmless_nonzero" && issue.classification !== "exploratory_miss") {
-        issue.classification = "blocking_failure";
-        issue.severity = "critical";
-        issue.impact = "high";
+    for (const issue2 of analysis.commandIssues) {
+      if (repeatedCommands.get(issue2.command) >= 3 && issue2.classification !== "harmless_nonzero" && issue2.classification !== "exploratory_miss") {
+        issue2.classification = "blocking_failure";
+        issue2.severity = "critical";
+        issue2.impact = "high";
       }
     }
   }
   if (totalTokens >= 1e6 && analysis.commandIssues.length >= 5) {
-    for (const issue of analysis.commandIssues) {
-      if (issue.severity === "warning") issue.impact = "high";
+    for (const issue2 of analysis.commandIssues) {
+      if (issue2.severity === "warning") issue2.impact = "high";
     }
   }
   analysis.nonZeroCommandEvents = analysis.commandIssues.length;
-  analysis.importantCommandFailures = analysis.commandIssues.filter((issue) => issue.severity === "critical" || issue.severity === "warning").length;
-  analysis.harmlessNonZeroEvents = analysis.commandIssues.filter((issue) => issue.classification === "harmless_nonzero").length;
-  analysis.exploratoryMisses = analysis.commandIssues.filter((issue) => issue.classification === "exploratory_miss").length;
+  analysis.importantCommandFailures = analysis.commandIssues.filter((issue2) => issue2.severity === "critical" || issue2.severity === "warning").length;
+  analysis.harmlessNonZeroEvents = analysis.commandIssues.filter((issue2) => issue2.classification === "harmless_nonzero").length;
+  analysis.exploratoryMisses = analysis.commandIssues.filter((issue2) => issue2.classification === "exploratory_miss").length;
   analysis.failedToolCallCount = analysis.importantCommandFailures;
   analysis.commandIssueSeverity = strongestSeverity(analysis.commandIssues);
   analysis.commandIssueImpact = strongestImpact(analysis.commandIssues);
@@ -974,21 +1021,21 @@ function finalizeCommandIssues(analysis, totalTokens) {
   analysis.commandIssueSamples = sampledCommandIssues(analysis.commandIssues);
 }
 function sampledCommandIssues(issues) {
-  return [...issues].sort((a, b) => issuePriority(b) - issuePriority(a)).slice(0, 12).map((issue) => ({
-    ...issue,
-    reason: commandIssueReason(issue)
+  return [...issues].sort((a, b) => issuePriority(b) - issuePriority(a)).slice(0, 12).map((issue2) => ({
+    ...issue2,
+    reason: commandIssueReason(issue2)
   }));
 }
-function issuePriority(issue) {
-  const severityScore = issue.severity === "critical" ? 4 : issue.severity === "warning" ? 3 : issue.severity === "info" ? 2 : issue.severity === "ignored" ? 1 : 0;
-  const impactScore = issue.impact === "high" ? 3 : issue.impact === "medium" ? 2 : issue.impact === "low" ? 1 : 0;
+function issuePriority(issue2) {
+  const severityScore = issue2.severity === "critical" ? 4 : issue2.severity === "warning" ? 3 : issue2.severity === "info" ? 2 : issue2.severity === "ignored" ? 1 : 0;
+  const impactScore = issue2.impact === "high" ? 3 : issue2.impact === "medium" ? 2 : issue2.impact === "low" ? 1 : 0;
   return severityScore * 10 + impactScore;
 }
-function commandIssueReason(issue) {
-  if (issue.severity === "critical") return "Repeated or blocking command issue that may have stopped progress.";
-  if (issue.severity === "warning") return "Non-zero command event classified as important for this session.";
-  if (issue.classification === "exploratory_miss") return "Likely exploratory command that found no result.";
-  if (issue.classification === "harmless_nonzero") return "Likely harmless non-zero exit during normal shell exploration.";
+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.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) {
@@ -997,7 +1044,7 @@ function classifyCommandIssue(record, previousIssues) {
   const command2 = extractCommandText(record) ?? compactCommandText(raw);
   const category = commandCategory(text);
   const commandKey = normalizeCommand(command2);
-  const repeated = previousIssues.filter((issue) => issue.command === commandKey).length + 1 >= 3;
+  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" };
   }
@@ -1042,23 +1089,23 @@ function importantImpact(category) {
   return category === "install" || category === "build" || category === "test" || category === "typecheck" || category === "deploy" ? "high" : "medium";
 }
 function strongestSeverity(issues) {
-  if (issues.some((issue) => issue.severity === "critical")) return "critical";
-  if (issues.some((issue) => issue.severity === "warning")) return "warning";
-  if (issues.some((issue) => issue.severity === "info")) return "info";
-  if (issues.some((issue) => issue.severity === "ignored")) return "ignored";
+  if (issues.some((issue2) => issue2.severity === "critical")) return "critical";
+  if (issues.some((issue2) => issue2.severity === "warning")) return "warning";
+  if (issues.some((issue2) => issue2.severity === "info")) return "info";
+  if (issues.some((issue2) => issue2.severity === "ignored")) return "ignored";
   return "none";
 }
 function strongestImpact(issues) {
-  if (issues.some((issue) => issue.impact === "high")) return "high";
-  if (issues.some((issue) => issue.impact === "medium")) return "medium";
-  if (issues.some((issue) => issue.impact === "low")) return "low";
+  if (issues.some((issue2) => issue2.impact === "high")) return "high";
+  if (issues.some((issue2) => issue2.impact === "medium")) return "medium";
+  if (issues.some((issue2) => issue2.impact === "low")) return "low";
   return "none";
 }
 function topFailureType(issues) {
-  const important = issues.filter((issue) => issue.severity === "critical" || issue.severity === "warning");
+  const important = issues.filter((issue2) => issue2.severity === "critical" || issue2.severity === "warning");
   const source = important.length ? important : issues;
   const counts = /* @__PURE__ */ new Map();
-  for (const issue of source) counts.set(issue.category === "unknown" ? issue.classification : issue.category, (counts.get(issue.category === "unknown" ? issue.classification : issue.category) ?? 0) + 1);
+  for (const issue2 of source) counts.set(issue2.category === "unknown" ? issue2.classification : issue2.category, (counts.get(issue2.category === "unknown" ? issue2.classification : issue2.category) ?? 0) + 1);
   return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
 }
 function extractCommandText(record) {
@@ -1256,6 +1303,9 @@ function scanCodex(options) {
     },
     sessions,
     stats: {
+      sourceId: "codex",
+      sourceLabel: "Codex",
+      homePath: codexHome,
       codexHome,
       statePath,
       sessionsPath,
@@ -1303,7 +1353,7 @@ function threadToUsage(row, index, sessionFiles, options) {
   const cachedInputTokens = sessionBreakdown.cachedInputTokens;
   const outputTokens = sessionBreakdown.outputTokens;
   const reasoningTokens = sessionBreakdown.reasoningTokens;
-  const totalTokens = sessionBreakdown.totalTokens || dbTokens || inputTokens + cachedInputTokens + outputTokens + reasoningTokens;
+  const totalTokens = sessionBreakdown.totalTokens || dbTokens || inputTokens + outputTokens + reasoningTokens;
   const hasPricedBreakdown = inputTokens + cachedInputTokens + outputTokens + reasoningTokens > 0;
   const warnings = [...repo.warnings, ...sessionBreakdown.warnings];
   const threadSource = stringValue2(row.thread_source) ?? sessionBreakdown.threadSource;
@@ -1676,12 +1726,12 @@ function stringValue2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function codexSourceAppLabel(source, threadSource) {
-  if (threadSource === "subagent") return "Codex subagent";
+  if (threadSource === "subagent") return "Codex app";
   if (!source) return "Codex";
   if (source === "vscode" || source === "codex_vscode" || source === "codex-vscode") return "VS Code";
   if (source === "cli" || source === "terminal" || source === "codex-tui") return "Terminal";
   if (source === "codex_app" || source === "codex-app") return "Codex app";
-  if (source.trim().startsWith("{")) return threadSource === "subagent" ? "Codex subagent" : "Codex";
+  if (source.trim().startsWith("{")) return threadSource === "subagent" ? "Codex app" : "Codex";
   return source.replace(/^codex[_-]/, "").split(/[_-]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 function dateValue(value) {
@@ -1704,8 +1754,476 @@ function errorMessage(error) {
   return message;
 }
 
-// apps/server/src/data.ts
+// packages/core/src/sources/claude.ts
 import fs5 from "node:fs";
+import os3 from "node:os";
+import path5 from "node:path";
+function scanClaude(options) {
+  const claudeHome = options.claudeHome ?? defaultClaudeHome();
+  const historyPath = path5.join(claudeHome, "history.jsonl");
+  const warnings = [];
+  const discovery = discoverClaudeSessionFiles(claudeHome, warnings, Boolean(options.claudeHome));
+  const historyExists = fs5.existsSync(historyPath);
+  const sessions = discovery.files.map((file, index) => claudeFileToUsage(file, index, options));
+  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))) {
+    warnings.push(`Claude Code projects directory not found at ${projectsPath}`);
+  }
+  return {
+    source: {
+      id: "claude",
+      label: "Claude Code",
+      available: discovery.files.length > 0 || historyExists,
+      paths: unique3([...discovery.projectsPaths, historyPath, ...discovery.desktopSessionRoots]),
+      warnings
+    },
+    sessions,
+    stats: {
+      sourceId: "claude",
+      sourceLabel: "Claude Code",
+      homePath: claudeHome,
+      claudeHome,
+      projectsPath,
+      historyPath,
+      projectsExists: discovery.projectsPaths.some((candidate) => fs5.existsSync(candidate)),
+      historyExists,
+      sessionFileCount: discovery.files.length,
+      projectDirCount: discovery.projectDirs.size,
+      sessionsImported: sessions.length,
+      parseFailureCount,
+      unreadableFileCount,
+      malformedFileCount,
+      historyEntryCount,
+      lastScannedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+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")]);
+  for (const projectsPath of projectsPaths) {
+    collectProjectFiles(projectsPath, files, projectDirs, warnings);
+  }
+  const desktopSessionRoots = explicitHome ? [] : defaultDesktopSessionRoots();
+  for (const root of desktopSessionRoots) {
+    collectDesktopSessionFiles(root, files, projectDirs, warnings);
+  }
+  return {
+    files: uniqueSessionFiles(files),
+    projectDirs,
+    projectsPaths,
+    desktopSessionRoots
+  };
+}
+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 [primaryHome];
+}
+function collectProjectFiles(projectsPath, files, projectDirs, warnings) {
+  if (!fs5.existsSync(projectsPath)) return;
+  try {
+    for (const entry of fs5.readdirSync(projectsPath, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const projectDir = path5.join(projectsPath, entry.name);
+      projectDirs.add(projectDir);
+      walk2(projectDir, 5, (filePath) => {
+        if (filePath.endsWith(".jsonl")) files.push({ filePath, projectDir, projectsPath });
+      });
+    }
+  } catch (error) {
+    warnings.push(`Unable to read Claude Code projects at ${projectsPath}: ${errorMessage2(error)}`);
+  }
+}
+function collectDesktopSessionFiles(root, files, projectDirs, warnings) {
+  if (!fs5.existsSync(root)) return;
+  try {
+    walk2(root, 8, (filePath) => {
+      if (!filePath.endsWith(".jsonl")) return;
+      const parts = filePath.split(path5.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);
+      projectDirs.add(projectDir);
+      files.push({ filePath, projectDir, projectsPath });
+    });
+  } catch (error) {
+    warnings.push(`Unable to read Claude Code desktop sessions at ${root}: ${errorMessage2(error)}`);
+  }
+}
+function walk2(root, maxDepth, onFile, depth = 0) {
+  if (depth > maxDepth) return;
+  for (const entry of fs5.readdirSync(root, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const fullPath = path5.join(root, entry.name);
+    if (entry.isDirectory()) {
+      walk2(fullPath, maxDepth, onFile, depth + 1);
+    } else if (entry.isFile()) {
+      onFile(fullPath);
+    }
+  }
+}
+function claudeFileToUsage(file, index, options) {
+  const breakdown = readClaudeBreakdown(file.filePath);
+  const id = breakdown.id ?? (path5.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];
+  if (!breakdown.cwd) warnings.push("repo_inferred_from_claude_project_dir");
+  const hasTokenBreakdown = breakdown.totalTokens > 0 && breakdown.usageCount > 0;
+  const usage = {
+    id,
+    sourceClient: "claude",
+    sourceApp: claudeSourceAppLabel(breakdown.entrypoint),
+    sourceAppRaw: breakdown.entrypoint,
+    sourcePath: file.filePath,
+    repoRoot: repo.repoRoot,
+    repoName: repo.repoName,
+    cwd,
+    gitRemoteUrl: repo.gitRemoteUrl,
+    gitBranch: repo.gitBranch ?? breakdown.gitBranch,
+    title: breakdown.title,
+    startedAt: breakdown.startedAt,
+    endedAt: breakdown.endedAt,
+    model: breakdown.model,
+    provider: "anthropic",
+    inputTokens: breakdown.inputTokens,
+    cachedInputTokens: breakdown.cachedInputTokens,
+    cacheCreationInputTokens: breakdown.cacheCreationInputTokens,
+    outputTokens: breakdown.outputTokens,
+    reasoningTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: breakdown.totalTokens,
+    tokenAggregationMethod: hasTokenBreakdown ? "direct_usage" : "unknown",
+    tokenConfidence: hasTokenBreakdown ? "high" : "low",
+    tokenSnapshotCount: breakdown.usageCount,
+    estimatedCostUsd: void 0,
+    messageCount: breakdown.messageCount,
+    rawTokenTotal: hasTokenBreakdown ? breakdown.totalTokens : void 0,
+    warnings: hasTokenBreakdown ? warnings : [...warnings, "missing_token_breakdown"],
+    durationMs: durationMs2(breakdown.startedAt, breakdown.endedAt),
+    rawEventCount: breakdown.rawEventCount,
+    parseStatus: breakdown.parseStatus,
+    parseErrors: breakdown.parseErrors,
+    detectedSurface: claudeSurface(breakdown.entrypoint),
+    surfaceConfidence: "medium",
+    surfaceReason: breakdown.entrypoint ? `Claude Code entrypoint: ${breakdown.entrypoint}` : "Claude Code transcript",
+    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,
+    promptTimeline: breakdown.promptTimeline,
+    sessionOutcome: inferOutcome2(breakdown)
+  };
+  const cost = hasTokenBreakdown ? calculateCostUsd(usage, options.pricing) : void 0;
+  return {
+    ...usage,
+    estimatedCostUsd: cost,
+    warnings: cost === void 0 ? [...usage.warnings, "unknown_pricing"] : usage.warnings
+  };
+}
+function readClaudeBreakdown(filePath) {
+  const breakdown = emptyBreakdown2();
+  try {
+    const text = fs5.readFileSync(filePath, "utf8");
+    const parse = parseJsonLines2(text);
+    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) {
+      applyClaudeRecord(breakdown, record);
+    }
+    breakdown.totalTokens = breakdown.inputTokens + breakdown.outputTokens;
+  } catch (error) {
+    const message = `unable_to_read_session_file:${errorMessage2(error)}`;
+    breakdown.parseStatus = "failed";
+    breakdown.parseErrors.push(message);
+    breakdown.warnings.push(message);
+  }
+  return breakdown;
+}
+function applyClaudeRecord(breakdown, record) {
+  const timestamp3 = dateValue2(record.timestamp);
+  if (timestamp3) {
+    breakdown.startedAt = minDate(breakdown.startedAt, timestamp3);
+    breakdown.endedAt = maxDate(breakdown.endedAt, timestamp3);
+  }
+  breakdown.id ??= stringValue3(record.sessionId);
+  breakdown.cwd ??= stringValue3(record.cwd);
+  breakdown.gitBranch ??= stringValue3(record.gitBranch);
+  breakdown.entrypoint ??= stringValue3(record.entrypoint);
+  breakdown.version ??= stringValue3(record.version);
+  breakdown.title ??= stringValue3(record.aiTitle);
+  const message = firstObject4(record.message);
+  const role = stringValue3(message?.role) ?? stringValue3(record.type);
+  if (role === "user") breakdown.userPromptCount += 1;
+  if (role === "assistant") breakdown.assistantMessageCount += 1;
+  if (role === "user" || role === "assistant") breakdown.messageCount += 1;
+  if (message) {
+    applyPromptTimeline2(breakdown, role, message.content, timestamp3);
+    const usage = firstObject4(message.usage);
+    const usageTokens = usage ? usageTotal(usage) : 0;
+    const model = normalizeClaudeModel(message.model);
+    if (model && (usageTokens > 0 || !breakdown.model)) breakdown.model = model;
+    if (usage && usageTokens > 0) applyUsage(breakdown, usage);
+    applyContentSignals(breakdown, message.content);
+  }
+  if (looksFailedToolResult(record.toolUseResult)) breakdown.failedToolCallCount += 1;
+}
+function applyUsage(breakdown, usage) {
+  const input = numberValue(usage.input_tokens);
+  const cacheRead = numberValue(usage.cache_read_input_tokens);
+  const cacheCreation = numberValue(usage.cache_creation_input_tokens);
+  const output = numberValue(usage.output_tokens);
+  breakdown.inputTokens += input + cacheRead + cacheCreation;
+  breakdown.cachedInputTokens += cacheRead;
+  breakdown.cacheCreationInputTokens += cacheCreation;
+  breakdown.outputTokens += output;
+  breakdown.usageCount += 1;
+}
+function usageTotal(usage) {
+  return numberValue(usage.input_tokens) + numberValue(usage.cache_read_input_tokens) + numberValue(usage.cache_creation_input_tokens) + numberValue(usage.output_tokens);
+}
+function applyContentSignals(breakdown, content) {
+  if (!Array.isArray(content)) return;
+  for (const item of content) {
+    const object = firstObject4(item);
+    if (!object || object.type !== "tool_use") continue;
+    breakdown.toolCallCount += 1;
+    const name = stringValue3(object.name)?.toLowerCase() ?? "";
+    if (name === "bash") breakdown.shellCommandCount += 1;
+    if (name === "read") breakdown.fileReadCount += 1;
+    if (["edit", "multiedit", "write", "notebookedit"].includes(name)) breakdown.fileEditCount += 1;
+  }
+}
+function parseJsonLines2(text) {
+  const records = [];
+  const errors = [];
+  text.split(/\r?\n/).map((line, index) => ({ line: line.trim(), index })).filter(({ line }) => Boolean(line)).forEach(({ line, index }) => {
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        records.push(parsed);
+      }
+    } catch (error) {
+      errors.push(`jsonl_line_${index + 1}:${errorMessage2(error)}`);
+    }
+  });
+  return { records, errors };
+}
+function emptyBreakdown2() {
+  return {
+    id: void 0,
+    title: void 0,
+    cwd: void 0,
+    gitBranch: void 0,
+    entrypoint: void 0,
+    version: void 0,
+    startedAt: void 0,
+    endedAt: void 0,
+    model: void 0,
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 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: []
+  };
+}
+function applyPromptTimeline2(breakdown, role, content, timestamp3) {
+  if (breakdown.promptTimeline.length >= 80 || role !== "user" && role !== "assistant") return;
+  const text = extractClaudeMessageText(content);
+  if (!text) return;
+  breakdown.promptTimeline.push({
+    role,
+    text: normalizeTimelineText2(text),
+    timestamp: timestamp3
+  });
+}
+function extractClaudeMessageText(content) {
+  if (typeof content === "string" && content.trim()) return content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = content.flatMap((item) => {
+    if (typeof item === "string") return [item];
+    const object = firstObject4(item);
+    if (!object || object.type !== "text") return [];
+    const text = stringValue3(object.text);
+    return text ? [text] : [];
+  }).filter((item) => item.trim());
+  return parts.length ? parts.join("\n") : void 0;
+}
+function normalizeTimelineText2(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 1e3);
+}
+function inferProjectPath(projectDir, projectsPath) {
+  const name = path5.basename(projectDir);
+  if (name.startsWith("-")) {
+    return `${path5.sep}${name.slice(1).split("-").filter(Boolean).join(path5.sep)}`;
+  }
+  const relative = path5.relative(projectsPath, projectDir);
+  return relative && !relative.startsWith("..") ? path5.join(projectsPath, relative) : projectDir;
+}
+function inferOutcome2(breakdown) {
+  if (breakdown.parseStatus === "failed") return "failed";
+  if (breakdown.failedToolCallCount > 0) return "partial";
+  if (breakdown.fileEditCount > 0) return "completed";
+  if (breakdown.shellCommandCount > 0) return "setup_debugging";
+  if (breakdown.userPromptCount > 0 || breakdown.assistantMessageCount > 0) return "research_only";
+  return "unknown";
+}
+function claudeSurface(entrypoint) {
+  const value = entrypoint?.toLowerCase() ?? "";
+  if (value.includes("vscode")) return "vscode_extension";
+  if (value.includes("local-agent")) return "local_agent";
+  return "terminal_cli";
+}
+function claudeSourceAppLabel(entrypoint) {
+  const value = entrypoint?.toLowerCase() ?? "";
+  if (value.includes("vscode")) return "VS Code";
+  if (value.includes("local-agent")) return "Claude desktop local agent";
+  if (value === "cli" || value.includes("terminal")) return "Terminal";
+  return "Claude Code";
+}
+function defaultClaudeHome() {
+  return process.env.CLAUDE_CONFIG_DIR?.split(",").map((item) => item.trim()).filter(Boolean)[0] ?? path5.join(os3.homedir(), ".claude");
+}
+function defaultDesktopSessionRoots() {
+  const home = os3.homedir();
+  const xdg = process.env.XDG_CONFIG_HOME || path5.join(home, ".config");
+  return [
+    path5.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
+    path5.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);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function unique3(values) {
+  return [...new Set(values)];
+}
+function countHistoryEntries(historyPath) {
+  if (!fs5.existsSync(historyPath)) return 0;
+  let entryCount = 0;
+  try {
+    for (const line of fs5.readFileSync(historyPath, "utf8").split(/\r?\n/).filter(Boolean)) {
+      try {
+        JSON.parse(line);
+        entryCount += 1;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return entryCount;
+  }
+  return entryCount;
+}
+function firstObject4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringValue3(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && Number.isFinite(Number(value))) return Number(value);
+  return 0;
+}
+function normalizeClaudeModel(value) {
+  const model = stringValue3(value);
+  if (!model || model === "<synthetic>") return void 0;
+  return model;
+}
+function dateValue2(value) {
+  if (typeof value !== "string") return void 0;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function minDate(current, candidate) {
+  return !current || candidate < current ? candidate : current;
+}
+function maxDate(current, candidate) {
+  return !current || candidate > current ? candidate : current;
+}
+function durationMs2(startedAt, endedAt) {
+  if (!startedAt || !endedAt) return void 0;
+  const start = new Date(startedAt).getTime();
+  const end = new Date(endedAt).getTime();
+  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : void 0;
+}
+function looksFailedToolResult(value) {
+  const object = firstObject4(value);
+  if (!object) return false;
+  if (object.is_error === true || object.error === true) return true;
+  const exitCode = numberValue(object.exit_code ?? object.exitCode ?? object.status_code ?? object.statusCode);
+  if (exitCode !== 0) return true;
+  const status = stringValue3(object.status)?.toLowerCase();
+  return status === "failed" || status === "error";
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// packages/core/src/sources/index.ts
+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
+  });
+  return {
+    sources: [codex.source, claude.source],
+    sourceStats: [codex.stats, claude.stats],
+    sessions: [...codex.sessions, ...claude.sessions]
+  };
+}
+
+// apps/server/src/data.ts
+import fs6 from "node:fs";
 var scanCacheTtlMs = 1e4;
 var scanCache;
 function readDashboardData(filters = {}) {
@@ -1722,11 +2240,11 @@ function readRawUsageData() {
   }
   const { config, warnings: configWarnings } = loadConfigWithWarnings();
   const pricing = loadPricingTable(resolvePricingPath(config));
-  const codex = scanCodex({ config, pricing });
+  const scan = scanUsageSources({ config, pricing });
   const data = {
-    sources: [{ ...codex.source, warnings: [...codex.source.warnings, ...configWarnings] }],
-    sourceStats: [codex.stats],
-    sessions: codex.sessions
+    sources: scan.sources.map((source) => ({ ...source, warnings: [...source.warnings, ...configWarnings] })),
+    sourceStats: scan.sourceStats,
+    sessions: scan.sessions
   };
   scanCache = { cwd, data, expiresAt: Date.now() + scanCacheTtlMs };
   return data;
@@ -1767,8 +2285,8 @@ function writePricingData(models) {
 }
 function clearRepoSpendLocalData() {
   const target = repospendHome();
-  const removed = fs5.existsSync(target);
-  fs5.rmSync(target, { recursive: true, force: true });
+  const removed = fs6.existsSync(target);
+  fs6.rmSync(target, { recursive: true, force: true });
   clearScanCache();
   return { path: target, removed };
 }
@@ -1791,12 +2309,621 @@ function runtimeCwd() {
 }
 
 // apps/server/src/server.ts
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 import { fileURLToPath } from "node:url";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
 
+// apps/server/src/demo-data.ts
+var baseDate = "2026-05-18";
+var demoPricing = {
+  ...defaultPricing,
+  "gpt-5.3-codex": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14 },
+  "gpt-5.3-codex-spark": { inputPerMillion: 0.75, cachedInputPerMillion: 0.075, outputPerMillion: 4.5, reasoningOutputPerMillion: 4.5 },
+  "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 = {}) {
+  return buildDashboardSnapshot({
+    sources: demoSources,
+    sourceStats: demoSourceStats,
+    sessions: demoSessions,
+    filters
+  });
+}
+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
+  };
+}
+var demoSources = [
+  {
+    id: "codex",
+    label: "Codex",
+    available: true,
+    paths: ["/demo/middle-earth/codex/state.sqlite", "/demo/middle-earth/codex/sessions"],
+    warnings: []
+  },
+  {
+    id: "claude",
+    label: "Claude Code",
+    available: true,
+    paths: ["/demo/middle-earth/claude/projects"],
+    warnings: []
+  }
+];
+var demoSourceStats = [
+  {
+    sourceId: "codex",
+    sourceLabel: "Codex",
+    homePath: "/demo/middle-earth/codex",
+    statePath: "/demo/middle-earth/codex/state.sqlite",
+    sessionsPath: "/demo/middle-earth/codex/sessions",
+    stateExists: true,
+    sessionsExists: true,
+    sessionFileCount: 15,
+    sessionsImported: 15,
+    parseFailureCount: 0,
+    unreadableFileCount: 0,
+    malformedFileCount: 0,
+    lastScannedAt: "2026-05-18T19:00:00.000Z"
+  },
+  {
+    sourceId: "claude",
+    sourceLabel: "Claude Code",
+    homePath: "/demo/middle-earth/claude",
+    projectsPath: "/demo/middle-earth/claude/projects",
+    projectsExists: true,
+    sessionFileCount: 7,
+    sessionsImported: 7,
+    parseFailureCount: 0,
+    unreadableFileCount: 0,
+    malformedFileCount: 0,
+    projectDirCount: 4,
+    lastScannedAt: "2026-05-18T19:01:00.000Z"
+  }
+];
+var demoInputs = [
+  {
+    id: "lotr-session-001",
+    repo: "one-ring-infra",
+    title: "Why is one-ring-infra spending 3x more than shire-mobile?",
+    sourceClient: "codex",
+    sourceApp: "Codex app",
+    model: "GPT-5.5",
+    provider: "openai",
+    hour: 9,
+    minute: 10,
+    durationMinutes: 84,
+    inputTokens: 285e4,
+    cachedInputTokens: 32e4,
+    outputTokens: 41e4,
+    reasoningTokens: 26e4,
+    prompts: 9,
+    replies: 18,
+    tools: 86,
+    commands: 34,
+    edits: 3,
+    reads: 92,
+    outcome: "completed",
+    branch: "audit/token-fire",
+    importantFailures: 2,
+    harmlessNonZero: 4,
+    repeatedClusters: 1,
+    topFailureType: "test",
+    warnings: ["repeated_error:test-suite"],
+    issueSamples: [
+      issue("pnpm test --filter one-ring-infra", "test", "warning", "medium", "Repeated failing shard while auditing token spend."),
+      issue("terraform plan -var region=mordor", "deploy", "critical", "high", "Infrastructure plan failed before the safer dry-run path was found.")
+    ]
+  },
+  {
+    id: "lotr-session-002",
+    repo: "mordor-ci",
+    title: "Reduce token burn in mordor-ci",
+    sourceClient: "codex",
+    sourceApp: "Codex app",
+    model: "GPT-5.4",
+    provider: "openai",
+    hour: 10,
+    minute: 35,
+    durationMinutes: 62,
+    inputTokens: 178e4,
+    cachedInputTokens: 95e3,
+    outputTokens: 28e4,
+    reasoningTokens: 185e3,
+    prompts: 7,
+    replies: 12,
+    tools: 58,
+    commands: 28,
+    edits: 2,
+    reads: 51,
+    outcome: "partial",
+    branch: "ci/doom-cache",
+    importantFailures: 3,
+    harmlessNonZero: 1,
+    repeatedClusters: 2,
+    topFailureType: "build",
+    warnings: ["low_cache_rate"],
+    issueSamples: [
+      issue("pnpm build --filter mordor-ci", "build", "critical", "high", "Build failed repeatedly after the Mount Doom runner image changed.")
+    ]
+  },
+  {
+    id: "lotr-session-003",
+    repo: "shire-mobile",
+    title: "Investigate token spike after second breakfast",
+    sourceClient: "claude",
+    sourceApp: "Claude Code",
+    sourceAppRaw: "claude-code",
+    model: "claude-opus-4-7",
+    provider: "anthropic",
+    hour: 11,
+    minute: 5,
+    durationMinutes: 46,
+    inputTokens: 142e4,
+    cachedInputTokens: 21e4,
+    outputTokens: 185e3,
+    reasoningTokens: 0,
+    prompts: 5,
+    replies: 9,
+    tools: 31,
+    commands: 12,
+    edits: 0,
+    reads: 44,
+    outcome: "research_only",
+    branch: "analytics/second-breakfast",
+    warnings: [],
+    detectedSurface: "terminal_cli",
+    tokenConfidence: "high"
+  },
+  {
+    id: "lotr-session-004",
+    repo: "palantir-observability",
+    title: "Fix race condition in the palantir event stream",
+    sourceClient: "codex",
+    sourceApp: "VS Code",
+    sourceAppRaw: "vscode",
+    model: "GPT-5.4",
+    provider: "openai",
+    hour: 12,
+    minute: 20,
+    durationMinutes: 73,
+    inputTokens: 126e4,
+    cachedInputTokens: 455e3,
+    outputTokens: 21e4,
+    reasoningTokens: 17e4,
+    prompts: 6,
+    replies: 14,
+    tools: 64,
+    commands: 24,
+    edits: 6,
+    reads: 66,
+    outcome: "completed",
+    branch: "stream/palantir-race",
+    importantFailures: 1,
+    harmlessNonZero: 3,
+    topFailureType: "test",
+    issueSamples: [
+      issue("pnpm test palantir-stream.spec.ts", "test", "warning", "medium", "One flaky stream-order assertion needed a deterministic clock.")
+    ]
+  },
+  {
+    id: "lotr-session-005",
+    repo: "gondor-api",
+    title: "Add auth flow for gates-of-moria",
+    sourceClient: "codex",
+    sourceApp: "Codex app",
+    model: "GPT-5.4-Mini",
+    provider: "openai",
+    hour: 13,
+    minute: 0,
+    durationMinutes: 58,
+    inputTokens: 86e4,
+    cachedInputTokens: 28e4,
+    outputTokens: 13e4,
+    reasoningTokens: 74e3,
+    prompts: 5,
+    replies: 10,
+    tools: 42,
+    commands: 18,
+    edits: 8,
+    reads: 39,
+    outcome: "completed",
+    branch: "auth/mellon"
+  },
+  {
+    id: "lotr-session-006",
+    repo: "rivendell-dashboard",
+    title: "Refactor the council-of-elrond planner",
+    sourceClient: "claude",
+    sourceApp: "Claude desktop local agent",
+    sourceAppRaw: "claude-desktop-local-agent",
+    model: "claude-sonnet-4-6",
+    provider: "anthropic",
+    hour: 14,
+    minute: 15,
+    durationMinutes: 67,
+    inputTokens: 92e4,
+    cachedInputTokens: 36e4,
+    outputTokens: 15e4,
+    reasoningTokens: 0,
+    prompts: 6,
+    replies: 11,
+    tools: 37,
+    commands: 15,
+    edits: 7,
+    reads: 48,
+    outcome: "completed",
+    branch: "planner/elrond-v2"
+  },
+  {
+    id: "lotr-session-007",
+    repo: "palantir-observability",
+    title: "Optimize observability for eye-of-sauron alerts",
+    sourceClient: "codex",
+    sourceApp: "Codex app",
+    model: "GPT-5.3-Codex",
+    provider: "openai",
+    hour: 15,
+    minute: 40,
+    durationMinutes: 51,
+    inputTokens: 74e4,
+    cachedInputTokens: 29e4,
+    outputTokens: 96e3,
+    reasoningTokens: 88e3,
+    prompts: 4,
+    replies: 8,
+    tools: 44,
+    commands: 17,
+    edits: 5,
+    reads: 36,
+    outcome: "completed",
+    branch: "alerts/eye-slo",
+    harmlessNonZero: 2,
+    exploratoryMisses: 3
+  },
+  {
+    id: "lotr-session-008",
+    repo: "mordor-ci",
+    title: "Clean up dead code in orc-deployment-worker",
+    sourceClient: "codex",
+    sourceApp: "Terminal",
+    sourceAppRaw: "terminal",
+    model: "GPT-5.3-Codex-Spark",
+    provider: "openai",
+    hour: 16,
+    minute: 10,
+    durationMinutes: 39,
+    inputTokens: 54e4,
+    cachedInputTokens: 18e4,
+    outputTokens: 84e3,
+    reasoningTokens: 64e3,
+    prompts: 3,
+    replies: 7,
+    tools: 35,
+    commands: 14,
+    edits: 9,
+    reads: 31,
+    outcome: "completed",
+    branch: "workers/orc-cleanup",
+    detectedSurface: "terminal_cli"
+  },
+  {
+    id: "lotr-session-009",
+    repo: "minas-tirith-admin",
+    title: "Tighten city-gate roles before the beacons launch",
+    sourceClient: "claude",
+    sourceApp: "Claude Code",
+    sourceAppRaw: "claude-code",
+    model: "claude-haiku-4-5-20251001",
+    provider: "anthropic",
+    hour: 17,
+    minute: 5,
+    durationMinutes: 32,
+    inputTokens: 39e4,
+    cachedInputTokens: 12e4,
+    outputTokens: 61e3,
+    reasoningTokens: 0,
+    prompts: 4,
+    replies: 6,
+    tools: 25,
+    commands: 9,
+    edits: 5,
+    reads: 23,
+    outcome: "completed",
+    branch: "rbac/beacons"
+  },
+  {
+    id: "lotr-session-010",
+    repo: "fellowship-docs",
+    title: "Document why nobody should commit the ring config",
+    sourceClient: "codex",
+    sourceApp: "Codex app",
+    model: "GPT-5.2",
+    provider: "openai",
+    hour: 18,
+    minute: 25,
+    durationMinutes: 24,
+    inputTokens: 21e4,
+    cachedInputTokens: 75e3,
+    outputTokens: 38e3,
+    reasoningTokens: 22e3,
+    prompts: 2,
+    replies: 5,
+    tools: 18,
+    commands: 6,
+    edits: 4,
+    reads: 16,
+    outcome: "completed",
+    branch: "docs/ring-config"
+  },
+  {
+    id: "lotr-session-011",
+    repo: "one-ring-infra",
+    title: "Cap runaway apply retries in black-gate provisioner",
+    sourceClient: "codex",
+    sourceApp: "Terminal",
+    sourceAppRaw: "terminal",
+    model: "GPT-5.4",
+    provider: "openai",
+    hour: 18,
+    minute: 55,
+    durationMinutes: 44,
+    inputTokens: 98e4,
+    cachedInputTokens: 14e4,
+    outputTokens: 148e3,
+    reasoningTokens: 96e3,
+    prompts: 4,
+    replies: 9,
+    tools: 41,
+    commands: 21,
+    edits: 4,
+    reads: 45,
+    outcome: "completed",
+    branch: "infra/black-gate-retries",
+    importantFailures: 1,
+    harmlessNonZero: 2,
+    topFailureType: "deploy",
+    detectedSurface: "terminal_cli",
+    issueSamples: [
+      issue("terraform apply -auto-approve", "deploy", "critical", "high", "The demo caught a risky retry loop and switched to a dry-run plan.")
+    ]
+  },
+  {
+    id: "lotr-session-012",
+    repo: "rivendell-dashboard",
+    title: "Make elvish table sorting less mysterious",
+    sourceClient: "codex",
+    sourceApp: "VS Code",
+    sourceAppRaw: "vscode",
+    model: "GPT-5.4-Mini",
+    provider: "openai",
+    hour: 19,
+    minute: 20,
+    durationMinutes: 29,
+    inputTokens: 31e4,
+    cachedInputTokens: 13e4,
+    outputTokens: 49e3,
+    reasoningTokens: 35e3,
+    prompts: 3,
+    replies: 6,
+    tools: 22,
+    commands: 8,
+    edits: 3,
+    reads: 18,
+    outcome: "completed",
+    branch: "tables/less-elvish"
+  },
+  {
+    id: "lotr-session-013",
+    repo: "gondor-api",
+    title: "Trim noisy auth logs from white-tree callbacks",
+    sourceClient: "codex",
+    sourceApp: "Codex app",
+    model: "GPT-5.3-Codex",
+    provider: "openai",
+    hour: 20,
+    minute: 5,
+    durationMinutes: 35,
+    inputTokens: 42e4,
+    cachedInputTokens: 16e4,
+    outputTokens: 66e3,
+    reasoningTokens: 54e3,
+    prompts: 3,
+    replies: 6,
+    tools: 28,
+    commands: 11,
+    edits: 4,
+    reads: 27,
+    outcome: "completed",
+    branch: "logs/white-tree"
+  },
+  {
+    id: "lotr-session-014",
+    repo: "shire-mobile",
+    title: "Make pantry sync work offline in Bag End",
+    sourceClient: "claude",
+    sourceApp: "Claude Code",
+    sourceAppRaw: "claude-code",
+    model: "claude-haiku-4-5-20251001",
+    provider: "anthropic",
+    hour: 20,
+    minute: 45,
+    durationMinutes: 28,
+    inputTokens: 26e4,
+    cachedInputTokens: 9e4,
+    outputTokens: 42e3,
+    reasoningTokens: 0,
+    prompts: 3,
+    replies: 5,
+    tools: 19,
+    commands: 7,
+    edits: 5,
+    reads: 17,
+    outcome: "completed",
+    branch: "offline/bag-end"
+  }
+];
+var demoSessions = demoInputs.map(toSession);
+function toSession(input) {
+  const start = timestamp2(input.hour, input.minute);
+  const end = new Date(new Date(start).getTime() + input.durationMinutes * 6e4).toISOString();
+  const repoRoot = `/demo/middle-earth/${input.repo}`;
+  const totalTokens = input.inputTokens + input.outputTokens + input.reasoningTokens;
+  const importantFailures = input.importantFailures ?? 0;
+  const harmlessNonZero = input.harmlessNonZero ?? 0;
+  const exploratoryMisses = input.exploratoryMisses ?? 0;
+  const repeatedClusters = input.repeatedClusters ?? 0;
+  const failedToolCalls = importantFailures + repeatedClusters;
+  const nonZeroCommandEvents = importantFailures + harmlessNonZero + exploratoryMisses;
+  const cost = calculateCostUsd({
+    model: input.model,
+    inputTokens: input.inputTokens,
+    cachedInputTokens: input.cachedInputTokens,
+    outputTokens: input.outputTokens,
+    reasoningTokens: input.reasoningTokens
+  }, demoPricing);
+  return {
+    id: input.id,
+    sourceClient: input.sourceClient,
+    sourceApp: input.sourceApp,
+    sourceAppRaw: input.sourceAppRaw ?? input.sourceApp.toLowerCase(),
+    sourcePath: `/demo/middle-earth/${input.sourceClient}/sessions/${input.id}.jsonl`,
+    repoRoot,
+    repoName: input.repo,
+    cwd: `${repoRoot}/worktree`,
+    gitRemoteUrl: `https://example.invalid/middle-earth/${input.repo}.git`,
+    gitBranch: input.branch,
+    title: input.title,
+    startedAt: start,
+    endedAt: end,
+    model: input.model,
+    provider: input.provider,
+    durationMs: input.durationMinutes * 6e4,
+    rawEventCount: input.tools + input.replies + input.prompts + 8,
+    parseStatus: "ok",
+    parseErrors: [],
+    detectedSurface: input.detectedSurface ?? detectedSurfaceForApp(input.sourceApp),
+    surfaceConfidence: "high",
+    surfaceReason: "Demo fixture includes an explicit fictional source app.",
+    promptTimeline: [
+      { role: "user", text: input.title, timestamp: start },
+      { role: "assistant", text: demoReply(input.repo, input.edits, importantFailures), timestamp: timestamp2(input.hour, Math.min(input.minute + 7, 59)) }
+    ],
+    sessionOutcome: input.outcome,
+    inputTokens: input.inputTokens,
+    cachedInputTokens: input.cachedInputTokens,
+    outputTokens: input.outputTokens,
+    reasoningTokens: input.reasoningTokens,
+    reasoningOutputTokens: input.reasoningTokens,
+    totalTokens,
+    tokenAggregationMethod: "direct_usage",
+    tokenConfidence: input.tokenConfidence ?? "high",
+    tokenSnapshotCount: Math.max(2, Math.round(input.durationMinutes / 18)),
+    estimatedCostUsd: cost,
+    messageCount: input.prompts + input.replies,
+    rawTokenTotal: totalTokens,
+    warnings: input.warnings ?? [],
+    userPromptCount: input.prompts,
+    assistantMessageCount: input.replies,
+    toolCallCount: input.tools,
+    shellCommandCount: input.commands,
+    failedToolCallCount: failedToolCalls,
+    nonZeroCommandEvents,
+    importantCommandFailures: importantFailures,
+    harmlessNonZeroEvents: harmlessNonZero,
+    exploratoryMisses,
+    repeatedFailureClusters: repeatedClusters,
+    commandIssueSeverity: importantFailures > 1 ? "critical" : importantFailures > 0 ? "warning" : "none",
+    commandIssueImpact: importantFailures > 1 ? "high" : importantFailures > 0 ? "medium" : "none",
+    topFailureType: input.topFailureType,
+    commandIssueSamples: input.issueSamples ?? [],
+    fileReadCount: input.reads,
+    fileEditCount: input.edits
+  };
+}
+function detectedSurfaceForApp(sourceApp) {
+  if (sourceApp === "VS Code") return "vscode_extension";
+  if (sourceApp === "Terminal") return "terminal_cli";
+  if (sourceApp === "Codex app") return "codex_app_cloud";
+  if (sourceApp === "Claude desktop local agent") return "local_agent";
+  return "terminal_cli";
+}
+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.`;
+  }
+  if (edits === 0) {
+    return `Mapped the spend pattern in ${repo} without changing files, which is exactly the kind of research-only trail RepoSpend should make visible.`;
+  }
+  return `Updated ${repo} with focused changes and enough local checks to make the token spend easy to explain.`;
+}
+
 // apps/server/src/rtk.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -1991,8 +3118,10 @@ function createServer(options = {}) {
   const app = Fastify({ logger: false });
   app.get("/api/health", async () => ({ ok: true, app: "RepoSpend", version: readPackageVersion() }));
   app.get("/api/dashboard", async (request) => {
-    const data = readDashboardData(parseFilters(request.query));
-    const rtkGain = await readRtkGain();
+    const filters = parseFilters(request.query);
+    const demoMode = demoModeEnabled();
+    const data = demoMode ? readDemoDashboardData(filters) : readDashboardData(filters);
+    const rtkGain = demoMode ? readDemoRtkGain() : await readRtkGain();
     return {
       ...data,
       summary: { ...data.summary, skippedZeroTokenSessions: data.skippedZeroTokenSessions },
@@ -2018,9 +3147,9 @@ function createServer(options = {}) {
     return exportCsv();
   });
   if (options.serveWeb !== false) {
-    const serverDist = path5.dirname(fileURLToPath(import.meta.url));
-    const packagedWebDist = path5.resolve(serverDist, "../web-dist");
-    const workspaceWebDist = path5.resolve(serverDist, "../../web/dist");
+    const serverDist = path6.dirname(fileURLToPath(import.meta.url));
+    const packagedWebDist = path6.resolve(serverDist, "../web-dist");
+    const workspaceWebDist = path6.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.`);
@@ -2041,13 +3170,13 @@ function createServer(options = {}) {
   return app;
 }
 function fsExists(inputPath) {
-  return Boolean(inputPath) && path5.isAbsolute(inputPath) && fs6.existsSync(inputPath);
+  return Boolean(inputPath) && path6.isAbsolute(inputPath) && fs7.existsSync(inputPath);
 }
 function readPackageVersion() {
-  const serverDist = path5.dirname(fileURLToPath(import.meta.url));
-  const packagePath = path5.resolve(serverDist, "../package.json");
+  const serverDist = path6.dirname(fileURLToPath(import.meta.url));
+  const packagePath = path6.resolve(serverDist, "../package.json");
   try {
-    const parsed = JSON.parse(fs6.readFileSync(packagePath, "utf8"));
+    const parsed = JSON.parse(fs7.readFileSync(packagePath, "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
@@ -2080,8 +3209,10 @@ function validatePricingBody(body) {
       outputPerMillion
     };
     const cachedInputPerMillion = finiteNumber(row.cachedInputPerMillion);
+    const cacheCreationInputPerMillion = finiteNumber(row.cacheCreationInputPerMillion);
     const reasoningOutputPerMillion = finiteNumber(row.reasoningOutputPerMillion);
     if (cachedInputPerMillion !== void 0) modelPricing.cachedInputPerMillion = cachedInputPerMillion;
+    if (cacheCreationInputPerMillion !== void 0) modelPricing.cacheCreationInputPerMillion = cacheCreationInputPerMillion;
     if (reasoningOutputPerMillion !== void 0) modelPricing.reasoningOutputPerMillion = reasoningOutputPerMillion;
     if (typeof row.note === "string") modelPricing.note = row.note;
     validated[model] = modelPricing;
@@ -2097,27 +3228,30 @@ function finiteNumber(value) {
 // apps/server/src/cli.ts
 var [command = "serve", ...args] = process.argv.slice(2);
 try {
-  if (command === "serve") {
+  if (command === "--help" || command === "-h" || command === "help") {
+    printHelp();
+  } else if (command === "serve") {
     const { url } = await startServer({ port: Number(process.env.REPOSPEND_PORT ?? 2005), serveWeb: true });
     console.log(`RepoSpend dashboard: ${url}`);
     openBrowser(url);
   } else if (command === "scan") {
-    const data = readDashboardData();
+    const data = readDashboardData(cliFilters(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().sessions));
+    printGroups(groupByRepo(readDashboardData(cliFilters(args)).sessions));
   } else if (command === "by-day") {
-    printGroups(groupByDay(readDashboardData().sessions));
+    printGroups(groupByDay(readDashboardData(cliFilters(args)).sessions));
   } else if (command === "by-hour") {
-    printGroups(groupByHour(readDashboardData().sessions));
+    printGroups(groupByHour(readDashboardData(cliFilters(args)).sessions));
   } else if (command === "by-model") {
-    printGroups(groupByModel(readDashboardData().sessions));
+    printGroups(groupByModel(readDashboardData(cliFilters(args)).sessions));
   } else if (command === "by-app") {
-    printGroups(groupBySourceApp(readDashboardData().sessions));
+    printGroups(groupBySourceApp(readDashboardData(cliFilters(args)).sessions));
   } else if (command === "export") {
     const format = valueAfter(args, "--format") ?? "json";
-    const sessions = readDashboardData().sessions;
-    console.log(format === "csv" ? toCsv(sessions) : exportJson());
+    const filters = cliFilters(args);
+    const sessions = readDashboardData(filters).sessions;
+    console.log(format === "csv" ? toCsv(sessions) : JSON.stringify(sessions, null, 2));
   } else {
     console.error(`Unknown command: ${command}`);
     printHelp();
@@ -2138,7 +3272,7 @@ function openBrowser(url) {
 }
 function printGroups(groups) {
   if (!groups.length) {
-    console.log("No usage found. Scanned ~/.codex/state_5.sqlite and ~/.codex/sessions.");
+    console.log("No usage found. Scanned Codex and Claude Code local data paths.");
     return;
   }
   const rows = groups.map((group) => ({
@@ -2149,6 +3283,11 @@ function printGroups(groups) {
   }));
   console.table(rows);
 }
+function cliFilters(args2) {
+  const source = valueAfter(args2, "--source");
+  if (!source || source === "all") return {};
+  return { source };
+}
 function valueAfter(args2, flag) {
   const index = args2.indexOf(flag);
   return index >= 0 ? args2[index + 1] : void 0;
@@ -2163,5 +3302,8 @@ function printHelp() {
   repospend by-model
   repospend by-app
   repospend export --format json
-  repospend export --format csv`);
+  repospend export --format csv
+
+Options:
+  --source all|codex|claude`);
 }