repospend 0.0.5 → 0.0.6

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to RepoSpend will be documented in this file.
 
+## 0.0.6
+
+- Improve Codex session metadata recovery from rollout logs, including standalone Codex Desktop sessions and imported Claude model metadata.
+- Add an optional source-scoped app display mode so shared surfaces can be shown as source-specific entries such as "Codex on VS Code".
+- Improve sparse timeline charts and RTK unavailable-state guidance in the dashboard.
+- Document why RepoSpend token totals can differ from `ccusage` while API-equivalent costs still match.
+- Show a git-branch icon next to repos with a confirmed git root and a folder icon for path-inferred repos, giving a quick visual signal of data confidence.
+- Fix Windows extended-length path prefix (\\?\) handling in git root detection, which caused repos on Windows to incorrectly appear as unverified.
+
+
 ## 0.0.5
 
 - Fix Codex token under-count on long sessions by summing per-turn `last_token_usage` instead of taking the max of `total_token_usage`, which Codex resets on each context compaction.

package/README.md

@@ -156,6 +156,31 @@ Claude Code cost may show as unknown when local files do not include token count
 or a model name. RepoSpend shows those sessions with unknown tokens/cost rather
 than guessing.
 
+### Why RepoSpend's token totals can look lower than `ccusage`
+
+If you compare RepoSpend to `ccusage` you may see matching costs but different
+"total tokens", especially for Codex where cache reads dominate. This is
+expected.
+
+RepoSpend treats `cached_input_tokens` as a **subset of** `input_tokens`, which
+is how the OpenAI and Anthropic APIs document the field. The "total tokens"
+number reflects the tokens the model actually processed. `ccusage` adds cached
+tokens as a separate line item in its "Total Tokens" column, which inflates the
+total but does not change billing.
+
+The dollar cost is the source of truth and should agree between the two tools
+within rounding. If costs diverge, that is a real discrepancy worth
+investigating; token-count divergence on its own usually is not.
+
+### Codex Desktop on Windows
+
+RepoSpend captures Codex **CLI** usage on Windows from `~/.codex/`. The Codex
+**Desktop app** (installed as the MSIX package
+`OpenAI.Codex_<id>` under `%LOCALAPPDATA%\Packages\`) does not persist session
+transcripts or per-turn token usage to disk. Only Electron caches and debug
+logs are stored locally. Real session data lives server-side. Neither RepoSpend
+nor `ccusage` can report on Codex Desktop usage from local files alone.
+
 ## What It Reads
 
 RepoSpend only reads local files. It does not edit Codex, Claude Code, or RTK

package/dist/cli.js

@@ -44,10 +44,14 @@ function summarize(sessions) {
   };
 }
 function groupByRepo(sessions) {
-  return groupBy(sessions, (session) => session.repoRoot, (session) => session.repoName);
+  const groups = groupBy(sessions, (session) => session.repoRoot, (session) => session.repoName);
+  return groups.map((group) => ({
+    ...group,
+    verified: sessions.some((s) => s.repoRoot === group.id && !s.warnings.includes("repo_unverified_no_git_root"))
+  }));
 }
 function groupByModel(sessions) {
-  return groupBy(sessions, (session) => session.model ?? "unknown-model", (session) => session.model ?? "Unknown model");
+  return groupBy(sessions, (session) => session.model ?? "unknown-model", (session) => session.model ?? "Model not recorded");
 }
 function groupBySourceApp(sessions) {
   return groupBy(sessions, (session) => session.sourceApp, (session) => session.sourceApp);
@@ -344,7 +348,7 @@ function filterUsage(sessions, filters) {
     if (!matchesAny(session.sourceClient, filters.source)) return false;
     if (!matchesAny(session.sourceApp, filters.sourceApp)) return false;
     if (!matchesRepo(session, filters.repo)) return false;
-    if (!matchesAny(session.model, filters.model)) return false;
+    if (!matchesModel(session.model, filters.model)) return false;
     const startedAt = timestamp(session.startedAt);
     const hasDateFilter = Boolean(filters.from || filters.to);
     if (hasDateFilter && startedAt === void 0) return false;
@@ -365,6 +369,11 @@ function matchesRepo(session, filter) {
   if (!values.length) return true;
   return values.includes(session.repoName) || values.includes(session.repoRoot);
 }
+function matchesModel(value, filter) {
+  const values = filterValues(filter);
+  if (!values.length) return true;
+  return value !== void 0 ? values.includes(value) : values.includes("unknown-model");
+}
 function filterValues(filter) {
   if (!filter) return [];
   return Array.isArray(filter) ? filter.filter(Boolean) : filter.split(",").map((value) => value.trim()).filter(Boolean);
@@ -849,8 +858,12 @@ function isDashboardVisibleSession(session) {
 // packages/core/src/repo.ts
 import fs3 from "node:fs";
 import path3 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 = path3.resolve(cwd);
+  let current = normalizeRoot(path3.resolve(cwd));
   while (true) {
     const gitPath = path3.join(current, ".git");
     if (fileSystem.existsSync(gitPath)) {
@@ -897,8 +910,8 @@ function safeFindGitRoot(cwd, fileSystem) {
   }
 }
 function fallbackWorkspaceRoot(cwd) {
-  const resolved = path3.resolve(cwd || process.cwd());
-  const home = process.env.HOME ? path3.resolve(process.env.HOME) : void 0;
+  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 first = relative[0];
@@ -1354,12 +1367,9 @@ function scanCodex(options) {
   if (stateExists) {
     const stateSessions = readThreads(statePath, sessionFiles, options, warnings);
     sessions.push(...stateSessions);
-    if (!stateSessions.length && sessionsExists) {
-      sessions.push(...readStandaloneSessions(sessionFiles, options));
-    }
   }
-  if (!stateExists && sessionsExists) {
-    sessions.push(...readStandaloneSessions(sessionFiles, options));
+  if (sessionsExists) {
+    sessions.push(...readStandaloneSessions(sessionFiles, options).filter((session) => !hasImportedSession(sessions, session)));
   }
   return {
     source: {
@@ -1402,8 +1412,10 @@ 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();
-    return rows.map((row, index) => threadToUsage(row, index, sessionFiles, options));
+    const sessions = rows.map((row, index) => threadToUsage(row, index, sessionFiles, options, importedModels));
+    return attributeSubagentsToParentSurfaces(sessions, rows);
   } catch (error) {
     warnings.push(`Unable to read Codex SQLite state at ${statePath}: ${errorMessage(error)}`);
     return [];
@@ -1411,6 +1423,37 @@ function readThreads(statePath, sessionFiles, options, warnings) {
     db?.close();
   }
 }
+function attributeSubagentsToParentSurfaces(sessions, rows) {
+  const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+  const parentIdsByChildId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const childId = stringValue2(row.id);
+    const parentId = codexParentThreadId(stringValue2(row.source));
+    if (childId && parentId) parentIdsByChildId.set(childId, parentId);
+  }
+  return sessions.map((session) => {
+    if (session.sourceApp !== "Codex subagent") return session;
+    const parent = sessionsById.get(parentIdsByChildId.get(session.id) ?? "");
+    if (!parent || parent.sourceApp === "Codex subagent") return session;
+    return {
+      ...session,
+      sourceApp: parent.sourceApp,
+      sourceAppRaw: session.sourceAppRaw,
+      surfaceReason: `subagent attributed to parent thread ${parent.id}: ${parent.surfaceReason}`
+    };
+  });
+}
+function codexParentThreadId(source) {
+  if (!source?.trim().startsWith("{")) return void 0;
+  try {
+    const object = asRecord(JSON.parse(source));
+    const subagent = asRecord(object?.subagent);
+    const threadSpawn = asRecord(subagent?.thread_spawn);
+    return stringValue2(threadSpawn?.parent_thread_id);
+  } catch {
+    return void 0;
+  }
+}
 function openCodexStateDatabase(statePath, warnings) {
   try {
     return new Database(statePath, { readonly: true, fileMustExist: true });
@@ -1475,24 +1518,30 @@ function isNativeSqliteMismatch(error) {
 function exitLabel(status) {
   return status === null ? "" : ` with exit code ${status}`;
 }
-function threadToUsage(row, index, sessionFiles, options) {
+function threadToUsage(row, index, sessionFiles, options, importedModels = /* @__PURE__ */ new Map()) {
+  const id = stringValue2(row.id) ?? `codex-thread-${index}`;
   const sourcePath = stringValue2(row.rollout_path) ?? matchSessionPath(stringValue2(row.id), sessionFiles) ?? "";
   const sessionBreakdown = sourcePath ? readSessionBreakdown(sourcePath) : emptyBreakdown();
   const dbTokens = parseTokenTotal(row.tokens_used);
-  const cwd = stringValue2(row.cwd) ?? fallbackCwdFromPath(sourcePath);
+  const cwd = stringValue2(row.cwd) ?? sessionBreakdown.cwd ?? fallbackCwdFromPath(sourcePath);
   const repo = resolveRepoInfo(cwd, options.config);
+  const inferredModel = stringValue2(row.model) || sessionBreakdown.model ? void 0 : importedModels.get(id);
+  const model = stringValue2(row.model) ?? sessionBreakdown.model ?? inferredModel?.model;
+  const provider = sessionBreakdown.provider ?? inferredModel?.provider ?? stringValue2(row.model_provider);
   const inputTokens = sessionBreakdown.inputTokens;
   const cachedInputTokens = sessionBreakdown.cachedInputTokens;
   const outputTokens = sessionBreakdown.outputTokens;
   const reasoningTokens = sessionBreakdown.reasoningTokens;
   const totalTokens = sessionBreakdown.totalTokens || dbTokens || inputTokens + outputTokens + reasoningTokens;
   const hasPricedBreakdown = inputTokens + cachedInputTokens + outputTokens + reasoningTokens > 0;
-  const warnings = [...repo.warnings, ...sessionBreakdown.warnings];
+  const warnings = [...repo.warnings, ...sessionBreakdown.warnings, ...inferredModel ? ["model_inferred_from_import_source"] : []];
   const threadSource = stringValue2(row.thread_source) ?? sessionBreakdown.threadSource;
-  const sourceAppRaw = stringValue2(row.source) ?? sessionBreakdown.source ?? sessionBreakdown.originator ?? threadSource;
+  const sourceAppRaw = codexSourceRaw(stringValue2(row.source), sessionBreakdown.source, sessionBreakdown.originator, threadSource);
   const surface = detectSurface(sourceAppRaw, threadSource);
+  const startedAt = dateValue2(row.created_at) ?? sessionBreakdown.startedAt;
+  const endedAt = dateValue2(row.updated_at) ?? sessionBreakdown.endedAt;
   const usage = {
-    id: stringValue2(row.id) ?? `codex-thread-${index}`,
+    id,
     sourceClient: "codex",
     sourceApp: codexSourceAppLabel(sourceAppRaw, threadSource),
     sourceAppRaw,
@@ -1502,11 +1551,11 @@ function threadToUsage(row, index, sessionFiles, options) {
     cwd,
     gitRemoteUrl: repo.gitRemoteUrl,
     gitBranch: repo.gitBranch,
-    title: stringValue2(row.title),
-    startedAt: dateValue2(row.created_at),
-    endedAt: dateValue2(row.updated_at),
-    model: stringValue2(row.model),
-    provider: stringValue2(row.model_provider),
+    title: stringValue2(row.title) ?? sessionBreakdown.title,
+    startedAt,
+    endedAt,
+    model,
+    provider,
     inputTokens,
     cachedInputTokens,
     outputTokens,
@@ -1521,7 +1570,7 @@ function threadToUsage(row, index, sessionFiles, options) {
     rawTokenTotal: dbTokens || sessionBreakdown.totalTokens || void 0,
     warnings,
     codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
-    durationMs: durationMs(dateValue2(row.created_at), dateValue2(row.updated_at)),
+    durationMs: durationMs(startedAt, endedAt),
     rawEventCount: sessionBreakdown.rawEventCount,
     parseStatus: sessionBreakdown.parseStatus,
     parseErrors: sessionBreakdown.parseErrors,
@@ -1559,26 +1608,28 @@ function threadToUsage(row, index, sessionFiles, options) {
 function readStandaloneSessions(sessionFiles, options) {
   return [...sessionFiles.entries()].map(([id, sourcePath]) => {
     const breakdown = readSessionBreakdown(sourcePath);
-    const cwd = fallbackCwdFromPath(sourcePath);
+    const cwd = breakdown.cwd ?? fallbackCwdFromPath(sourcePath);
     const repo = resolveRepoInfo(cwd, options.config);
-    const model = void 0;
-    const surface = detectSurface(breakdown.source ?? breakdown.originator, breakdown.threadSource);
-    return {
-      id,
+    const model = breakdown.model;
+    const provider = breakdown.provider ?? providerForModel(model ?? "");
+    const sourceAppRaw = codexSourceRaw(void 0, breakdown.source, breakdown.originator, breakdown.threadSource);
+    const surface = detectSurface(sourceAppRaw, breakdown.threadSource);
+    const usage = {
+      id: breakdown.id ?? id,
       sourceClient: "codex",
-      sourceApp: codexSourceAppLabel(breakdown.source ?? breakdown.originator, breakdown.threadSource),
-      sourceAppRaw: breakdown.source ?? breakdown.originator ?? breakdown.threadSource,
+      sourceApp: codexSourceAppLabel(sourceAppRaw, breakdown.threadSource),
+      sourceAppRaw,
       sourcePath,
       repoRoot: repo.repoRoot,
       repoName: repo.repoName,
       cwd,
       gitRemoteUrl: repo.gitRemoteUrl,
       gitBranch: repo.gitBranch,
-      title: void 0,
-      startedAt: void 0,
-      endedAt: void 0,
+      title: breakdown.title,
+      startedAt: breakdown.startedAt,
+      endedAt: breakdown.endedAt,
       model,
-      provider: void 0,
+      provider,
       inputTokens: breakdown.inputTokens,
       cachedInputTokens: breakdown.cachedInputTokens,
       outputTokens: breakdown.outputTokens,
@@ -1591,8 +1642,9 @@ function readStandaloneSessions(sessionFiles, options) {
       estimatedCostUsd: void 0,
       messageCount: breakdown.messageCount,
       rawTokenTotal: breakdown.totalTokens || void 0,
-      warnings: [...repo.warnings, ...breakdown.warnings, "unknown_pricing"],
+      warnings: [...repo.warnings, ...breakdown.warnings],
       codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
+      durationMs: durationMs(breakdown.startedAt, breakdown.endedAt),
       rawEventCount: breakdown.rawEventCount,
       parseStatus: breakdown.parseStatus,
       parseErrors: breakdown.parseErrors,
@@ -1619,8 +1671,87 @@ function readStandaloneSessions(sessionFiles, options) {
       sessionOutcome: inferOutcome(breakdown),
       compaction: breakdown.compaction
     };
+    const hasPricedBreakdown = breakdown.inputTokens + breakdown.cachedInputTokens + breakdown.outputTokens + breakdown.reasoningTokens > 0;
+    const cost = hasPricedBreakdown ? calculateCostUsd(usage, options.pricing) : void 0;
+    return {
+      ...usage,
+      estimatedCostUsd: cost,
+      warnings: cost === void 0 ? [...usage.warnings, hasPricedBreakdown ? "unknown_pricing" : "missing_token_breakdown"] : usage.warnings
+    };
   });
 }
+function hasImportedSession(sessions, candidate) {
+  const candidatePath = comparableSourcePath(candidate.sourcePath);
+  return sessions.some((session) => {
+    if (session.id && session.id === candidate.id) return true;
+    const sessionPath = comparableSourcePath(session.sourcePath);
+    return Boolean(candidatePath && sessionPath && candidatePath === sessionPath);
+  });
+}
+function readImportedModelMap(codexHome, warnings) {
+  const importsPath = path4.join(codexHome, "external_agent_session_imports.json");
+  const models = /* @__PURE__ */ new Map();
+  if (!fs4.existsSync(importsPath)) return models;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs4.readFileSync(importsPath, "utf8"));
+  } catch (error) {
+    warnings.push(`Unable to read Codex external import index at ${importsPath}: ${errorMessage(error)}`);
+    return models;
+  }
+  const records = Array.isArray(asRecord(parsed)?.records) ? asRecord(parsed)?.records : [];
+  for (const record of records) {
+    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;
+    const model = readImportedSourceModel(sourcePath, warnings);
+    if (model) models.set(importedThreadId, { model, provider: providerForModel(model) });
+  }
+  return models;
+}
+function readImportedSourceModel(sourcePath, warnings) {
+  const counts = /* @__PURE__ */ new Map();
+  let content;
+  try {
+    content = fs4.readFileSync(sourcePath, "utf8");
+  } catch (error) {
+    warnings.push(`Unable to read Codex external import source at ${sourcePath}: ${errorMessage(error)}`);
+    return void 0;
+  }
+  for (const [index, line] of content.split(/\r?\n/).entries()) {
+    if (!line.trim()) continue;
+    try {
+      const model = modelFromImportedRecord(JSON.parse(line));
+      if (model) counts.set(model, (counts.get(model) ?? 0) + 1);
+    } catch (error) {
+      warnings.push(`Unable to parse Codex external import source ${sourcePath} line ${index + 1}: ${errorMessage(error)}`);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0];
+}
+function modelFromImportedRecord(record) {
+  const object = asRecord(record);
+  const type = stringValue2(object?.type) ?? stringValue2(asRecord(object?.payload)?.type);
+  const message = asRecord(object?.message) ?? asRecord(asRecord(object?.payload)?.message);
+  const model = stringValue2(message?.model) ?? stringValue2(object?.model);
+  if (!model || model === "<synthetic>") return void 0;
+  if (type && type !== "assistant") return void 0;
+  return model;
+}
+function providerForModel(model) {
+  const normalized = model.toLowerCase();
+  if (!normalized) return void 0;
+  if (normalized.startsWith("claude")) return "anthropic";
+  if (normalized.startsWith("gpt") || normalized.startsWith("o")) return "openai";
+  return void 0;
+}
+function normalizeVerbatimPath(value) {
+  return value?.replace(/^\\\\\?\\/, "");
+}
+function comparableSourcePath(value) {
+  return normalizeVerbatimPath(value)?.replace(/\\/g, "/");
+}
 function indexSessionFiles(sessionsPath, warnings) {
   const files = /* @__PURE__ */ new Map();
   try {
@@ -1657,6 +1788,7 @@ function readSessionBreakdown(filePath) {
     let responseMessageCount = 0;
     let lastUserMessageText;
     for (const record of records) {
+      applySessionBounds(breakdown, record);
       applySessionMetadata(breakdown, record);
       applyPromptTimeline(breakdown, record);
       if (isCodexEventMessage(record)) eventMessageCount += 1;
@@ -1739,6 +1871,13 @@ function matchSessionPath(id, sessionFiles) {
 }
 function emptyBreakdown() {
   return {
+    id: void 0,
+    cwd: void 0,
+    title: void 0,
+    startedAt: void 0,
+    endedAt: void 0,
+    model: void 0,
+    provider: void 0,
     inputTokens: 0,
     cachedInputTokens: 0,
     outputTokens: 0,
@@ -1783,10 +1922,26 @@ function applySessionMetadata(breakdown, record) {
   if (!record || typeof record !== "object") return;
   const object = record;
   const payload = firstObject3(object.payload) ?? object;
+  const collaborationMode = firstObject3(payload.collaboration_mode);
+  const collaborationSettings = firstObject3(collaborationMode?.settings);
+  breakdown.id ??= stringValue2(payload.id);
+  breakdown.cwd ??= stringValue2(payload.cwd);
+  breakdown.title ??= stringValue2(payload.title);
+  breakdown.model ??= stringValue2(payload.model) ?? stringValue2(collaborationSettings?.model);
+  breakdown.provider ??= stringValue2(payload.model_provider);
   breakdown.source ??= stringValue2(payload.source);
   breakdown.originator ??= stringValue2(payload.originator);
   breakdown.threadSource ??= stringValue2(payload.thread_source);
 }
+function applySessionBounds(breakdown, record) {
+  if (!record || typeof record !== "object") return;
+  const object = record;
+  const payload = firstObject3(object.payload);
+  const timestamp3 = dateValue2(object.timestamp) ?? dateValue2(payload?.timestamp);
+  const sessionStartedAt = object.type === "session_meta" ? dateValue2(payload?.timestamp) ?? timestamp3 : timestamp3;
+  if (sessionStartedAt && (!breakdown.startedAt || sessionStartedAt < breakdown.startedAt)) breakdown.startedAt = sessionStartedAt;
+  if (timestamp3 && (!breakdown.endedAt || timestamp3 > breakdown.endedAt)) breakdown.endedAt = timestamp3;
+}
 function isCodexEventMessage(record) {
   if (!record || typeof record !== "object") return false;
   const object = record;
@@ -1887,9 +2042,14 @@ function hasNearbyDuplicatePromptTimelineItem(items, item) {
     return Math.abs(existingTime - itemTime) <= 5e3;
   });
 }
+function codexSourceRaw(source, sessionSource, originator, threadSource) {
+  if (originator && /codex\s+desktop/i.test(originator)) return originator;
+  return source ?? sessionSource ?? originator ?? threadSource;
+}
 function detectSurface(source, threadSource) {
   const raw = `${source ?? ""} ${threadSource ?? ""}`.toLowerCase();
   if (threadSource === "subagent") return { surface: "codex_exec", confidence: "medium", reason: "thread_source is subagent" };
+  if (raw.includes("codex desktop")) return { surface: "local_agent", confidence: "high", reason: "originator metadata identifies Codex Desktop" };
   if (raw.includes("vscode")) return { surface: "vscode_extension", confidence: "high", reason: "source metadata includes vscode" };
   if (raw.includes("cli") || raw.includes("terminal") || raw.includes("tui")) return { surface: "terminal_cli", confidence: "high", reason: "source metadata indicates CLI/terminal" };
   if (raw.includes("exec")) return { surface: "codex_exec", confidence: "medium", reason: "source metadata includes exec" };
@@ -1913,9 +2073,13 @@ function durationMs(startedAt, endedAt) {
 function stringValue2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
 function codexSourceAppLabel(source, threadSource) {
   if (threadSource === "subagent") return "Codex subagent";
   if (!source) return "Codex";
+  if (/codex\s+desktop/i.test(source)) return "Codex Desktop";
   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";
@@ -2067,13 +2231,14 @@ function claudeFileToUsage(file, index, options, seenUsageKeys) {
   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");
   const hasTokenBreakdown = breakdown.totalTokens > 0 && breakdown.usageCount > 0;
   const usage = {
     id,
     sourceClient: "claude",
-    sourceApp: claudeSourceAppLabel(breakdown.entrypoint),
-    sourceAppRaw: breakdown.entrypoint,
+    sourceApp: claudeSourceAppLabel(entrypoint),
+    sourceAppRaw: entrypoint,
     sourcePath: file.filePath,
     repoRoot: repo.repoRoot,
     repoName: repo.repoName,
@@ -2103,9 +2268,9 @@ function claudeFileToUsage(file, index, options, seenUsageKeys) {
     rawEventCount: breakdown.rawEventCount,
     parseStatus: breakdown.parseStatus,
     parseErrors: breakdown.parseErrors,
-    detectedSurface: claudeSurface(breakdown.entrypoint),
+    detectedSurface: claudeSurface(entrypoint),
     surfaceConfidence: "medium",
-    surfaceReason: breakdown.entrypoint ? `Claude Code entrypoint: ${breakdown.entrypoint}` : "Claude Code transcript",
+    surfaceReason: entrypoint ? `Claude Code entrypoint: ${entrypoint}` : "Claude Code transcript",
     userPromptCount: breakdown.userPromptCount,
     assistantMessageCount: breakdown.assistantMessageCount,
     toolCallCount: breakdown.toolCallCount,
@@ -2132,6 +2297,9 @@ function claudeFileToUsage(file, index, options, seenUsageKeys) {
     warnings: cost === void 0 ? [...usage.warnings, "unknown_pricing"] : usage.warnings
   };
 }
+function inferClaudeEntrypointFromPath(filePath) {
+  return filePath.split(path5.sep).includes("local-agent-mode-sessions") ? "local-agent" : void 0;
+}
 function readClaudeBreakdown(filePath, seenUsageKeys) {
   const breakdown = emptyBreakdown2();
   try {
@@ -2308,13 +2476,13 @@ function inferOutcome2(breakdown) {
 function claudeSurface(entrypoint) {
   const value = entrypoint?.toLowerCase() ?? "";
   if (value.includes("vscode")) return "vscode_extension";
-  if (value.includes("local-agent")) return "local_agent";
+  if (value.includes("local-agent") || value.includes("desktop")) 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.includes("local-agent") || value.includes("desktop")) return "Claude Desktop App";
   if (value === "cli" || value.includes("terminal")) return "Terminal";
   return "Claude Code";
 }
@@ -2434,9 +2602,9 @@ function scanUsageSources(options) {
 import fs6 from "node:fs";
 var scanCacheTtlMs = 1e4;
 var scanCache;
-function readDashboardData(filters = {}) {
+function readDashboardData(filters = {}, options = {}) {
   const raw = readRawUsageData();
-  return buildDashboardSnapshot({ ...raw, filters });
+  return buildDashboardSnapshot({ ...raw, sessions: displaySessions(raw.sessions, options), filters });
 }
 function clearScanCache() {
   scanCache = void 0;
@@ -2473,6 +2641,11 @@ function parseFilters(query) {
   if (to) filters.to = to;
   return filters;
 }
+function parseDashboardOptions(query) {
+  return {
+    splitSourceApps: query.splitSourceApps === "true" || query.splitSourceApps === "1"
+  };
+}
 function readPricingData() {
   const config = loadConfig();
   const pricingPath = resolvePricingPath(config);
@@ -2512,6 +2685,39 @@ function listQuery(value) {
   const parsed = values.flatMap((item) => typeof item === "string" ? item.split(",") : []).map((item) => item.trim()).filter(Boolean);
   return parsed.length ? parsed : void 0;
 }
+function displaySessions(sessions, options) {
+  if (!options.splitSourceApps) return sessions;
+  return sessions.map((session) => {
+    const sourceApp = sourceScopedAppLabel(session);
+    return sourceApp === session.sourceApp ? session : { ...session, sourceApp };
+  });
+}
+function sourceScopedAppLabel(session) {
+  const app = session.sourceApp || fallbackSurfaceLabel(session.detectedSurface);
+  if (!app || app === "Unknown") return sourceClientLabel(session.sourceClient);
+  if (!shouldScopeApp(app)) return app;
+  return `${sourceClientLabel(session.sourceClient)} on ${app}`;
+}
+function shouldScopeApp(app) {
+  const normalized = app.toLowerCase();
+  return normalized.includes("vs code") || normalized.includes("vscode") || normalized.includes("terminal") || normalized.includes("cli");
+}
+function sourceClientLabel(source) {
+  if (source === "codex") return "Codex";
+  if (source === "claude") return "Claude Code";
+  if (source === "gemini-cli") return "Gemini CLI";
+  if (source === "opencode") return "OpenCode";
+  if (source === "cursor") return "Cursor";
+  return "Unknown";
+}
+function fallbackSurfaceLabel(surface) {
+  if (surface === "terminal_cli") return "Terminal";
+  if (surface === "vscode_extension") return "VS Code";
+  if (surface === "local_agent") return "Desktop local agent";
+  if (surface === "codex_exec") return "Codex";
+  if (surface === "codex_app_cloud") return "Codex app";
+  return "Unknown";
+}
 function runtimeCwd() {
   return process.env.INIT_CWD || process.cwd();
 }
@@ -2534,11 +2740,11 @@ var demoPricing = {
 function demoModeEnabled() {
   return process.env.REPOSPEND_DEMO_DATA === "lotr";
 }
-function readDemoDashboardData(filters = {}) {
+function readDemoDashboardData(filters = {}, options = {}) {
   return buildDashboardSnapshot({
     sources: demoSources,
     sourceStats: demoSourceStats,
-    sessions: demoSessions,
+    sessions: displaySessions(demoSessions, options),
     filters
   });
 }
@@ -2796,7 +3002,7 @@ var demoInputs = [
     repo: "rivendell-dashboard",
     title: "Refactor the council-of-elrond planner",
     sourceClient: "claude",
-    sourceApp: "Claude desktop local agent",
+    sourceApp: "Claude Desktop App",
     sourceAppRaw: "claude-desktop-local-agent",
     model: "claude-sonnet-4-6",
     provider: "anthropic",
@@ -3106,7 +3312,7 @@ 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";
+  if (sourceApp === "Claude Desktop App") return "local_agent";
   return "terminal_cli";
 }
 function timestamp2(hour, minute) {
@@ -3326,9 +3532,11 @@ 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 filters = parseFilters(request.query);
+    const query = request.query;
+    const filters = parseFilters(query);
+    const dashboardOptions = parseDashboardOptions(query);
     const demoMode = demoModeEnabled();
-    const data = demoMode ? readDemoDashboardData(filters) : readDashboardData(filters);
+    const data = demoMode ? readDemoDashboardData(filters, dashboardOptions) : readDashboardData(filters, dashboardOptions);
     const rtkGain = demoMode ? readDemoRtkGain() : await readRtkGain();
     return {
       ...data,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repospend",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Local-first dashboard for tracking AI coding token usage by repo, source, session, model, and day.",
   "license": "Apache-2.0",
   "author": "Mehmet Mustafa Demir",