repospend 0.0.4 → 0.0.6

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);
@@ -212,6 +216,8 @@ var defaultPricing = {
   "gpt-5.4-mini": { inputPerMillion: 0.75, cachedInputPerMillion: 0.075, outputPerMillion: 4.5, reasoningOutputPerMillion: 4.5 },
   "gpt-5.4-nano": { inputPerMillion: 0.2, cachedInputPerMillion: 0.02, outputPerMillion: 1.25, reasoningOutputPerMillion: 1.25 },
   "gpt-5.4-pro": { inputPerMillion: 30, outputPerMillion: 180, reasoningOutputPerMillion: 180 },
+  "gpt-5.3-codex": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14 },
+  "gpt-5.3-codex-spark": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14, note: "Research preview pricing is not final in the OpenAI Codex rate card; this API-equivalent rate matches the practical ccusage/LiteLLM-style estimate." },
   "gpt-5.2": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14 },
   "gpt-5.2-chat-latest": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14 },
   "gpt-5.2-codex": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14 },
@@ -342,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;
@@ -363,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);
@@ -847,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)) {
@@ -895,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];
@@ -946,8 +961,9 @@ import Database from "better-sqlite3";
 // packages/core/src/sources/agent-friction.ts
 function analyzeAgentFriction(records, totalTokens) {
   const analysis = emptyAgentFrictionAnalysis();
+  const messages = [];
   for (const record of records) {
-    applyActionMetadata(analysis, record);
+    applyActionMetadata(analysis, record, messages);
   }
   finalizeCommandIssues(analysis, totalTokens);
   return analysis;
@@ -973,14 +989,14 @@ function emptyAgentFrictionAnalysis() {
     assistantMessageCount: 0
   };
 }
-function applyActionMetadata(analysis, record) {
+function applyActionMetadata(analysis, record, messages) {
   if (!record || typeof record !== "object") return;
   const object = record;
   const payload = firstObject(object.payload) ?? object;
   const type = stringValue(object.type) ?? stringValue(payload.type);
   const role = stringValue(payload.role);
-  if (payload.type === "user_message" || role === "user") analysis.userPromptCount += 1;
-  if (payload.type === "agent_message" || role === "assistant") analysis.assistantMessageCount += 1;
+  const messageRole = payload.type === "user_message" || role === "user" ? "user" : payload.type === "agent_message" || role === "assistant" ? "assistant" : void 0;
+  if (messageRole) applyMessageCount(analysis, messages, messageRole, payload, object);
   const text = JSON.stringify(record).toLowerCase();
   const isTool = type?.includes("tool") || type?.includes("function_call") || text.includes('"tool_call"') || text.includes('"function_call"');
   if (isTool) analysis.toolCallCount += 1;
@@ -1140,6 +1156,64 @@ function firstObject(...values) {
 function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function applyMessageCount(analysis, messages, role, payload, object) {
+  const message = extractMessageText(payload) ?? extractMessageText(object);
+  if (!message) return;
+  const item = {
+    role,
+    text: compactText(message),
+    timestamp: dateValue(payload.timestamp) ?? dateValue(object.timestamp) ?? dateValue(payload.created_at) ?? dateValue(object.created_at)
+  };
+  if (!item.text || isCodexStartupContext(item.text) || hasNearbyDuplicateMessage(messages, item)) return;
+  messages.push(item);
+  if (role === "user") analysis.userPromptCount += 1;
+  if (role === "assistant") analysis.assistantMessageCount += 1;
+}
+function extractMessageText(record) {
+  for (const key of ["text", "message", "content", "input"]) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value;
+    if (Array.isArray(value)) {
+      const parts = value.map((item) => {
+        if (typeof item === "string") return item;
+        if (item && typeof item === "object") {
+          const object = item;
+          return stringValue(object.text) ?? stringValue(object.content);
+        }
+        return void 0;
+      }).filter((item) => Boolean(item?.trim()));
+      if (parts.length) return parts.join("\n");
+    }
+  }
+  return void 0;
+}
+function compactText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isCodexStartupContext(text) {
+  return text.includes("<environment_context>") && (text.includes("# AGENTS.md instructions") || text.includes("<INSTRUCTIONS>"));
+}
+function hasNearbyDuplicateMessage(items, item) {
+  return items.some((existing) => {
+    if (existing.role !== item.role || existing.text !== item.text) return false;
+    if (!existing.timestamp || !item.timestamp) return true;
+    const existingTime = new Date(existing.timestamp).getTime();
+    const itemTime = new Date(item.timestamp).getTime();
+    if (!Number.isFinite(existingTime) || !Number.isFinite(itemTime)) return false;
+    return Math.abs(existingTime - itemTime) <= 5e3;
+  });
+}
+function dateValue(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return void 0;
+    return new Date(value > 1e10 ? value : value * 1e3).toISOString();
+  }
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+  }
+  return void 0;
+}
 
 // packages/core/src/sources/codex-token.ts
 function aggregateTokens(records) {
@@ -1210,8 +1284,8 @@ function finalizeTokenAccumulator(accumulator) {
       { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningTokens: 0, totalTokens: 0 }
     );
     applyFinalUsage(accumulator, total);
-    accumulator.tokenAggregationMethod = "direct_usage";
-    accumulator.tokenConfidence = "medium";
+    accumulator.tokenAggregationMethod = "delta_sum";
+    accumulator.tokenConfidence = "high";
     return;
   }
   accumulator.tokenAggregationMethod = "unknown";
@@ -1222,6 +1296,10 @@ function extractRecordTokens(record) {
   const object = record;
   const payload = firstObject2(object.payload);
   const payloadInfo = firstObject2(payload?.info);
+  const codexLastUsage = firstObject2(payloadInfo?.last_token_usage);
+  if (codexLastUsage) {
+    return tokenUsageFromObject(codexLastUsage, false);
+  }
   const codexTotalUsage = firstObject2(payloadInfo?.total_token_usage);
   if (codexTotalUsage) {
     return tokenUsageFromObject(codexTotalUsage, true);
@@ -1289,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: {
@@ -1337,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 [];
@@ -1346,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 });
@@ -1410,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,
@@ -1437,11 +1551,11 @@ function threadToUsage(row, index, sessionFiles, options) {
     cwd,
     gitRemoteUrl: repo.gitRemoteUrl,
     gitBranch: repo.gitBranch,
-    title: stringValue2(row.title),
-    startedAt: dateValue(row.created_at),
-    endedAt: dateValue(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,
@@ -1456,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(dateValue(row.created_at), dateValue(row.updated_at)),
+    durationMs: durationMs(startedAt, endedAt),
     rawEventCount: sessionBreakdown.rawEventCount,
     parseStatus: sessionBreakdown.parseStatus,
     parseErrors: sessionBreakdown.parseErrors,
@@ -1480,7 +1594,8 @@ function threadToUsage(row, index, sessionFiles, options) {
     fileReadCount: sessionBreakdown.fileReadCount,
     fileEditCount: sessionBreakdown.fileEditCount,
     promptTimeline: sessionBreakdown.promptTimeline,
-    sessionOutcome: inferOutcome(sessionBreakdown)
+    sessionOutcome: inferOutcome(sessionBreakdown),
+    compaction: sessionBreakdown.compaction
   };
   const cost = hasPricedBreakdown ? calculateCostUsd(usage, options.pricing) : void 0;
   const costWarnings = hasPricedBreakdown ? warnings : [...warnings, "missing_token_breakdown"];
@@ -1493,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,
@@ -1525,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,
@@ -1550,10 +1668,90 @@ function readStandaloneSessions(sessionFiles, options) {
       fileReadCount: breakdown.fileReadCount,
       fileEditCount: breakdown.fileEditCount,
       promptTimeline: breakdown.promptTimeline,
-      sessionOutcome: inferOutcome(breakdown)
+      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 {
@@ -1588,11 +1786,16 @@ function readSessionBreakdown(filePath) {
     breakdown.parseStatus = parse.errors.length ? records.length ? "partial" : "failed" : "ok";
     let eventMessageCount = 0;
     let responseMessageCount = 0;
+    let lastUserMessageText;
     for (const record of records) {
+      applySessionBounds(breakdown, record);
       applySessionMetadata(breakdown, record);
       applyPromptTimeline(breakdown, record);
       if (isCodexEventMessage(record)) eventMessageCount += 1;
       if (isResponseMessage(record)) responseMessageCount += 1;
+      const userText = extractUserMessageText(record);
+      if (userText !== void 0) lastUserMessageText = userText;
+      applyCompactionEvent(breakdown, record, lastUserMessageText);
     }
     breakdown.messageCount = eventMessageCount || responseMessageCount;
     const tokenAggregation = aggregateTokens(records);
@@ -1668,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,
@@ -1701,7 +1911,8 @@ function emptyBreakdown() {
     commandIssueSamples: [],
     fileReadCount: 0,
     fileEditCount: 0,
-    promptTimeline: []
+    promptTimeline: [],
+    compaction: { count: 0, autoCount: 0, manualCount: 0, events: [] }
   };
 }
 function fallbackCwdFromPath(filePath) {
@@ -1711,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;
@@ -1729,6 +1956,35 @@ function isResponseMessage(record) {
   const payload = firstObject3(object.payload);
   return payload?.type === "message" && (payload.role === "user" || payload.role === "assistant");
 }
+function extractUserMessageText(record) {
+  if (!record || typeof record !== "object") return void 0;
+  const object = record;
+  const payload = firstObject3(object.payload) ?? object;
+  const payloadType = stringValue2(payload.type);
+  const roleValue = stringValue2(payload.role);
+  const isUser = payloadType === "user_message" || object.type === "response_item" && payloadType === "message" && roleValue === "user";
+  if (!isUser) return void 0;
+  return extractMessageText2(payload) ?? extractMessageText2(object);
+}
+function applyCompactionEvent(breakdown, record, lastUserMessageText) {
+  if (!record || typeof record !== "object") return;
+  const object = record;
+  if (object.type !== "event_msg") return;
+  const payload = firstObject3(object.payload);
+  if (payload?.type !== "context_compacted") return;
+  const trigger = isManualCompactCommand(lastUserMessageText) ? "manual" : "auto";
+  breakdown.compaction.count += 1;
+  if (trigger === "manual") breakdown.compaction.manualCount += 1;
+  else breakdown.compaction.autoCount += 1;
+  breakdown.compaction.events.push({
+    timestamp: dateValue2(object.timestamp) ?? dateValue2(payload.timestamp),
+    trigger
+  });
+}
+function isManualCompactCommand(text) {
+  if (!text) return false;
+  return /^\s*\/compact\b/.test(text);
+}
 function applyPromptTimeline(breakdown, record) {
   if (breakdown.promptTimeline.length >= 80 || !record || typeof record !== "object") return;
   const object = record;
@@ -1737,15 +1993,19 @@ function applyPromptTimeline(breakdown, record) {
   const roleValue = stringValue2(payload.role);
   const role = payloadType === "user_message" || roleValue === "user" ? "user" : payloadType === "agent_message" || roleValue === "assistant" ? "assistant" : void 0;
   if (!role) return;
-  const text = extractMessageText(payload) ?? extractMessageText(object);
+  const text = extractMessageText2(payload) ?? extractMessageText2(object);
   if (!text) return;
-  breakdown.promptTimeline.push({
+  const timelineText = compactTimelineText(text);
+  if (!timelineText || isCodexStartupContext2(timelineText)) return;
+  const item = {
     role,
-    text: normalizeTimelineText(text),
-    timestamp: dateValue(payload.timestamp) ?? dateValue(object.timestamp) ?? dateValue(payload.created_at) ?? dateValue(object.created_at)
-  });
+    text: normalizeTimelineText(timelineText),
+    timestamp: dateValue2(payload.timestamp) ?? dateValue2(object.timestamp) ?? dateValue2(payload.created_at) ?? dateValue2(object.created_at)
+  };
+  if (hasNearbyDuplicatePromptTimelineItem(breakdown.promptTimeline, item)) return;
+  breakdown.promptTimeline.push(item);
 }
-function extractMessageText(record) {
+function extractMessageText2(record) {
   for (const key of ["text", "message", "content", "input"]) {
     const value = record[key];
     if (typeof value === "string" && value.trim()) return value;
@@ -1763,12 +2023,33 @@ function extractMessageText(record) {
   }
   return void 0;
 }
+function compactTimelineText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
 function normalizeTimelineText(text) {
-  return text.replace(/\s+/g, " ").trim().slice(0, 1e3);
+  return compactTimelineText(text).slice(0, 1e3);
+}
+function isCodexStartupContext2(text) {
+  return text.includes("<environment_context>") && (text.includes("# AGENTS.md instructions") || text.includes("<INSTRUCTIONS>"));
+}
+function hasNearbyDuplicatePromptTimelineItem(items, item) {
+  return items.some((existing) => {
+    if (existing.role !== item.role || existing.text !== item.text) return false;
+    if (!existing.timestamp || !item.timestamp) return true;
+    const existingTime = new Date(existing.timestamp).getTime();
+    const itemTime = new Date(item.timestamp).getTime();
+    if (!Number.isFinite(existingTime) || !Number.isFinite(itemTime)) return false;
+    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" };
@@ -1792,16 +2073,20 @@ 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 app";
+  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";
-  if (source.trim().startsWith("{")) return threadSource === "subagent" ? "Codex app" : "Codex";
+  if (source.trim().startsWith("{")) return threadSource === "subagent" ? "Codex subagent" : "Codex";
   return source.replace(/^codex[_-]/, "").split(/[_-]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
-function dateValue(value) {
+function dateValue2(value) {
   if (typeof value === "number") {
     return new Date(value > 1e10 ? value : value * 1e3).toISOString();
   }
@@ -1831,7 +2116,9 @@ function scanClaude(options) {
   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 seenUsageKeys = /* @__PURE__ */ new Set();
+  const orderedFiles = discovery.files.map((file) => ({ file, mtimeMs: safeMtimeMs(file.filePath) })).sort((a, b) => a.mtimeMs - b.mtimeMs);
+  const sessions = orderedFiles.map(({ file }, index) => claudeFileToUsage(file, index, options, seenUsageKeys));
   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;
@@ -1937,20 +2224,21 @@ function walk2(root, maxDepth, onFile, depth = 0) {
     }
   }
 }
-function claudeFileToUsage(file, index, options) {
-  const breakdown = readClaudeBreakdown(file.filePath);
+function claudeFileToUsage(file, index, options, seenUsageKeys) {
+  const breakdown = readClaudeBreakdown(file.filePath, seenUsageKeys);
   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];
+  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,
@@ -1980,9 +2268,9 @@ function claudeFileToUsage(file, index, options) {
     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,
@@ -2009,7 +2297,10 @@ function claudeFileToUsage(file, index, options) {
     warnings: cost === void 0 ? [...usage.warnings, "unknown_pricing"] : usage.warnings
   };
 }
-function readClaudeBreakdown(filePath) {
+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 {
     const text = fs5.readFileSync(filePath, "utf8");
@@ -2018,7 +2309,7 @@ function readClaudeBreakdown(filePath) {
     breakdown.parseErrors = parse.errors;
     breakdown.parseStatus = parse.errors.length ? parse.records.length ? "partial" : "failed" : "ok";
     for (const record of parse.records) {
-      applyClaudeRecord(breakdown, record);
+      applyClaudeRecord(breakdown, record, seenUsageKeys);
     }
     breakdown.totalTokens = breakdown.inputTokens + breakdown.outputTokens;
   } catch (error) {
@@ -2029,8 +2320,8 @@ function readClaudeBreakdown(filePath) {
   }
   return breakdown;
 }
-function applyClaudeRecord(breakdown, record) {
-  const timestamp3 = dateValue2(record.timestamp);
+function applyClaudeRecord(breakdown, record, seenUsageKeys) {
+  const timestamp3 = dateValue3(record.timestamp);
   if (timestamp3) {
     breakdown.startedAt = minDate(breakdown.startedAt, timestamp3);
     breakdown.endedAt = maxDate(breakdown.endedAt, timestamp3);
@@ -2052,11 +2343,22 @@ function applyClaudeRecord(breakdown, record) {
     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);
+    if (usage && usageTokens > 0 && !alreadySeenUsage(record, message, seenUsageKeys)) {
+      applyUsage(breakdown, usage);
+    }
     applyContentSignals(breakdown, message.content);
   }
   if (looksFailedToolResult(record.toolUseResult)) breakdown.failedToolCallCount += 1;
 }
+function alreadySeenUsage(record, message, seenUsageKeys) {
+  const messageId = stringValue3(message.id);
+  const requestId = stringValue3(record.requestId);
+  if (!messageId || !requestId) return false;
+  const key = `${requestId}:${messageId}`;
+  if (seenUsageKeys.has(key)) return true;
+  seenUsageKeys.add(key);
+  return false;
+}
 function applyUsage(breakdown, usage) {
   const input = numberValue(usage.input_tokens);
   const cacheRead = numberValue(usage.cache_read_input_tokens);
@@ -2174,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";
 }
@@ -2240,7 +2542,7 @@ function normalizeClaudeModel(value) {
   if (!model || model === "<synthetic>") return void 0;
   return model;
 }
-function dateValue2(value) {
+function dateValue3(value) {
   if (typeof value !== "string") return void 0;
   const date = new Date(value);
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
@@ -2269,6 +2571,13 @@ function looksFailedToolResult(value) {
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function safeMtimeMs(filePath) {
+  try {
+    return fs5.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
 
 // packages/core/src/sources/index.ts
 function scanUsageSources(options) {
@@ -2293,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;
@@ -2332,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);
@@ -2371,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();
 }
@@ -2387,17 +2734,17 @@ 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 },
+  "gpt-5.3-codex-spark": { inputPerMillion: 1.75, cachedInputPerMillion: 0.175, outputPerMillion: 14, reasoningOutputPerMillion: 14 },
   "claude-haiku-4-5-20251001": { inputPerMillion: 1, cacheCreationInputPerMillion: 1.25, cachedInputPerMillion: 0.1, outputPerMillion: 5 }
 };
 function demoModeEnabled() {
   return process.env.REPOSPEND_DEMO_DATA === "lotr";
 }
-function readDemoDashboardData(filters = {}) {
+function readDemoDashboardData(filters = {}, options = {}) {
   return buildDashboardSnapshot({
     sources: demoSources,
     sourceStats: demoSourceStats,
-    sessions: demoSessions,
+    sessions: displaySessions(demoSessions, options),
     filters
   });
 }
@@ -2655,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",
@@ -2965,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) {
@@ -3185,12 +3532,15 @@ 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,
+      appVersion: readPackageVersion(),
       summary: { ...data.summary, skippedZeroTokenSessions: data.skippedZeroTokenSessions },
       pricing: {
         info: pricingInfo,