repospend 0.0.1

package/dist/cli.js

@@ -0,0 +1,2167 @@
+#!/usr/bin/env node
+
+// apps/server/src/cli.ts
+import { spawn } from "node:child_process";
+
+// packages/core/src/aggregate.ts
+function summarize(sessions) {
+  const repos = groupByRepo(sessions);
+  const cost = sumKnownCost(sessions);
+  const inputTokens = sum(sessions, "inputTokens");
+  const cachedInputTokens = sum(sessions, "cachedInputTokens");
+  return {
+    estimatedCostUsd: cost.knownCount > 0 ? cost.value : void 0,
+    knownCostSessions: cost.knownCount,
+    totalTokens: sum(sessions, "totalTokens"),
+    cachedInputTokens,
+    inputTokens,
+    outputTokens: sum(sessions, "outputTokens"),
+    reasoningTokens: sum(sessions, "reasoningTokens"),
+    cachedInputPct: inputTokens > 0 ? cachedInputTokens / inputTokens : 0,
+    sessionCount: sessions.length,
+    repoCount: repos.length,
+    modelCount: new Set(sessions.map((session) => session.model).filter(Boolean)).size,
+    mostExpensiveRepo: repos.filter((repo) => repo.estimatedCostUsd !== void 0).sort((a, b) => (b.estimatedCostUsd ?? 0) - (a.estimatedCostUsd ?? 0))[0],
+    unknownCostSessions: sessions.filter((session) => session.estimatedCostUsd === void 0).length,
+    userPromptCount: optionalSum(sessions, "userPromptCount"),
+    assistantMessageCount: optionalSum(sessions, "assistantMessageCount"),
+    toolCallCount: optionalSum(sessions, "toolCallCount"),
+    shellCommandCount: optionalSum(sessions, "shellCommandCount"),
+    failedToolCallCount: optionalSum(sessions, "failedToolCallCount"),
+    nonZeroCommandEvents: optionalSum(sessions, "nonZeroCommandEvents"),
+    importantCommandFailures: optionalSum(sessions, "importantCommandFailures"),
+    harmlessNonZeroEvents: optionalSum(sessions, "harmlessNonZeroEvents"),
+    exploratoryMisses: optionalSum(sessions, "exploratoryMisses"),
+    repeatedFailureClusters: optionalSum(sessions, "repeatedFailureClusters"),
+    fileReadCount: optionalSum(sessions, "fileReadCount"),
+    fileEditCount: optionalSum(sessions, "fileEditCount"),
+    rawEventCount: optionalSum(sessions, "rawEventCount"),
+    parseFailureCount: sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).length,
+    unknownSurfaceSessions: sessions.filter((session) => session.detectedSurface === "unknown").length,
+    noCodeChangeSessions: sessions.filter((session) => (session.fileEditCount ?? 0) === 0).length,
+    researchOnlySessions: sessions.filter((session) => session.sessionOutcome === "research_only").length,
+    warnings: unique(sessions.flatMap((session) => session.warnings))
+  };
+}
+function groupByRepo(sessions) {
+  return groupBy(sessions, (session) => session.repoRoot, (session) => session.repoName);
+}
+function groupByModel(sessions) {
+  return groupBy(sessions, (session) => session.model ?? "unknown-model", (session) => session.model ?? "Unknown model");
+}
+function groupBySourceApp(sessions) {
+  return groupBy(sessions, (session) => session.sourceApp, (session) => session.sourceApp);
+}
+function groupByDay(sessions) {
+  return groupBy(sessions, (session) => dateKey(session.startedAt), (session) => dateKey(session.startedAt));
+}
+function groupByHour(sessions) {
+  return groupBy(sessions, (session) => hourKey(session.startedAt), (session) => hourKey(session.startedAt));
+}
+function groupBy(sessions, keyFn, labelFn) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const id = keyFn(session);
+    const existing = groups.get(id);
+    const group = existing ?? {
+      id,
+      label: labelFn(session),
+      estimatedCostUsd: void 0,
+      inputTokens: 0,
+      cachedInputTokens: 0,
+      outputTokens: 0,
+      reasoningTokens: 0,
+      totalTokens: 0,
+      sessionCount: 0,
+      messageCount: 0,
+      warnings: []
+    };
+    group.inputTokens += session.inputTokens;
+    group.cachedInputTokens += session.cachedInputTokens;
+    group.outputTokens += session.outputTokens;
+    group.reasoningTokens += session.reasoningTokens;
+    group.totalTokens += session.totalTokens;
+    group.sessionCount += 1;
+    group.messageCount += session.messageCount;
+    group.warnings = unique([...group.warnings, ...session.warnings]);
+    if (session.estimatedCostUsd !== void 0) {
+      group.estimatedCostUsd = roundCurrency((group.estimatedCostUsd ?? 0) + session.estimatedCostUsd);
+    }
+    groups.set(id, group);
+  }
+  return [...groups.values()].sort((a, b) => (b.estimatedCostUsd ?? 0) - (a.estimatedCostUsd ?? 0) || b.totalTokens - a.totalTokens);
+}
+function toCsv(sessions) {
+  const columns = [
+    "id",
+    "sourceClient",
+    "sourceApp",
+    "sourceAppRaw",
+    "sourcePath",
+    "repoRoot",
+    "repoName",
+    "cwd",
+    "gitRemoteUrl",
+    "gitBranch",
+    "title",
+    "startedAt",
+    "endedAt",
+    "model",
+    "provider",
+    "inputTokens",
+    "cachedInputTokens",
+    "outputTokens",
+    "reasoningTokens",
+    "reasoningOutputTokens",
+    "totalTokens",
+    "tokenAggregationMethod",
+    "tokenConfidence",
+    "tokenSnapshotCount",
+    "estimatedCostUsd",
+    "messageCount",
+    "rawTokenTotal",
+    "warnings",
+    "codexHome",
+    "durationMs",
+    "rawEventCount",
+    "parseStatus",
+    "parseErrors",
+    "detectedSurface",
+    "surfaceConfidence",
+    "surfaceReason",
+    "userPromptCount",
+    "assistantMessageCount",
+    "toolCallCount",
+    "shellCommandCount",
+    "failedToolCallCount",
+    "nonZeroCommandEvents",
+    "importantCommandFailures",
+    "harmlessNonZeroEvents",
+    "exploratoryMisses",
+    "repeatedFailureClusters",
+    "commandIssueSeverity",
+    "commandIssueImpact",
+    "topFailureType",
+    "fileReadCount",
+    "fileEditCount",
+    "sessionOutcome"
+  ];
+  const rows = sessions.map((session) => columns.map((column) => csvEscape(Array.isArray(session[column]) ? session[column].join(";") : session[column])));
+  return [columns.join(","), ...rows.map((row) => row.join(","))].join("\n");
+}
+function csvEscape(value) {
+  if (value === void 0 || value === null) return "";
+  const text = String(value);
+  return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function sum(sessions, key) {
+  return sessions.reduce((total, session) => total + session[key], 0);
+}
+function optionalSum(sessions, key) {
+  return sessions.reduce((total, session) => total + (session[key] ?? 0), 0);
+}
+function sumKnownCost(sessions) {
+  return sessions.reduce(
+    (state, session) => ({
+      value: roundCurrency(state.value + (session.estimatedCostUsd ?? 0)),
+      knownCount: state.knownCount + (session.estimatedCostUsd === void 0 ? 0 : 1)
+    }),
+    { value: 0, knownCount: 0 }
+  );
+}
+function dateKey(date) {
+  return date ? date.slice(0, 10) : "unknown-date";
+}
+function hourKey(date) {
+  if (!date) return "unknown-hour";
+  const parsed = new Date(date);
+  if (Number.isNaN(parsed.getTime())) return "unknown-hour";
+  return parsed.toISOString().slice(0, 13) + ":00:00.000Z";
+}
+function roundCurrency(value) {
+  return Number(value.toFixed(6));
+}
+function unique(values) {
+  return [...new Set(values)].sort();
+}
+
+// packages/core/src/config.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// packages/core/src/pricing.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var pricingInfo = {
+  sourceName: "OpenAI API pricing",
+  sourceUrl: "https://developers.openai.com/api/docs/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."
+};
+var defaultPricing = {
+  "gpt-5.5": { inputPerMillion: 5, cachedInputPerMillion: 0.5, outputPerMillion: 30, reasoningOutputPerMillion: 30 },
+  "gpt-5.5-pro": { inputPerMillion: 30, outputPerMillion: 180, reasoningOutputPerMillion: 180 },
+  "gpt-5.4": { inputPerMillion: 2.5, cachedInputPerMillion: 0.25, outputPerMillion: 15, reasoningOutputPerMillion: 15 },
+  "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.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 },
+  "gpt-5.2-pro": { inputPerMillion: 21, outputPerMillion: 168, reasoningOutputPerMillion: 168 },
+  "gpt-5.1": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, reasoningOutputPerMillion: 10 },
+  "gpt-5.1-chat-latest": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, reasoningOutputPerMillion: 10 },
+  "gpt-5.1-codex": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, reasoningOutputPerMillion: 10 },
+  "gpt-5.1-codex-max": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, reasoningOutputPerMillion: 10 },
+  "gpt-5": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, reasoningOutputPerMillion: 10 },
+  "gpt-5-chat-latest": { inputPerMillion: 1.25, cachedInputPerMillion: 0.125, outputPerMillion: 10, reasoningOutputPerMillion: 10 },
+  "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 }
+};
+function loadPricingTable(pricingPath) {
+  if (!pricingPath) {
+    return defaultPricing;
+  }
+  try {
+    const resolved = path.resolve(pricingPath);
+    return { ...defaultPricing, ...JSON.parse(fs.readFileSync(resolved, "utf8")) };
+  } catch {
+    return defaultPricing;
+  }
+}
+function resolvePricingPath(config = {}) {
+  return config.pricingPath ? path.resolve(repospendHome(), config.pricingPath) : path.join(repospendHome(), "pricing.json");
+}
+function savePricingTable(pricingPath, pricing) {
+  fs.mkdirSync(path.dirname(pricingPath), { recursive: true });
+  fs.writeFileSync(pricingPath, `${JSON.stringify(pricing, null, 2)}
+`);
+}
+function repospendHome() {
+  return process.env.REPOSPEND_HOME || path.join(os.homedir(), ".repospend");
+}
+function calculateCostUsd(usage, pricing) {
+  if (!usage.model) {
+    return void 0;
+  }
+  const modelPricing = pricing[usage.model] ?? pricing[usage.model.toLowerCase()];
+  if (!modelPricing) {
+    return void 0;
+  }
+  const billableInput = Math.max(usage.inputTokens - usage.cachedInputTokens, 0);
+  const cachedRate = modelPricing.cachedInputPerMillion ?? 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;
+  return Number(cost.toFixed(6));
+}
+
+// packages/core/src/config.ts
+function configPath() {
+  return path2.join(repospendHome(), "config.json");
+}
+function loadConfig() {
+  return loadConfigWithWarnings().config;
+}
+function loadConfigWithWarnings() {
+  const localConfigPath = configPath();
+  if (!fs2.existsSync(localConfigPath)) {
+    return { config: {}, warnings: [] };
+  }
+  try {
+    return { config: JSON.parse(fs2.readFileSync(localConfigPath, "utf8")), warnings: [] };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { config: {}, warnings: [`Unable to parse ${localConfigPath}: ${message}`] };
+  }
+}
+function normalizePathForMatch(inputPath) {
+  return path2.resolve(inputPath).replace(/\/+$/, "");
+}
+function aliasForPath(repoRoot, config) {
+  const resolvedRoot = normalizePathForMatch(repoRoot);
+  const match = config.repos?.find(
+    (repo) => repo.paths.some((repoPath) => {
+      const candidate = normalizePathForMatch(repoPath);
+      return resolvedRoot === candidate || resolvedRoot.startsWith(`${candidate}${path2.sep}`);
+    })
+  );
+  return match?.name;
+}
+
+// packages/core/src/filters.ts
+function filterUsage(sessions, filters) {
+  return sessions.filter((session) => {
+    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;
+    const startedAt = timestamp(session.startedAt);
+    const hasDateFilter = Boolean(filters.from || filters.to);
+    if (hasDateFilter && startedAt === void 0) return false;
+    const from = filters.from ? lowerBound(filters.from) : void 0;
+    const to = filters.to ? upperBound(filters.to) : void 0;
+    if (from !== void 0 && startedAt !== void 0 && startedAt < from) return false;
+    if (to !== void 0 && startedAt !== void 0 && startedAt > to) return false;
+    return true;
+  });
+}
+function matchesAny(value, filter) {
+  const values = filterValues(filter);
+  if (!values.length) return true;
+  return value !== void 0 && values.includes(value);
+}
+function matchesRepo(session, filter) {
+  const values = filterValues(filter);
+  if (!values.length) return true;
+  return values.includes(session.repoName) || values.includes(session.repoRoot);
+}
+function filterValues(filter) {
+  if (!filter) return [];
+  return Array.isArray(filter) ? filter.filter(Boolean) : filter.split(",").map((value) => value.trim()).filter(Boolean);
+}
+function timestamp(value) {
+  if (!value) return void 0;
+  const parsed = new Date(value).getTime();
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function lowerBound(value) {
+  return timestamp(value.includes("T") ? value : `${value}T00:00:00.000Z`);
+}
+function upperBound(value) {
+  return timestamp(value.includes("T") ? value : `${value}T23:59:59.999Z`);
+}
+
+// packages/core/src/repo-rollup.ts
+function buildRepoRollups(sessions) {
+  return groupByRepo(sessions).map((group) => {
+    const repoSessions = sessions.filter((session) => session.repoRoot === group.id);
+    return rollupFromGroup(group, repoSessions);
+  });
+}
+function rollupFromGroup(group, sessions) {
+  const fileEditCount = sessions.reduce((sum2, session) => sum2 + (session.fileEditCount ?? 0), 0);
+  const failedCommandCount = sessions.reduce((sum2, session) => sum2 + (session.importantCommandFailures ?? session.failedToolCallCount ?? 0), 0);
+  const tokenRoiTokensPerEdit = fileEditCount > 0 ? Math.round(group.totalTokens / fileEditCount) : void 0;
+  const warnings = unique2([...group.warnings, ...sessions.flatMap((session) => session.warnings), ...repoWarnings(group, sessions)]);
+  return {
+    ...group,
+    sessions,
+    warnings,
+    fileEditCount,
+    failedCommandCount,
+    tokenRoiTokensPerEdit,
+    tokenRoiLabel: tokenRoiTokensPerEdit === void 0 ? "No edits" : `${compactNumber(tokenRoiTokensPerEdit)} tokens / edit`,
+    tokenRoiTitle: tokenRoiTokensPerEdit === void 0 ? "Token ROI cannot be computed because no file edits were detected for this repo." : "Token ROI estimates how much useful engineering activity was produced per token. Lower tokens per edit is usually better."
+  };
+}
+function repoWarnings(group, sessions) {
+  const warnings = [];
+  if (sessions.some((session) => (session.fileEditCount ?? 0) === 0 && session.totalTokens >= 1e6)) warnings.push("high-token no-edit");
+  if (sessions.some((session) => (session.importantCommandFailures ?? session.failedToolCallCount ?? 0) > 0)) warnings.push("command issues");
+  if (group.estimatedCostUsd === void 0 && group.totalTokens > 0) warnings.push("unknown pricing");
+  if (group.inputTokens > 0 && group.cachedInputTokens / group.inputTokens < 0.1) warnings.push("low cache rate");
+  return warnings;
+}
+function compactNumber(value) {
+  return new Intl.NumberFormat(void 0, { maximumFractionDigits: 1, notation: "compact" }).format(value);
+}
+function unique2(values) {
+  return [...new Set(values)].sort();
+}
+
+// packages/core/src/usage-health.ts
+function buildUsageHealth(input) {
+  const signals = buildHealthSignals(input);
+  const affectedSessionCount = new Set(signals.flatMap((signal) => signal.affectedSessionIds)).size;
+  return {
+    keyInsights: buildKeyInsights(input),
+    signals,
+    wasteSignals: buildWasteSignals(input.sessions),
+    healthyCount: signals.filter((signal) => signal.tone === "good").length,
+    attentionCount: signals.filter((signal) => signal.tone === "attention").length,
+    criticalCount: signals.filter((signal) => signal.critical).length,
+    affectedSessionCount
+  };
+}
+function buildKeyInsights({ sessions, summary, repos, sourceApps }) {
+  const insights = [];
+  const topTokenRepo = [...repos].sort((a, b) => b.totalTokens - a.totalTokens)[0];
+  const topCostRepo = [...repos].filter((repo) => repo.estimatedCostUsd !== void 0).sort((a, b) => (b.estimatedCostUsd ?? 0) - (a.estimatedCostUsd ?? 0))[0];
+  const mostUsedApp = sourceApps[0];
+  const mostExpensiveSession = [...sessions].filter((session) => session.estimatedCostUsd !== void 0).sort((a, b) => (b.estimatedCostUsd ?? 0) - (a.estimatedCostUsd ?? 0))[0];
+  if (topTokenRepo) insights.push({ label: "Most-used repo", text: `${topTokenRepo.label} used the most tokens in this period.`, metric: tokens(topTokenRepo.totalTokens), tone: "neutral" });
+  if (topCostRepo) insights.push({ label: "Highest API-equivalent cost", text: `${topCostRepo.label} had the highest estimated API-equivalent cost.`, metric: money(topCostRepo.estimatedCostUsd), tone: "attention" });
+  if (summary.noCodeChangeSessions === 0 && summary.sessionCount > 0) {
+    insights.push({ label: "No-edit sessions", text: "No no-edit sessions were detected.", metric: "0", tone: "good" });
+  } else if (summary.noCodeChangeSessions > 0) {
+    insights.push({ label: "No-edit sessions", text: `${count(summary.noCodeChangeSessions, "session")} used tokens without detected file edits.`, metric: count(summary.noCodeChangeSessions, "session"), tone: "attention" });
+  }
+  if (mostUsedApp) insights.push({ label: "Most-used app", text: `${mostUsedApp.label} accounts for most detected local Codex usage.`, metric: tokens(mostUsedApp.totalTokens), tone: "neutral" });
+  if (summary.inputTokens > 0) {
+    const tone = summary.cachedInputPct >= 0.5 ? "good" : "attention";
+    insights.push({ label: "Cache reuse", text: `Cached input represents ${percent(summary.cachedInputPct)} of input tokens.`, metric: percent(summary.cachedInputPct), tone });
+  }
+  if (mostExpensiveSession) {
+    insights.push({ label: "Session to inspect", text: `The most expensive session was ${money(mostExpensiveSession.estimatedCostUsd)} API-equivalent.`, metric: money(mostExpensiveSession.estimatedCostUsd), tone: "attention" });
+  }
+  return insights.slice(0, 6);
+}
+function buildHealthSignals(input) {
+  const context = healthSignalContext(input);
+  return healthSignalDetectors.flatMap((detector) => {
+    const signal = detector.detect(context);
+    return signal ? [signal] : [];
+  });
+}
+function healthSignalContext(input) {
+  const { sessions, summary } = input;
+  const totalKnownCost = sessions.reduce((sum2, session) => sum2 + (session.estimatedCostUsd ?? 0), 0);
+  const topSession = [...sessions].filter((session) => session.estimatedCostUsd !== void 0).sort((a, b) => (b.estimatedCostUsd ?? 0) - (a.estimatedCostUsd ?? 0))[0];
+  const topSessionShare = topSession?.estimatedCostUsd && totalKnownCost > 0 ? topSession.estimatedCostUsd / totalKnownCost : 0;
+  const totals = tokenTotals(sessions);
+  return {
+    ...input,
+    topSession,
+    topSessionShare,
+    totals,
+    outputShare: totals.totalTokens > 0 ? totals.outputTokens / totals.totalTokens : 0,
+    unverifiedRepos: sessions.filter((session) => session.warnings.includes("repo_unverified_no_git_root")),
+    commandIssueSessions: sessions.filter((session) => importantCommandFailures(session) > 0),
+    unknownSurfaceSessions: sessions.filter((session) => session.detectedSurface === "unknown"),
+    unknownCostSessions: sessions.filter((session) => session.estimatedCostUsd === void 0),
+    parseFailureSessions: sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0),
+    noCodeSessions: sessions.filter((session) => session.fileEditCount === 0),
+    commandIssueRate: summary.shellCommandCount > 0 ? (summary.importantCommandFailures || summary.failedToolCallCount) / summary.shellCommandCount : 0,
+    noCodeRate: summary.sessionCount > 0 ? summary.noCodeChangeSessions / summary.sessionCount : 0
+  };
+}
+var healthSignalDetectors = [
+  {
+    id: "repo-grouping",
+    detect({ scan }) {
+      if (scan.repoCount <= 0) return void 0;
+      return {
+        id: "repo-grouping",
+        tone: "good",
+        title: "Repo grouping is working",
+        detail: `RepoSpend discovered ${count(scan.repoCount, "repo")} and merges nested working directories into repo roots.`,
+        metric: count(scan.sessionCount, "session"),
+        affectedSessionIds: []
+      };
+    }
+  },
+  {
+    id: "app-attribution",
+    detect({ scan }) {
+      if (scan.sourceAppCount <= 1) return void 0;
+      return {
+        id: "app-attribution",
+        tone: "good",
+        title: "App attribution is visible",
+        detail: `Usage is split across ${count(scan.sourceAppCount, "source app")}, so VS Code, terminal, and subagent activity can be compared.`,
+        metric: count(scan.sourceAppCount, "app"),
+        affectedSessionIds: []
+      };
+    }
+  },
+  {
+    id: "priced-sessions",
+    detect({ summary }) {
+      if (summary.unknownCostSessions !== 0 || summary.sessionCount <= 0) return void 0;
+      return {
+        id: "priced-sessions",
+        tone: "good",
+        title: "All loaded sessions are priced",
+        detail: "Every filtered session with tokens matched the local pricing table and has an API-equivalent cost estimate.",
+        metric: `${compactNumber2(summary.sessionCount)} priced`,
+        affectedSessionIds: []
+      };
+    }
+  },
+  {
+    id: "cache-reuse",
+    detect({ summary }) {
+      if (summary.cachedInputPct < 0.75) return void 0;
+      return {
+        id: "cache-reuse",
+        tone: "good",
+        title: "Cache reuse is strong",
+        detail: "Most input tokens are cached, which usually means repeated project context is being reused efficiently.",
+        metric: percent(summary.cachedInputPct),
+        affectedSessionIds: []
+      };
+    }
+  },
+  {
+    id: "token-roi-measurable",
+    detect({ summary }) {
+      if (summary.fileEditCount <= 0 || summary.totalTokens <= 0) return void 0;
+      return {
+        id: "token-roi-measurable",
+        tone: "good",
+        title: "Token ROI can be measured",
+        detail: "RepoSpend detected file edits in local events, so tokens per edit and no-edit sessions can be tracked.",
+        metric: `${tokens(Math.round(summary.totalTokens / summary.fileEditCount))} / edit`,
+        affectedSessionIds: []
+      };
+    }
+  },
+  {
+    id: "empty-filter",
+    detect({ summary }) {
+      if (summary.sessionCount !== 0) return void 0;
+      return {
+        id: "empty-filter",
+        tone: "attention",
+        title: "No sessions in this view",
+        detail: "The current filters do not include any token-bearing Codex sessions.",
+        action: "Widen the date range or clear repo, app, and model filters.",
+        affectedSessionIds: []
+      };
+    }
+  },
+  {
+    id: "command-friction",
+    detect({ commandIssueRate, commandIssueSessions }) {
+      if (commandIssueRate <= 0.2) return void 0;
+      return {
+        id: "command-friction",
+        tone: "attention",
+        title: "Important command issue rate looks high",
+        detail: `${percent(commandIssueRate)} of detected shell commands look like blocking, repeated, or token-expensive issues in this filtered view.`,
+        action: "Look for repeated setup, dependency, permission, test, or build issues in the Sessions page.",
+        actionTarget: "sessions",
+        actionLabel: "Open affected sessions",
+        metric: percent(commandIssueRate),
+        affectedSessionIds: commandIssueSessions.map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "no-code-sessions",
+    detect({ noCodeRate, noCodeSessions, summary }) {
+      if (noCodeRate <= 0.5 || summary.sessionCount < 3) return void 0;
+      return {
+        id: "no-code-sessions",
+        tone: "attention",
+        title: "Many sessions have no detected edits",
+        detail: `${count(summary.noCodeChangeSessions, "session")} used tokens without detected file edits.`,
+        action: "Some may be research-only, but high-token no-edit sessions are worth reviewing.",
+        actionTarget: "sessions",
+        actionLabel: "Open affected sessions",
+        metric: percent(noCodeRate),
+        affectedSessionIds: noCodeSessions.map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "unknown-surfaces",
+    detect({ unknownSurfaceSessions }) {
+      if (unknownSurfaceSessions.length === 0) return void 0;
+      return {
+        id: "unknown-surfaces",
+        tone: "attention",
+        title: "Some surfaces are unknown",
+        detail: `${count(unknownSurfaceSessions.length, "session")} did not expose enough local metadata to classify VS Code, terminal, exec, or app usage.`,
+        action: "Open Sessions and check the surface reason column for those sessions.",
+        actionTarget: "sessions",
+        actionLabel: "Open affected sessions",
+        metric: count(unknownSurfaceSessions.length, "session"),
+        affectedSessionIds: unknownSurfaceSessions.map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "parse-failures",
+    detect({ parseFailureSessions }) {
+      if (parseFailureSessions.length === 0) return void 0;
+      return {
+        id: "parse-failures",
+        tone: "attention",
+        title: "Some session files parsed partially",
+        detail: `${count(parseFailureSessions.length, "session")} had parse errors or unreadable local log data.`,
+        action: "Check Local Data Coverage and the Sessions parse column before trusting derived command/file metrics.",
+        actionTarget: "settings",
+        actionLabel: "View data sources",
+        metric: count(parseFailureSessions.length, "issue"),
+        critical: true,
+        affectedSessionIds: parseFailureSessions.map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "unknown-cost",
+    detect({ unknownCostSessions }) {
+      if (unknownCostSessions.length === 0) return void 0;
+      return {
+        id: "unknown-cost",
+        tone: "attention",
+        title: "Some sessions cannot be priced",
+        detail: `${count(unknownCostSessions.length, "session")} are missing a model price or detailed token split.`,
+        action: "Open Settings and add model rates, or inspect older Codex sessions that only expose raw totals.",
+        actionTarget: "settings",
+        actionLabel: "Open settings",
+        metric: count(unknownCostSessions.length, "session"),
+        critical: true,
+        affectedSessionIds: unknownCostSessions.map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "low-cache",
+    detect({ sessions, summary, totals }) {
+      if (totals.inputTokens <= 0 || summary.cachedInputPct >= 0.5) return void 0;
+      return {
+        id: "low-cache",
+        tone: "attention",
+        title: "Cache rate could be better",
+        detail: "A low cached-input share usually means repeated context is being resent as fresh input.",
+        action: "Prefer continuing existing sessions for related work and avoid repeatedly pasting large project context.",
+        metric: percent(summary.cachedInputPct),
+        affectedSessionIds: sessions.map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "output-heavy",
+    detect({ outputShare, sessions }) {
+      if (outputShare <= 0.35) return void 0;
+      return {
+        id: "output-heavy",
+        tone: "attention",
+        title: "Output-heavy sessions are driving tokens",
+        detail: "A large share of tokens are assistant output, which can happen with broad generation, long reviews, or verbose command output.",
+        action: "Ask for concise diffs, summaries, or scoped files when the task does not need full output.",
+        metric: percent(outputShare),
+        affectedSessionIds: sessions.filter((session) => session.outputTokens / Math.max(session.totalTokens, 1) > 0.35).map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "cost-concentration",
+    detect({ topSession, topSessionShare }) {
+      if (topSessionShare <= 0.35 || !topSession) return void 0;
+      return {
+        id: "cost-concentration",
+        tone: "attention",
+        title: "Spend is concentrated in one session",
+        detail: `"${topSession.title ?? topSession.id}" accounts for a large share of estimated API-equivalent cost in this view.`,
+        action: "Inspect that session and consider splitting very broad work into smaller passes.",
+        metric: percent(topSessionShare),
+        affectedSessionIds: [topSession.id]
+      };
+    }
+  },
+  {
+    id: "unverified-repos",
+    detect({ unverifiedRepos }) {
+      if (unverifiedRepos.length === 0) return void 0;
+      return {
+        id: "unverified-repos",
+        tone: "attention",
+        title: "Some repos are unverified",
+        detail: `${count(unverifiedRepos.length, "session")} did not resolve to a Git root, so grouping may be less precise.`,
+        action: "Add repo aliases in repospend.config.json or run Codex from inside Git worktrees.",
+        actionTarget: "settings",
+        actionLabel: "View data sources",
+        metric: count(unverifiedRepos.length, "session"),
+        affectedSessionIds: unverifiedRepos.map((session) => session.id)
+      };
+    }
+  },
+  {
+    id: "zero-token-skipped",
+    detect({ scan }) {
+      if (scan.zeroTokenSessionCount <= 0) return void 0;
+      return {
+        id: "zero-token-skipped",
+        tone: "attention",
+        title: "Zero-token placeholders were skipped",
+        detail: `${count(scan.zeroTokenSessionCount, "local Codex record")} had no token usage and were excluded from analytics.`,
+        action: "This is usually harmless, but it explains why raw local session counts may differ from dashboard counts.",
+        metric: `${compactNumber2(scan.zeroTokenSessionCount)} skipped`,
+        affectedSessionIds: []
+      };
+    }
+  }
+];
+function buildWasteSignals(sessions) {
+  return wasteSignalDetectors.flatMap((detector) => {
+    const signal = detector.detect(sessions);
+    return signal ? [signal] : [];
+  });
+}
+var wasteSignalDetectors = [
+  wasteSignalDetector("high-token-no-edit", "High-token no-edit sessions", "Large sessions where local events did not show file edits.", (session) => (session.fileEditCount ?? 0) === 0 && session.totalTokens >= 1e6),
+  wasteSignalDetector("high-token-low-output", "High-token low-output sessions", "Large sessions where most tokens were input or cached context.", (session) => session.totalTokens >= 1e6 && session.outputTokens / Math.max(session.totalTokens, 1) < 0.03),
+  wasteSignalDetector("command-issue-sessions", "Command issue sessions", "Sessions with blocking, repeated, or token-expensive command issues.", (session) => importantCommandFailures(session) > 0),
+  wasteSignalDetector("unknown-repos", "Unknown repo sessions", "Repo root could not be verified from local Git metadata.", (session) => session.warnings.includes("repo_unverified_no_git_root")),
+  wasteSignalDetector("unknown-surfaces", "Unknown surface sessions", "Local logs did not identify VS Code, terminal, exec, or app surface.", (session) => (session.detectedSurface ?? "unknown") === "unknown"),
+  wasteSignalDetector("repeated-errors", "Repeated error signals", "Repeated-error hints found in session warnings.", (session) => session.warnings.some((warning) => warning.includes("repeated_error")))
+];
+function wasteSignalDetector(id, title, detail, matches) {
+  return {
+    id,
+    detect(sessions) {
+      const affected = sessions.filter(matches);
+      if (affected.length === 0) return void 0;
+      return {
+        id,
+        title,
+        value: count(affected.length, "session"),
+        detail,
+        tone: "attention",
+        affectedSessionIds: affected.map((session) => session.id)
+      };
+    }
+  };
+}
+function importantCommandFailures(session) {
+  return session.importantCommandFailures ?? session.failedToolCallCount ?? 0;
+}
+function tokenTotals(sessions) {
+  return sessions.reduce(
+    (totals, session) => ({
+      inputTokens: totals.inputTokens + session.inputTokens,
+      cachedInputTokens: totals.cachedInputTokens + session.cachedInputTokens,
+      outputTokens: totals.outputTokens + session.outputTokens,
+      reasoningTokens: totals.reasoningTokens + session.reasoningTokens,
+      totalTokens: totals.totalTokens + session.totalTokens
+    }),
+    { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningTokens: 0, totalTokens: 0 }
+  );
+}
+function money(value) {
+  if (value === void 0) return "Not priced";
+  if (value > 0 && value < 0.01) return "<$0.01 USD";
+  return `${currency(value, 2, 2)} USD`;
+}
+function tokens(value) {
+  return `${compactNumber2(value)} ${pluralize("token", value)}`;
+}
+function count(value, noun) {
+  return `${compactNumber2(value)} ${pluralize(noun, value)}`;
+}
+function percent(value) {
+  return `${new Intl.NumberFormat(void 0, { maximumFractionDigits: 1 }).format(value * 100)}%`;
+}
+function compactNumber2(value) {
+  return new Intl.NumberFormat(void 0, { maximumFractionDigits: 1, notation: "compact" }).format(value);
+}
+function currency(value, minimumFractionDigits, maximumFractionDigits) {
+  return `$${new Intl.NumberFormat(void 0, { maximumFractionDigits, minimumFractionDigits }).format(value)}`;
+}
+function pluralize(noun, value) {
+  if (value === 1) return noun;
+  if (noun.endsWith("s")) return noun;
+  return `${noun}s`;
+}
+
+// packages/core/src/dashboard.ts
+function buildDashboardSnapshot(input) {
+  const allSessions = input.sessions.filter((session) => session.totalTokens > 0);
+  const filteredSessions = filterUsage(input.sessions, input.filters ?? {});
+  const sessions = filteredSessions.filter((session) => session.totalTokens > 0);
+  const summary = summarize(sessions);
+  const repos = buildRepoRollups(sessions);
+  const sourceApps = groupBySourceApp(sessions);
+  const scan = {
+    sessionCount: allSessions.length,
+    zeroTokenSessionCount: input.sessions.length - allSessions.length,
+    repoCount: buildRepoRollups(allSessions).length,
+    modelCount: groupByModel(allSessions).length,
+    sourceAppCount: groupBySourceApp(allSessions).length,
+    rawSessionCount: input.sessions.length,
+    rawEventCount: allSessions.reduce((sum2, session) => sum2 + (session.rawEventCount ?? 0), 0),
+    parseFailureCount: allSessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).length,
+    sessionFileCount: input.sourceStats.reduce((sum2, source) => sum2 + source.sessionFileCount, 0),
+    lastScannedAt: input.sourceStats.map((source) => source.lastScannedAt).sort().at(-1) ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    sources: input.sources,
+    sourceStats: input.sourceStats,
+    scan,
+    sessions,
+    skippedZeroTokenSessions: filteredSessions.length - sessions.length,
+    summary,
+    repos,
+    days: groupByDay(sessions),
+    hours: groupByHour(sessions),
+    models: groupByModel(sessions),
+    sourceApps,
+    health: buildUsageHealth({ sessions, summary, repos, sourceApps, scan })
+  };
+}
+
+// packages/core/src/repo.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+function findGitRoot(cwd, fileSystem = fs3) {
+  let current = path3.resolve(cwd);
+  while (true) {
+    const gitPath = path3.join(current, ".git");
+    if (fileSystem.existsSync(gitPath)) {
+      try {
+        const stat = fileSystem.statSync(gitPath);
+        if (stat.isDirectory() || stat.isFile()) {
+          return current;
+        }
+      } catch {
+        return current;
+      }
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function resolveRepoInfo(cwd, config = {}, fileSystem = fs3) {
+  const warnings = [];
+  const gitRoot = safeFindGitRoot(cwd, fileSystem);
+  const repoRoot = gitRoot ?? fallbackWorkspaceRoot(cwd);
+  const alias = aliasForPath(repoRoot, config);
+  const repoName = alias ?? (path3.basename(repoRoot) || "unknown-workspace");
+  const gitMeta = gitRoot ? readGitMetadata(gitRoot, fileSystem) : { remote: void 0, branch: void 0 };
+  if (!gitRoot) {
+    warnings.push("repo_unverified_no_git_root");
+  }
+  return {
+    repoRoot,
+    repoName,
+    gitRemoteUrl: gitMeta.remote,
+    gitBranch: gitMeta.branch,
+    verified: Boolean(gitRoot),
+    warnings
+  };
+}
+function safeFindGitRoot(cwd, fileSystem) {
+  try {
+    return findGitRoot(cwd, fileSystem);
+  } catch {
+    return void 0;
+  }
+}
+function fallbackWorkspaceRoot(cwd) {
+  const resolved = path3.resolve(cwd || process.cwd());
+  const home = process.env.HOME ? 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];
+    return first ? path3.join(home, first) : home;
+  }
+  const parts = resolved.split(path3.sep).filter(Boolean);
+  return `${path3.sep}${parts.slice(0, Math.min(parts.length, 3)).join(path3.sep)}`;
+}
+function readGitMetadata(repoRoot, fileSystem) {
+  const gitPath = path3.join(repoRoot, ".git");
+  try {
+    const stat = fileSystem.statSync(gitPath);
+    const gitDir = stat.isFile() ? resolveGitFile(repoRoot, fileSystem.readFileSync(gitPath, "utf8")) : gitPath;
+    const configPath2 = path3.join(gitDir, "config");
+    const headPath = path3.join(gitDir, "HEAD");
+    const remote = fileSystem.existsSync(configPath2) ? parseRemote(fileSystem.readFileSync(configPath2, "utf8")) : void 0;
+    const branch = fileSystem.existsSync(headPath) ? parseBranch(fileSystem.readFileSync(headPath, "utf8")) : void 0;
+    return { remote, branch };
+  } catch {
+    return { remote: void 0, branch: void 0 };
+  }
+}
+function resolveGitFile(repoRoot, contents) {
+  const match = contents.match(/^gitdir:\s*(.+)$/m);
+  if (!match?.[1]) {
+    return path3.join(repoRoot, ".git");
+  }
+  return path3.resolve(repoRoot, match[1].trim());
+}
+function parseRemote(config) {
+  const originMatch = config.match(/\[remote "origin"\][\s\S]*?\n\s*url\s*=\s*(.+)/);
+  return originMatch?.[1]?.trim();
+}
+function parseBranch(head) {
+  const match = head.trim().match(/^ref:\s+refs\/heads\/(.+)$/);
+  return match?.[1] ?? head.trim().slice(0, 12);
+}
+
+// packages/core/src/sources/codex.ts
+import fs4 from "node:fs";
+import os2 from "node:os";
+import path4 from "node:path";
+import Database from "better-sqlite3";
+
+// packages/core/src/sources/agent-friction.ts
+function analyzeAgentFriction(records, totalTokens) {
+  const analysis = emptyAgentFrictionAnalysis();
+  for (const record of records) {
+    applyActionMetadata(analysis, record);
+  }
+  finalizeCommandIssues(analysis, totalTokens);
+  return analysis;
+}
+function emptyAgentFrictionAnalysis() {
+  return {
+    commandIssues: [],
+    shellCommandCount: 0,
+    failedToolCallCount: 0,
+    nonZeroCommandEvents: 0,
+    importantCommandFailures: 0,
+    harmlessNonZeroEvents: 0,
+    exploratoryMisses: 0,
+    repeatedFailureClusters: 0,
+    commandIssueSeverity: "none",
+    commandIssueImpact: "none",
+    topFailureType: void 0,
+    commandIssueSamples: [],
+    fileReadCount: 0,
+    fileEditCount: 0,
+    toolCallCount: 0,
+    userPromptCount: 0,
+    assistantMessageCount: 0
+  };
+}
+function applyActionMetadata(analysis, record) {
+  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 text = JSON.stringify(record).toLowerCase();
+  const isTool = type?.includes("tool") || type?.includes("function_call") || text.includes('"tool_call"') || text.includes('"function_call"');
+  if (isTool) analysis.toolCallCount += 1;
+  const isNonZeroCommand = text.includes("exit_code") && !text.includes('"exit_code":0') && !text.includes('"exit_code": 0');
+  if (isNonZeroCommand) analysis.commandIssues.push(classifyCommandIssue(record, analysis.commandIssues));
+  if (/\b(exec_command|shell|bash|zsh|command)\b/.test(text)) analysis.shellCommandCount += 1;
+  if (/\b(read_file|view_image|cat |sed |rg |grep |open_file)\b/.test(text)) analysis.fileReadCount += 1;
+  if (/\b(apply_patch|write_file|edit|patch|created|deleted)\b/.test(text)) analysis.fileEditCount += 1;
+}
+function 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 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";
+      }
+    }
+  }
+  if (totalTokens >= 1e6 && analysis.commandIssues.length >= 5) {
+    for (const issue of analysis.commandIssues) {
+      if (issue.severity === "warning") issue.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.failedToolCallCount = analysis.importantCommandFailures;
+  analysis.commandIssueSeverity = strongestSeverity(analysis.commandIssues);
+  analysis.commandIssueImpact = strongestImpact(analysis.commandIssues);
+  analysis.topFailureType = topFailureType(analysis.commandIssues);
+  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)
+  }));
+}
+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;
+  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.";
+  return "Non-zero command event with limited local context.";
+}
+function classifyCommandIssue(record, previousIssues) {
+  const raw = JSON.stringify(record);
+  const text = raw.toLowerCase();
+  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;
+  if (isHarmlessNonZero(text)) {
+    return { command: commandKey, category, classification: isExploratoryMiss(text) ? "exploratory_miss" : "harmless_nonzero", severity: "ignored", impact: "low" };
+  }
+  if (isImportantFailure(text, category) || repeated) {
+    return { command: commandKey, category, classification: "blocking_failure", severity: repeated ? "critical" : importantSeverity(text, category), impact: repeated ? "high" : importantImpact(category) };
+  }
+  if (category === "search" || category === "filesystem") {
+    return { command: commandKey, category, classification: "exploratory_miss", severity: "ignored", impact: "low" };
+  }
+  return { command: commandKey, category, classification: "unknown", severity: "info", impact: "low" };
+}
+function isHarmlessNonZero(text) {
+  return /\b(rg|grep)\b/.test(text) || /git\s+(diff|status)/.test(text) || /\bfind\b/.test(text) || /\btest\s+(-f|-d|-e)\b/.test(text) || /\b(ls|cat)\b/.test(text) && /(optional|exists|existence|not found|no such file)/.test(text);
+}
+function isExploratoryMiss(text) {
+  return /\b(rg|grep|find)\b/.test(text) || /(no matches|not found|no such file|existence)/.test(text);
+}
+function isImportantFailure(text, category) {
+  return category === "install" || category === "build" || category === "test" || category === "lint" || category === "typecheck" || category === "deploy" || category === "database" || category === "auth_env" || /(command not found|permission denied|authentication|unauthorized|missing environment|missing env|database connection|connection refused|deployment failed|tsc\b|vite build|next build)/.test(text);
+}
+function commandCategory(text) {
+  if (/\b(pnpm|npm|yarn|bun)\s+(install|add|i)\b/.test(text)) return "install";
+  if (/\b(pnpm|npm|yarn|bun)\s+[^"']*build\b|\b(vite|next)\s+build\b/.test(text)) return "build";
+  if (/\b(pnpm|npm|yarn|bun)\s+[^"']*test\b|\b(vitest|jest|playwright)\b/.test(text)) return "test";
+  if (/\b(pnpm|npm|yarn|bun)\s+[^"']*lint\b|\beslint\b/.test(text)) return "lint";
+  if (/\b(pnpm|npm|yarn|bun)\s+[^"']*typecheck\b|\btsc\b/.test(text)) return "typecheck";
+  if (/\b(vercel|deploy|netlify|railway|flyctl)\b/.test(text)) return "deploy";
+  if (/\bgit\b/.test(text)) return "git";
+  if (/\b(rg|grep|find)\b/.test(text)) return "search";
+  if (/\b(ls|cat|sed|test|stat|mkdir|rm|cp|mv)\b/.test(text)) return "filesystem";
+  if (/\b(pnpm|npm|yarn|bun|npx)\b/.test(text)) return "package_manager";
+  if (/\b(dev|serve|localhost|vite --host|next dev)\b/.test(text)) return "dev_server";
+  if (/\b(sqlite|postgres|mysql|database|db:|prisma|drizzle)\b/.test(text)) return "database";
+  if (/\b(auth|token|api key|environment variable|env var|permission denied|unauthorized)\b/.test(text)) return "auth_env";
+  return "unknown";
+}
+function importantSeverity(text, category) {
+  if (category === "deploy" || category === "database" || category === "auth_env" || /(command not found|permission denied|authentication|unauthorized)/.test(text)) return "critical";
+  return "warning";
+}
+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";
+  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";
+  return "none";
+}
+function topFailureType(issues) {
+  const important = issues.filter((issue) => issue.severity === "critical" || issue.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);
+  return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+}
+function extractCommandText(record) {
+  if (!record || typeof record !== "object") return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [record];
+  while (stack.length) {
+    const current = stack.pop();
+    if (!current || typeof current !== "object" || seen.has(current)) continue;
+    seen.add(current);
+    const object = current;
+    for (const key of ["command", "cmd", "argv", "args"]) {
+      const value = object[key];
+      if (typeof value === "string" && value.length) return value;
+      if (Array.isArray(value) && value.every((item) => typeof item === "string")) return value.join(" ");
+    }
+    stack.push(...Object.values(object));
+  }
+  return void 0;
+}
+function normalizeCommand(command2) {
+  return command2.replace(/\s+/g, " ").trim().slice(0, 160) || "unknown";
+}
+function compactCommandText(text) {
+  return normalizeCommand(text.toLowerCase().replace(/\\n/g, " ").slice(0, 160));
+}
+function firstObject(...values) {
+  return values.find((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// packages/core/src/sources/codex-token.ts
+function aggregateTokens(records) {
+  const accumulator = emptyTokenAccumulator();
+  for (const record of records) {
+    collectRecordTokens(accumulator, record);
+  }
+  finalizeTokenAccumulator(accumulator);
+  return {
+    inputTokens: accumulator.inputTokens,
+    cachedInputTokens: accumulator.cachedInputTokens,
+    outputTokens: accumulator.outputTokens,
+    reasoningTokens: accumulator.reasoningTokens,
+    totalTokens: accumulator.totalTokens,
+    tokenAggregationMethod: accumulator.tokenAggregationMethod,
+    tokenConfidence: accumulator.tokenConfidence,
+    tokenSnapshotCount: accumulator.tokenSnapshotCount,
+    warnings: accumulator.warnings
+  };
+}
+function emptyTokenAccumulator() {
+  return {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    tokenAggregationMethod: "unknown",
+    tokenConfidence: "low",
+    tokenSnapshotCount: 0,
+    warnings: [],
+    cumulativeTokenSnapshots: [],
+    directTokenUsages: []
+  };
+}
+function collectRecordTokens(accumulator, record) {
+  const usage = extractRecordTokens(record);
+  if (!usage) return;
+  accumulator.tokenSnapshotCount += 1;
+  if (usage.cumulative) {
+    accumulator.cumulativeTokenSnapshots.push(usage);
+  } else {
+    accumulator.directTokenUsages.push(usage);
+  }
+}
+function finalizeTokenAccumulator(accumulator) {
+  const invalidSnapshots = [...accumulator.cumulativeTokenSnapshots, ...accumulator.directTokenUsages].filter((usage) => !isValidTokenUsage(usage)).length;
+  if (invalidSnapshots > 0) accumulator.warnings.push(`invalid_token_snapshots:${invalidSnapshots}`);
+  const cumulative = accumulator.cumulativeTokenSnapshots.filter((snapshot) => isValidTokenUsage(snapshot));
+  if (cumulative.length > 0) {
+    const finalSnapshot = cumulative.reduce((best, snapshot) => snapshot.totalTokens >= best.totalTokens ? snapshot : best, cumulative[0]);
+    applyFinalUsage(accumulator, finalSnapshot);
+    accumulator.tokenAggregationMethod = "final_snapshot";
+    accumulator.tokenConfidence = "high";
+    if (accumulator.directTokenUsages.length > 0) accumulator.warnings.push("token_direct_usage_ignored_after_cumulative_snapshot");
+    return;
+  }
+  const direct = accumulator.directTokenUsages.filter((usage) => isValidTokenUsage(usage));
+  if (direct.length > 0) {
+    const total = direct.reduce(
+      (sum2, usage) => ({
+        inputTokens: sum2.inputTokens + usage.inputTokens,
+        cachedInputTokens: sum2.cachedInputTokens + usage.cachedInputTokens,
+        outputTokens: sum2.outputTokens + usage.outputTokens,
+        reasoningTokens: sum2.reasoningTokens + usage.reasoningTokens,
+        totalTokens: sum2.totalTokens + usage.totalTokens
+      }),
+      { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningTokens: 0, totalTokens: 0 }
+    );
+    applyFinalUsage(accumulator, total);
+    accumulator.tokenAggregationMethod = "direct_usage";
+    accumulator.tokenConfidence = "medium";
+    return;
+  }
+  accumulator.tokenAggregationMethod = "unknown";
+  accumulator.tokenConfidence = "low";
+}
+function extractRecordTokens(record) {
+  if (!record || typeof record !== "object") return void 0;
+  const object = record;
+  const payload = firstObject2(object.payload);
+  const payloadInfo = firstObject2(payload?.info);
+  const codexTotalUsage = firstObject2(payloadInfo?.total_token_usage);
+  if (codexTotalUsage) {
+    return tokenUsageFromObject(codexTotalUsage, true);
+  }
+  const response = firstObject2(object.response);
+  const usage = firstObject2(object.usage, object.token_usage, object.tokens, response?.usage, payload?.usage, payload?.token_usage, payload?.tokens);
+  return tokenUsageFromObject(usage ?? object, false);
+}
+function tokenUsageFromObject(target, cumulative) {
+  const input = numberFromKeys(target, ["input_tokens", "inputTokens", "prompt_tokens", "promptTokens"]);
+  const cached = numberFromKeys(target, ["cached_input_tokens", "cachedInputTokens", "cached_tokens", "cachedTokens", "cache_read_input_tokens"]);
+  const outputWithReasoning = numberFromKeys(target, ["output_tokens", "outputTokens", "completion_tokens", "completionTokens"]);
+  const reasoning = numberFromKeys(target, ["reasoning_tokens", "reasoningTokens", "reasoning_output_tokens", "reasoningOutputTokens"]);
+  const output = Math.max(outputWithReasoning - reasoning, 0);
+  const total = numberFromKeys(target, ["total_tokens", "totalTokens", "tokens_used", "tokensUsed"]);
+  if (input + cached + output + reasoning + total === 0) return void 0;
+  return {
+    inputTokens: input,
+    cachedInputTokens: cached,
+    outputTokens: output,
+    reasoningTokens: reasoning,
+    totalTokens: total || input + output + reasoning,
+    cumulative
+  };
+}
+function applyFinalUsage(accumulator, usage) {
+  accumulator.inputTokens = usage.inputTokens;
+  accumulator.cachedInputTokens = usage.cachedInputTokens;
+  accumulator.outputTokens = usage.outputTokens;
+  accumulator.reasoningTokens = usage.reasoningTokens;
+  accumulator.totalTokens = usage.totalTokens || usage.inputTokens + usage.outputTokens + usage.reasoningTokens;
+}
+function isValidTokenUsage(usage) {
+  return usage.inputTokens >= 0 && usage.cachedInputTokens >= 0 && usage.outputTokens >= 0 && usage.reasoningTokens >= 0 && usage.totalTokens >= 0;
+}
+function firstObject2(...values) {
+  return values.find((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
+}
+function numberFromKeys(object, keys) {
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && Number.isFinite(Number(value))) return Number(value);
+  }
+  return 0;
+}
+
+// packages/core/src/sources/codex.ts
+function scanCodex(options) {
+  const codexHome = options.codexHome ?? path4.join(os2.homedir(), ".codex");
+  const statePath = path4.join(codexHome, "state_5.sqlite");
+  const sessionsPath = path4.join(codexHome, "sessions");
+  const warnings = [];
+  const sessions = [];
+  const stateExists = fs4.existsSync(statePath);
+  const sessionsExists = fs4.existsSync(sessionsPath);
+  if (!stateExists) {
+    warnings.push(`Codex SQLite state not found at ${statePath}`);
+  }
+  if (!sessionsExists) {
+    warnings.push(`Codex sessions directory not found at ${sessionsPath}`);
+  }
+  const sessionFiles = sessionsExists ? indexSessionFiles(sessionsPath, warnings) : /* @__PURE__ */ new Map();
+  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));
+  }
+  return {
+    source: {
+      id: "codex",
+      label: "Codex",
+      available: stateExists || sessionsExists,
+      paths: [statePath, sessionsPath],
+      warnings
+    },
+    sessions,
+    stats: {
+      codexHome,
+      statePath,
+      sessionsPath,
+      stateExists,
+      sessionsExists,
+      sessionFileCount: sessionFiles.size,
+      sessionsImported: sessions.length,
+      parseFailureCount: sessions.filter((session) => session.parseStatus === "failed").length,
+      unreadableFileCount: sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("unable_to_read_session_file:"))).length,
+      lastScannedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function readThreads(statePath, sessionFiles, options, warnings) {
+  let db;
+  try {
+    db = new Database(statePath, { readonly: true, fileMustExist: true });
+    const tableNames = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+    if (!tableNames.some((table) => table.name === "threads")) {
+      warnings.push("Codex SQLite state does not contain a threads table.");
+      return [];
+    }
+    const columns = db.prepare("PRAGMA table_info(threads)").all().map((column) => column.name);
+    const selectedColumns = ["id", "rollout_path", "created_at", "updated_at", "cwd", "title", "model_provider", "model", "tokens_used", "source", "thread_source"].filter((column) => columns.includes(column));
+    if (!selectedColumns.length) {
+      warnings.push("Codex threads table has no recognized columns.");
+      return [];
+    }
+    const rows = db.prepare(`SELECT ${selectedColumns.map((column) => `"${column}"`).join(", ")} FROM threads`).all();
+    return rows.map((row, index) => threadToUsage(row, index, sessionFiles, options));
+  } catch (error) {
+    warnings.push(`Unable to read Codex SQLite state at ${statePath}: ${errorMessage(error)}`);
+    return [];
+  } finally {
+    db?.close();
+  }
+}
+function threadToUsage(row, index, sessionFiles, options) {
+  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 repo = resolveRepoInfo(cwd, options.config);
+  const inputTokens = sessionBreakdown.inputTokens;
+  const cachedInputTokens = sessionBreakdown.cachedInputTokens;
+  const outputTokens = sessionBreakdown.outputTokens;
+  const reasoningTokens = sessionBreakdown.reasoningTokens;
+  const totalTokens = sessionBreakdown.totalTokens || dbTokens || inputTokens + cachedInputTokens + outputTokens + reasoningTokens;
+  const hasPricedBreakdown = inputTokens + cachedInputTokens + outputTokens + reasoningTokens > 0;
+  const warnings = [...repo.warnings, ...sessionBreakdown.warnings];
+  const threadSource = stringValue2(row.thread_source) ?? sessionBreakdown.threadSource;
+  const sourceAppRaw = stringValue2(row.source) ?? sessionBreakdown.source ?? sessionBreakdown.originator ?? threadSource;
+  const surface = detectSurface(sourceAppRaw, threadSource);
+  const usage = {
+    id: stringValue2(row.id) ?? `codex-thread-${index}`,
+    sourceClient: "codex",
+    sourceApp: codexSourceAppLabel(sourceAppRaw, threadSource),
+    sourceAppRaw,
+    sourcePath,
+    repoRoot: repo.repoRoot,
+    repoName: repo.repoName,
+    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),
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    reasoningTokens,
+    reasoningOutputTokens: reasoningTokens,
+    totalTokens,
+    tokenAggregationMethod: sessionBreakdown.tokenAggregationMethod === "unknown" && dbTokens > 0 ? "estimated" : sessionBreakdown.tokenAggregationMethod,
+    tokenConfidence: sessionBreakdown.tokenAggregationMethod === "unknown" && dbTokens > 0 ? "low" : sessionBreakdown.tokenConfidence,
+    tokenSnapshotCount: sessionBreakdown.tokenSnapshotCount,
+    estimatedCostUsd: void 0,
+    messageCount: sessionBreakdown.messageCount,
+    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)),
+    rawEventCount: sessionBreakdown.rawEventCount,
+    parseStatus: sessionBreakdown.parseStatus,
+    parseErrors: sessionBreakdown.parseErrors,
+    detectedSurface: surface.surface,
+    surfaceConfidence: surface.confidence,
+    surfaceReason: surface.reason,
+    userPromptCount: sessionBreakdown.userPromptCount,
+    assistantMessageCount: sessionBreakdown.assistantMessageCount,
+    toolCallCount: sessionBreakdown.toolCallCount,
+    shellCommandCount: sessionBreakdown.shellCommandCount,
+    failedToolCallCount: sessionBreakdown.failedToolCallCount,
+    nonZeroCommandEvents: sessionBreakdown.nonZeroCommandEvents,
+    importantCommandFailures: sessionBreakdown.importantCommandFailures,
+    harmlessNonZeroEvents: sessionBreakdown.harmlessNonZeroEvents,
+    exploratoryMisses: sessionBreakdown.exploratoryMisses,
+    repeatedFailureClusters: sessionBreakdown.repeatedFailureClusters,
+    commandIssueSeverity: sessionBreakdown.commandIssueSeverity,
+    commandIssueImpact: sessionBreakdown.commandIssueImpact,
+    topFailureType: sessionBreakdown.topFailureType,
+    commandIssueSamples: sessionBreakdown.commandIssueSamples,
+    fileReadCount: sessionBreakdown.fileReadCount,
+    fileEditCount: sessionBreakdown.fileEditCount,
+    promptTimeline: sessionBreakdown.promptTimeline,
+    sessionOutcome: inferOutcome(sessionBreakdown)
+  };
+  const cost = hasPricedBreakdown ? calculateCostUsd(usage, options.pricing) : void 0;
+  const costWarnings = hasPricedBreakdown ? warnings : [...warnings, "missing_token_breakdown"];
+  return {
+    ...usage,
+    estimatedCostUsd: cost,
+    warnings: cost === void 0 ? [...costWarnings, "unknown_pricing"] : warnings
+  };
+}
+function readStandaloneSessions(sessionFiles, options) {
+  return [...sessionFiles.entries()].map(([id, sourcePath]) => {
+    const breakdown = readSessionBreakdown(sourcePath);
+    const cwd = fallbackCwdFromPath(sourcePath);
+    const repo = resolveRepoInfo(cwd, options.config);
+    const model = void 0;
+    const surface = detectSurface(breakdown.source ?? breakdown.originator, breakdown.threadSource);
+    return {
+      id,
+      sourceClient: "codex",
+      sourceApp: codexSourceAppLabel(breakdown.source ?? breakdown.originator, breakdown.threadSource),
+      sourceAppRaw: breakdown.source ?? breakdown.originator ?? breakdown.threadSource,
+      sourcePath,
+      repoRoot: repo.repoRoot,
+      repoName: repo.repoName,
+      cwd,
+      gitRemoteUrl: repo.gitRemoteUrl,
+      gitBranch: repo.gitBranch,
+      title: void 0,
+      startedAt: void 0,
+      endedAt: void 0,
+      model,
+      provider: void 0,
+      inputTokens: breakdown.inputTokens,
+      cachedInputTokens: breakdown.cachedInputTokens,
+      outputTokens: breakdown.outputTokens,
+      reasoningTokens: breakdown.reasoningTokens,
+      reasoningOutputTokens: breakdown.reasoningTokens,
+      totalTokens: breakdown.totalTokens,
+      tokenAggregationMethod: breakdown.tokenAggregationMethod,
+      tokenConfidence: breakdown.tokenConfidence,
+      tokenSnapshotCount: breakdown.tokenSnapshotCount,
+      estimatedCostUsd: void 0,
+      messageCount: breakdown.messageCount,
+      rawTokenTotal: breakdown.totalTokens || void 0,
+      warnings: [...repo.warnings, ...breakdown.warnings, "unknown_pricing"],
+      codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
+      rawEventCount: breakdown.rawEventCount,
+      parseStatus: breakdown.parseStatus,
+      parseErrors: breakdown.parseErrors,
+      detectedSurface: surface.surface,
+      surfaceConfidence: surface.confidence,
+      surfaceReason: surface.reason,
+      userPromptCount: breakdown.userPromptCount,
+      assistantMessageCount: breakdown.assistantMessageCount,
+      toolCallCount: breakdown.toolCallCount,
+      shellCommandCount: breakdown.shellCommandCount,
+      failedToolCallCount: breakdown.failedToolCallCount,
+      nonZeroCommandEvents: breakdown.nonZeroCommandEvents,
+      importantCommandFailures: breakdown.importantCommandFailures,
+      harmlessNonZeroEvents: breakdown.harmlessNonZeroEvents,
+      exploratoryMisses: breakdown.exploratoryMisses,
+      repeatedFailureClusters: breakdown.repeatedFailureClusters,
+      commandIssueSeverity: breakdown.commandIssueSeverity,
+      commandIssueImpact: breakdown.commandIssueImpact,
+      topFailureType: breakdown.topFailureType,
+      commandIssueSamples: breakdown.commandIssueSamples,
+      fileReadCount: breakdown.fileReadCount,
+      fileEditCount: breakdown.fileEditCount,
+      promptTimeline: breakdown.promptTimeline,
+      sessionOutcome: inferOutcome(breakdown)
+    };
+  });
+}
+function indexSessionFiles(sessionsPath, warnings) {
+  const files = /* @__PURE__ */ new Map();
+  try {
+    walk(sessionsPath, (filePath) => {
+      if (!/\.(jsonl|json|log)$/i.test(filePath)) return;
+      const id = path4.basename(filePath).replace(/\.(jsonl|json|log)$/i, "");
+      files.set(id, filePath);
+    });
+  } catch (error) {
+    warnings.push(`Unable to read Codex sessions at ${sessionsPath}: ${errorMessage(error)}`);
+  }
+  return files;
+}
+function walk(root, onFile) {
+  for (const entry of fs4.readdirSync(root, { withFileTypes: true })) {
+    const fullPath = path4.join(root, entry.name);
+    if (entry.isDirectory()) {
+      walk(fullPath, onFile);
+    } else if (entry.isFile()) {
+      onFile(fullPath);
+    }
+  }
+}
+function readSessionBreakdown(filePath) {
+  const breakdown = emptyBreakdown();
+  try {
+    const text = fs4.readFileSync(filePath, "utf8");
+    const parse = parseSessionRecords(text);
+    const records = parse.records;
+    breakdown.rawEventCount = records.length;
+    breakdown.parseErrors = parse.errors;
+    breakdown.parseStatus = parse.errors.length ? records.length ? "partial" : "failed" : "ok";
+    let eventMessageCount = 0;
+    let responseMessageCount = 0;
+    for (const record of records) {
+      applySessionMetadata(breakdown, record);
+      applyPromptTimeline(breakdown, record);
+      if (isCodexEventMessage(record)) eventMessageCount += 1;
+      if (isResponseMessage(record)) responseMessageCount += 1;
+    }
+    breakdown.messageCount = eventMessageCount || responseMessageCount;
+    const tokenAggregation = aggregateTokens(records);
+    Object.assign(breakdown, {
+      ...tokenAggregation,
+      warnings: [...breakdown.warnings, ...tokenAggregation.warnings]
+    });
+    Object.assign(breakdown, analyzeAgentFriction(records, breakdown.totalTokens));
+  } catch (error) {
+    const message = `unable_to_read_session_file:${errorMessage(error)}`;
+    breakdown.parseStatus = "failed";
+    breakdown.parseErrors.push(message);
+    breakdown.warnings.push(message);
+  }
+  return breakdown;
+}
+function parseSessionRecords(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return { records: [], errors: [] };
+  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return { records: Array.isArray(parsed) ? parsed : [parsed], errors: [] };
+    } catch {
+      return parseJsonLines(text);
+    }
+  }
+  return parseJsonLines(text);
+}
+function parseJsonLines(text, firstError) {
+  const records = [];
+  const errors = firstError ? [`json_parse:${firstError}`] : [];
+  text.split(/\r?\n/).map((line, index) => ({ line: line.trim(), index })).filter(({ line }) => Boolean(line)).forEach(({ line, index }) => {
+    try {
+      records.push(JSON.parse(line));
+    } catch (error) {
+      errors.push(`jsonl_line_${index + 1}:${errorMessage(error)}`);
+    }
+  });
+  return { records, errors };
+}
+function firstObject3(...values) {
+  return values.find((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
+}
+function numberFromKeys2(object, keys) {
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && Number.isFinite(Number(value))) return Number(value);
+  }
+  return 0;
+}
+function parseTokenTotal(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+    try {
+      const parsed = JSON.parse(value);
+      if (typeof parsed === "number") return parsed;
+      if (parsed && typeof parsed === "object") {
+        return numberFromKeys2(parsed, ["total_tokens", "totalTokens", "tokens_used", "tokensUsed"]);
+      }
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+}
+function matchSessionPath(id, sessionFiles) {
+  if (!id) return void 0;
+  return sessionFiles.get(id) ?? [...sessionFiles.entries()].find(([key]) => key.includes(id) || id.includes(key))?.[1];
+}
+function emptyBreakdown() {
+  return {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    tokenAggregationMethod: "unknown",
+    tokenConfidence: "low",
+    tokenSnapshotCount: 0,
+    warnings: [],
+    messageCount: 0,
+    source: void 0,
+    originator: void 0,
+    threadSource: void 0,
+    rawEventCount: 0,
+    parseStatus: "ok",
+    parseErrors: [],
+    userPromptCount: 0,
+    assistantMessageCount: 0,
+    toolCallCount: 0,
+    shellCommandCount: 0,
+    failedToolCallCount: 0,
+    commandIssues: [],
+    nonZeroCommandEvents: 0,
+    importantCommandFailures: 0,
+    harmlessNonZeroEvents: 0,
+    exploratoryMisses: 0,
+    repeatedFailureClusters: 0,
+    commandIssueSeverity: "none",
+    commandIssueImpact: "none",
+    topFailureType: void 0,
+    commandIssueSamples: [],
+    fileReadCount: 0,
+    fileEditCount: 0,
+    promptTimeline: []
+  };
+}
+function fallbackCwdFromPath(filePath) {
+  return filePath ? path4.dirname(filePath) : process.cwd();
+}
+function applySessionMetadata(breakdown, record) {
+  if (!record || typeof record !== "object") return;
+  const object = record;
+  const payload = firstObject3(object.payload) ?? object;
+  breakdown.source ??= stringValue2(payload.source);
+  breakdown.originator ??= stringValue2(payload.originator);
+  breakdown.threadSource ??= stringValue2(payload.thread_source);
+}
+function isCodexEventMessage(record) {
+  if (!record || typeof record !== "object") return false;
+  const object = record;
+  if (object.type !== "event_msg") return false;
+  const payload = firstObject3(object.payload);
+  return payload?.type === "user_message" || payload?.type === "agent_message";
+}
+function isResponseMessage(record) {
+  if (!record || typeof record !== "object") return false;
+  const object = record;
+  if (object.type !== "response_item") return false;
+  const payload = firstObject3(object.payload);
+  return payload?.type === "message" && (payload.role === "user" || payload.role === "assistant");
+}
+function applyPromptTimeline(breakdown, record) {
+  if (breakdown.promptTimeline.length >= 80 || !record || typeof record !== "object") return;
+  const object = record;
+  const payload = firstObject3(object.payload) ?? object;
+  const payloadType = stringValue2(payload.type);
+  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);
+  if (!text) return;
+  breakdown.promptTimeline.push({
+    role,
+    text: normalizeTimelineText(text),
+    timestamp: dateValue(payload.timestamp) ?? dateValue(object.timestamp) ?? dateValue(payload.created_at) ?? dateValue(object.created_at)
+  });
+}
+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 stringValue2(object.text) ?? stringValue2(object.content);
+        }
+        return void 0;
+      }).filter((item) => Boolean(item?.trim()));
+      if (parts.length) return parts.join("\n");
+    }
+  }
+  return void 0;
+}
+function normalizeTimelineText(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 1e3);
+}
+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("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" };
+  if (raw.includes("codex_app") || raw.includes("codex-app")) return { surface: "codex_app_cloud", confidence: "low", reason: "source metadata references codex app; local logs may be incomplete" };
+  return { surface: "unknown", confidence: "low", reason: "no recognized local surface metadata" };
+}
+function inferOutcome(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 durationMs(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 stringValue2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function codexSourceAppLabel(source, threadSource) {
+  if (threadSource === "subagent") return "Codex subagent";
+  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";
+  return source.replace(/^codex[_-]/, "").split(/[_-]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function dateValue(value) {
+  if (typeof value === "number") {
+    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;
+}
+function errorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("NODE_MODULE_VERSION") && message.includes("better_sqlite3.node")) {
+    const builtAbi = message.match(/NODE_MODULE_VERSION\s+(\d+)/)?.[1] ?? "unknown";
+    const requiredAbi = message.match(/requires\s+NODE_MODULE_VERSION\s+(\d+)/)?.[1] ?? "unknown";
+    return `SQLite native module mismatch: better-sqlite3 was built for Node ABI ${builtAbi}, but RepoSpend is running with ABI ${requiredAbi}. Run "node -p \\"process.version + ' ABI=' + process.versions.modules\\"" in the same terminal you use for RepoSpend, then reinstall or rebuild better-sqlite3 with that same Node version. From source, run "pnpm rebuild:native". For a global npm install, run "npm rebuild -g better-sqlite3" or reinstall RepoSpend.`;
+  }
+  return message;
+}
+
+// apps/server/src/data.ts
+import fs5 from "node:fs";
+var scanCacheTtlMs = 1e4;
+var scanCache;
+function readDashboardData(filters = {}) {
+  const raw = readRawUsageData();
+  return buildDashboardSnapshot({ ...raw, filters });
+}
+function clearScanCache() {
+  scanCache = void 0;
+}
+function readRawUsageData() {
+  const cwd = runtimeCwd();
+  if (scanCache && scanCache.cwd === cwd && scanCache.expiresAt > Date.now()) {
+    return scanCache.data;
+  }
+  const { config, warnings: configWarnings } = loadConfigWithWarnings();
+  const pricing = loadPricingTable(resolvePricingPath(config));
+  const codex = scanCodex({ config, pricing });
+  const data = {
+    sources: [{ ...codex.source, warnings: [...codex.source.warnings, ...configWarnings] }],
+    sourceStats: [codex.stats],
+    sessions: codex.sessions
+  };
+  scanCache = { cwd, data, expiresAt: Date.now() + scanCacheTtlMs };
+  return data;
+}
+function parseFilters(query) {
+  const filters = {};
+  const source = listQuery(query.source);
+  const sourceApp = listQuery(query.sourceApp);
+  const repo = listQuery(query.repo);
+  const model = listQuery(query.model);
+  const from = stringQuery(query.from);
+  const to = stringQuery(query.to);
+  if (source) filters.source = source;
+  if (sourceApp) filters.sourceApp = sourceApp;
+  if (repo) filters.repo = repo;
+  if (model) filters.model = model;
+  if (from) filters.from = from;
+  if (to) filters.to = to;
+  return filters;
+}
+function readPricingData() {
+  const config = loadConfig();
+  const pricingPath = resolvePricingPath(config);
+  return {
+    path: pricingPath,
+    models: loadPricingTable(pricingPath)
+  };
+}
+function writePricingData(models) {
+  const config = loadConfig();
+  const pricingPath = resolvePricingPath(config);
+  savePricingTable(pricingPath, models);
+  clearScanCache();
+  return {
+    path: pricingPath,
+    models: loadPricingTable(pricingPath)
+  };
+}
+function clearRepoSpendLocalData() {
+  const target = repospendHome();
+  const removed = fs5.existsSync(target);
+  fs5.rmSync(target, { recursive: true, force: true });
+  clearScanCache();
+  return { path: target, removed };
+}
+function exportJson() {
+  return JSON.stringify(readDashboardData().sessions, null, 2);
+}
+function exportCsv() {
+  return toCsv(readDashboardData().sessions);
+}
+function stringQuery(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function listQuery(value) {
+  const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  const parsed = values.flatMap((item) => typeof item === "string" ? item.split(",") : []).map((item) => item.trim()).filter(Boolean);
+  return parsed.length ? parsed : void 0;
+}
+function runtimeCwd() {
+  return process.env.INIT_CWD || process.cwd();
+}
+
+// apps/server/src/server.ts
+import fs6 from "node:fs";
+import path5 from "node:path";
+import { fileURLToPath } from "node:url";
+import fastifyStatic from "@fastify/static";
+import Fastify from "fastify";
+
+// apps/server/src/rtk.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function readRtkGain() {
+  try {
+    const { stdout } = await execFileAsync("rtk", ["gain", "--history"], {
+      timeout: 5e3,
+      maxBuffer: 1024 * 1024
+    });
+    const version = await readRtkVersion();
+    const discover = await readRtkDiscover();
+    return parseRtkGain(stdout, version, discover);
+  } catch (error) {
+    return {
+      available: false,
+      rtkDetected: false,
+      rtkVersion: void 0,
+      rtkCodexHookStatus: "not_detected",
+      rtkLastActivityAt: void 0,
+      rtkDataSource: void 0,
+      totalCommands: void 0,
+      inputTokens: void 0,
+      outputTokens: void 0,
+      tokensSaved: void 0,
+      savedPercent: void 0,
+      totalExecTime: void 0,
+      averageExecTime: void 0,
+      rtkTokensSaved: void 0,
+      rtkSavingsRate: void 0,
+      rtkCommandsProcessed: void 0,
+      rtkAverageCommandRuntime: void 0,
+      rtkTopSavingsCommands: [],
+      rtkRecentActivity: [],
+      rtkDiscoverAvailable: false,
+      rtkDiscoverError: void 0,
+      rtkDiscoverSummary: void 0,
+      rtkCoverageGaps: [],
+      rtkUnhandledCommands: [],
+      topCommands: [],
+      recentCommands: [],
+      raw: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function readRtkDiscover() {
+  try {
+    const { stdout } = await execFileAsync("rtk", ["discover", "--all", "--since", "7"], {
+      timeout: 8e3,
+      maxBuffer: 1024 * 1024
+    });
+    return parseRtkDiscover(stdout);
+  } catch (error) {
+    return {
+      rtkDiscoverAvailable: false,
+      rtkDiscoverError: error instanceof Error ? error.message : String(error),
+      rtkDiscoverSummary: void 0,
+      rtkCoverageGaps: [],
+      rtkUnhandledCommands: []
+    };
+  }
+}
+async function readRtkVersion() {
+  try {
+    const { stdout } = await execFileAsync("rtk", ["--version"], {
+      timeout: 1500,
+      maxBuffer: 128 * 1024
+    });
+    return stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseRtkGain(raw, version, discover) {
+  const lines = raw.split(/\r?\n/);
+  const savedLine = valueAfterLabel(lines, "Tokens saved");
+  const execLine = valueAfterLabel(lines, "Total exec time");
+  const totalCommands = numberFromText(valueAfterLabel(lines, "Total commands"));
+  const tokensSaved = savedLine?.replace(/\s+\(.+\)$/, "");
+  const savedPercent = percentFromText(savedLine);
+  const averageExecTime = execLine?.match(/\(avg\s+(.+)\)/)?.[1];
+  const topCommands = commandRows(lines);
+  const recentCommands = recentCommandLines(lines);
+  return {
+    available: true,
+    rtkDetected: true,
+    rtkVersion: version,
+    rtkCodexHookStatus: "unknown",
+    rtkLastActivityAt: void 0,
+    rtkDataSource: "rtk gain --history output",
+    totalCommands,
+    inputTokens: valueAfterLabel(lines, "Input tokens"),
+    outputTokens: valueAfterLabel(lines, "Output tokens"),
+    tokensSaved,
+    savedPercent,
+    totalExecTime: execLine?.replace(/\s+\(.+\)$/, ""),
+    averageExecTime,
+    rtkTokensSaved: tokensSaved,
+    rtkSavingsRate: savedPercent,
+    rtkCommandsProcessed: totalCommands,
+    rtkAverageCommandRuntime: averageExecTime,
+    rtkTopSavingsCommands: topCommands,
+    rtkRecentActivity: recentCommands,
+    ...discover,
+    topCommands,
+    recentCommands,
+    raw,
+    error: void 0
+  };
+}
+function parseRtkDiscover(raw) {
+  const lines = raw.split(/\r?\n/);
+  return {
+    rtkDiscoverAvailable: true,
+    rtkDiscoverError: void 0,
+    rtkDiscoverSummary: lines.find((line) => line.trim().startsWith("Total:"))?.trim(),
+    rtkCoverageGaps: coverageGapRows(lines),
+    rtkUnhandledCommands: unhandledCommandRows(lines)
+  };
+}
+function valueAfterLabel(lines, label) {
+  const line = lines.find((candidate) => candidate.trim().startsWith(`${label}:`));
+  return line?.split(":").slice(1).join(":").trim();
+}
+function numberFromText(value) {
+  if (!value) return void 0;
+  const number = Number(value.replaceAll(",", "").match(/\d+/)?.[0]);
+  return Number.isFinite(number) ? number : void 0;
+}
+function percentFromText(value) {
+  if (!value) return void 0;
+  const match = value.match(/([\d.]+)%/);
+  return match?.[1] ? Number(match[1]) : void 0;
+}
+function commandRows(lines) {
+  const start = lines.findIndex((line) => line.trim() === "By Command");
+  const end = lines.findIndex((line, index) => index > start && line.trim() === "Recent Commands");
+  if (start < 0) return [];
+  return lines.slice(start + 1, end > start ? end : void 0).map((line) => line.trim()).filter((line) => /^\d+\.\s+/.test(line)).flatMap((line) => {
+    const withoutRank = line.replace(/^\d+\.\s+/, "");
+    const columns = withoutRank.split(/\s{2,}/).filter(Boolean);
+    const [command2, count2, saved, averageSavedPercent, time] = columns;
+    if (!command2) return [];
+    return [{
+      command: command2,
+      count: numberFromText(count2),
+      saved,
+      averageSavedPercent: percentFromText(averageSavedPercent),
+      time
+    }];
+  });
+}
+function coverageGapRows(lines) {
+  const start = lines.findIndex((line) => line.trim().startsWith("MISSED SAVINGS"));
+  const end = lines.findIndex((line, index) => index > start && line.trim().startsWith("Total:"));
+  if (start < 0) return [];
+  return lines.slice(start + 3, end > start ? end : void 0).map((line) => line.trim()).filter((line) => line && !line.startsWith("\u2500") && !line.startsWith("Command")).flatMap((line) => {
+    const match = line.match(/^(.+?)\s{2,}(\d+)\s{2,}(.+?)\s{2,}(.+?)\s{2,}(.+)$/);
+    if (!match?.[1]) return [];
+    return [{
+      command: match[1].trim(),
+      count: numberFromText(match[2]),
+      rtkEquivalent: match[3]?.trim(),
+      status: match[4]?.trim(),
+      estimatedSavings: match[5]?.replace(/^~/, "").trim()
+    }];
+  });
+}
+function unhandledCommandRows(lines) {
+  const start = lines.findIndex((line) => line.trim().startsWith("TOP UNHANDLED COMMANDS"));
+  const end = lines.findIndex((line, index) => index > start && line.trim().startsWith("->"));
+  if (start < 0) return [];
+  return lines.slice(start + 3, end > start ? end : void 0).map((line) => line.trim()).filter((line) => line && !line.startsWith("\u2500") && !line.startsWith("Command")).flatMap((line) => {
+    const match = line.match(/^(.+?)\s{2,}(\d+)\s{2,}(.+)$/);
+    if (!match?.[1]) return [];
+    return [{
+      command: match[1].trim(),
+      count: numberFromText(match[2]),
+      example: match[3]?.trim()
+    }];
+  });
+}
+function recentCommandLines(lines) {
+  const start = lines.findIndex((line) => line.trim() === "Recent Commands");
+  if (start < 0) return [];
+  return lines.slice(start + 2).map((line) => line.trim()).filter((line) => line && !line.startsWith("\u2500")).slice(0, 6);
+}
+
+// apps/server/src/server.ts
+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();
+    return {
+      ...data,
+      summary: { ...data.summary, skippedZeroTokenSessions: data.skippedZeroTokenSessions },
+      pricing: {
+        info: pricingInfo,
+        ...readPricingData()
+      },
+      rtkGain
+    };
+  });
+  app.put("/api/settings/pricing", async (request) => ({
+    info: pricingInfo,
+    ...writePricingData(validatePricingBody(request.body))
+  }));
+  app.delete("/api/settings/local-data", async () => clearRepoSpendLocalData());
+  app.get("/api/export.json", async (_request, reply) => {
+    reply.header("content-type", "application/json; charset=utf-8");
+    return exportJson();
+  });
+  app.get("/api/export.csv", async (_request, reply) => {
+    reply.header("content-type", "text/csv; charset=utf-8");
+    reply.header("content-disposition", 'attachment; filename="repospend-export.csv"');
+    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 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.`);
+    }
+    app.register(fastifyStatic, {
+      root: webDist,
+      prefix: "/",
+      wildcard: false
+    });
+    app.setNotFoundHandler((request, reply) => {
+      if (request.url.startsWith("/api/")) {
+        reply.code(404).send({ error: "API route not found" });
+        return;
+      }
+      reply.sendFile("index.html");
+    });
+  }
+  return app;
+}
+function fsExists(inputPath) {
+  return Boolean(inputPath) && path5.isAbsolute(inputPath) && fs6.existsSync(inputPath);
+}
+function readPackageVersion() {
+  const serverDist = path5.dirname(fileURLToPath(import.meta.url));
+  const packagePath = path5.resolve(serverDist, "../package.json");
+  try {
+    const parsed = JSON.parse(fs6.readFileSync(packagePath, "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function startServer(options = {}) {
+  const port = options.port ?? Number(process.env.REPOSPEND_PORT ?? 2005);
+  const host = options.host ?? "127.0.0.1";
+  const app = createServer(options);
+  await app.listen({ host, port });
+  return { app, url: `http://localhost:${port}` };
+}
+function validatePricingBody(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw new Error("Expected JSON body with a models object.");
+  }
+  const models = body.models;
+  if (!models || typeof models !== "object" || Array.isArray(models)) {
+    throw new Error("Expected JSON body with a models object.");
+  }
+  const validated = {};
+  for (const [model, value] of Object.entries(models)) {
+    if (!model.trim() || !value || typeof value !== "object" || Array.isArray(value)) continue;
+    const row = value;
+    const inputPerMillion = finiteNumber(row.inputPerMillion);
+    const outputPerMillion = finiteNumber(row.outputPerMillion);
+    if (inputPerMillion === void 0 || outputPerMillion === void 0) continue;
+    const modelPricing = {
+      inputPerMillion,
+      outputPerMillion
+    };
+    const cachedInputPerMillion = finiteNumber(row.cachedInputPerMillion);
+    const reasoningOutputPerMillion = finiteNumber(row.reasoningOutputPerMillion);
+    if (cachedInputPerMillion !== void 0) modelPricing.cachedInputPerMillion = cachedInputPerMillion;
+    if (reasoningOutputPerMillion !== void 0) modelPricing.reasoningOutputPerMillion = reasoningOutputPerMillion;
+    if (typeof row.note === "string") modelPricing.note = row.note;
+    validated[model] = modelPricing;
+  }
+  return validated;
+}
+function finiteNumber(value) {
+  if (value === "" || value === null || value === void 0) return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+
+// apps/server/src/cli.ts
+var [command = "serve", ...args] = process.argv.slice(2);
+try {
+  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();
+    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));
+  } else if (command === "by-day") {
+    printGroups(groupByDay(readDashboardData().sessions));
+  } else if (command === "by-hour") {
+    printGroups(groupByHour(readDashboardData().sessions));
+  } else if (command === "by-model") {
+    printGroups(groupByModel(readDashboardData().sessions));
+  } else if (command === "by-app") {
+    printGroups(groupBySourceApp(readDashboardData().sessions));
+  } else if (command === "export") {
+    const format = valueAfter(args, "--format") ?? "json";
+    const sessions = readDashboardData().sessions;
+    console.log(format === "csv" ? toCsv(sessions) : exportJson());
+  } else {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exitCode = 1;
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}
+function openBrowser(url) {
+  if (process.env.REPOSPEND_NO_OPEN === "1" || process.env.CI === "true") return;
+  const command2 = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args2 = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command2, args2, { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function printGroups(groups) {
+  if (!groups.length) {
+    console.log("No usage found. Scanned ~/.codex/state_5.sqlite and ~/.codex/sessions.");
+    return;
+  }
+  const rows = groups.map((group) => ({
+    name: group.label,
+    cost: group.estimatedCostUsd === void 0 ? "unknown" : `$${group.estimatedCostUsd.toFixed(4)}`,
+    tokens: group.totalTokens,
+    sessions: group.sessionCount
+  }));
+  console.table(rows);
+}
+function valueAfter(args2, flag) {
+  const index = args2.indexOf(flag);
+  return index >= 0 ? args2[index + 1] : void 0;
+}
+function printHelp() {
+  console.log(`RepoSpend commands:
+  repospend serve
+  repospend scan
+  repospend by-repo
+  repospend by-day
+  repospend by-hour
+  repospend by-model
+  repospend by-app
+  repospend export --format json
+  repospend export --format csv`);
+}