@mohndoe/pi-atlas 0.1.2 → 0.1.3

package/src/components/{__tests__/KpiCards.test.ts → KpiCards.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { makeTheme } from "../../__tests__/components.fixtures";
-import { KpiCards } from "../KpiCards";
+import { makeTheme } from "./components.fixtures";
+import { KpiCards } from "./KpiCards";
 
 describe("KpiCards", () => {
   const kpis = {
@@ -22,7 +22,7 @@ describe("KpiCards", () => {
     expect(text).toContain("12.34");
     expect(text).toContain("42");
     expect(text).toContain("1.5k");
-    expect(text).toContain("250.0k");
+    expect(text).toContain("250k");
     expect(text).toContain("7");
     expect(text).toContain("1.76");
   });
@@ -50,13 +50,13 @@ describe("KpiCards", () => {
   it("formats large token numbers", () => {
     const cards = new KpiCards({ ...kpis, totalTokens: 1500000 }, makeTheme());
     const lines = cards.render(80);
-    expect(lines.join("\n")).toContain("1.50M");
+    expect(lines.join("\n")).toContain("1.5M");
   });
 
   it("formats large costs with compact notation", () => {
     const cards = new KpiCards({ ...kpis, totalCost: 5432.1 }, makeTheme());
     const lines = cards.render(80);
-    expect(lines.join("\n")).toContain("$5.4k");
+    expect(lines.join("\n")).toContain("$5.43k");
   });
 
   it("formats very large costs with M notation", () => {

package/src/components/KpiCards.ts

@@ -20,7 +20,7 @@ export class KpiCards implements Component {
   constructor(kpis: KpiData, theme: Theme) {
     this.theme = theme;
 
-    const colPcts = [16, 16, 16, 16, 16, 17];
+    const colPcts = [17, 17, 17, 17, 17, 15];
 
     const totalCostCard = new StatCard(
       {

package/src/components/LoadingView.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "bun:test";
+import { makeTheme } from "./components.fixtures";
+import { LoadingView } from "./LoadingView";
+
+const theme = makeTheme();
+
+describe("LoadingView", () => {
+  it("renders with 0% progress", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 100, done: 0, pct: 0 });
+    const lines = lv.render(80);
+    expect(lines.join("\n")).toContain("Parsing session logs...");
+    expect(lines.join("\n")).toContain("0/100");
+  });
+
+  it("updates progress", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 20, done: 10, pct: 50 });
+    const lines = lv.render(80);
+    expect(lines.join("\n")).toContain("10/20");
+  });
+
+  it("renders progress bar with block chars", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 20, done: 15, pct: 75 });
+    const lines = lv.render(80);
+    expect(lines.join("\n")).toContain("15/20");
+    expect(lines.join("\n")).toContain("█");
+  });
+
+  it("does not show remaining time when not provided", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 20, done: 0, pct: 0 });
+    const lines = lv.render(80);
+    // Progress line is the second content line (index 2); title also contains · so check specific line
+    expect(lines[2]).toContain("0/20");
+    expect(lines[2]).not.toContain("·");
+  });
+
+  it("shows remaining time in seconds", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 20, done: 5, pct: 25, remainingTimeMs: 5210 });
+    const lines = lv.render(80);
+    expect(lines[2]).toContain("~5.21s remaining · 5/20");
+  });
+
+  it("shows remaining time in minutes and seconds", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 20, done: 5, pct: 25, remainingTimeMs: 90000 });
+    const lines = lv.render(80);
+    expect(lines[2]).toContain("~1m 30s remaining · 5/20");
+  });
+
+  it("shows remaining time in ms when under 1s", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 20, done: 19, pct: 95, remainingTimeMs: 500 });
+    const lines = lv.render(80);
+    expect(lines[2]).toContain("~0.5s remaining · 19/20");
+  });
+
+  it("shows 0ms remaining when done", () => {
+    const lv = new LoadingView("Parsing session logs...", theme);
+    lv.setProgress({ total: 20, done: 20, pct: 100, remainingTimeMs: 0 });
+    const lines = lv.render(80);
+    expect(lines[2]).toContain("~0s remaining · 20/20");
+  });
+
+  describe("handleInput", () => {
+    it("calls onClose on Escape key", () => {
+      let called = false;
+      const lv = new LoadingView("test", theme, () => {
+        called = true;
+      });
+      lv.handleInput("\x1b");
+      expect(called).toBe(true);
+    });
+
+    it("calls onClose on 'q'", () => {
+      let called = false;
+      const lv = new LoadingView("test", theme, () => {
+        called = true;
+      });
+      lv.handleInput("q");
+      expect(called).toBe(true);
+    });
+
+    it("calls onClose on 'Q'", () => {
+      let called = false;
+      const lv = new LoadingView("test", theme, () => {
+        called = true;
+      });
+      lv.handleInput("Q");
+      expect(called).toBe(true);
+    });
+
+    it("does not call onClose on other keys", () => {
+      let called = false;
+      const lv = new LoadingView("test", theme, () => {
+        called = true;
+      });
+      lv.handleInput("a");
+      lv.handleInput("Enter");
+      lv.handleInput("\x1b[C"); // right arrow
+      expect(called).toBe(false);
+    });
+
+    it("does not throw when onClose is null", () => {
+      const lv = new LoadingView("test", theme, null);
+      expect(() => {
+        lv.handleInput("\x1b");
+        lv.handleInput("q");
+        lv.handleInput("Q");
+      }).not.toThrow();
+    });
+  });
+});

package/src/components/LoadingView.ts

@@ -1,38 +1,100 @@
-import { type Component } from "@earendil-works/pi-tui";
-
-export class LoadingView implements Component {
-  private progress = 0;
-  private message: string;
-  private cachedLines: string[] | null = null;
-  private cachedWidth = -1;
-  private tui: { requestRender: () => void } | null;
-
-  constructor(message = "Parsing session logs...", tui?: { requestRender: () => void }) {
-    this.message = message;
-    this.tui = tui ?? null;
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { matchesKey, Spacer, Text } from "@earendil-works/pi-tui";
+import { BorderBox } from "@mohndoe/pi-tui-extras";
+import { alignInWidthLR } from "@mohndoe/pi-tui-extras/src/core/align";
+import pkg from "../../package.json" with { type: "json" };
+import type { LoadingProgress } from "../cache";
+import { renderBar } from "./shared/Bar";
+
+function formatRemainingTime(ms: number): string {
+  if (ms < 60000)
+    return `~${new Intl.NumberFormat("en-US", {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2,
+      style: "decimal",
+    }).format(ms / 1000)}s`;
+  const m = Math.floor(ms / 60000);
+  const s = Math.round((ms % 60000) / 1000);
+  return `~${m}m ${s}s`;
+}
+
+export class LoadingView extends BorderBox {
+  private progress: LoadingProgress = {
+    pct: 0,
+    total: 0,
+    done: 0,
+  };
+  private bar: Text;
+  private loadingText: Text;
+
+  constructor(
+    private message = "Parsing session logs...",
+    private theme: Theme,
+    private onClose: (() => void) | null = null,
+  ) {
+    super({
+      titles: [
+        { text: theme.bold("Pi Atlas") + theme.fg("dim", ` · v${pkg.version}`), align: "left" },
+      ],
+      padding: {
+        top: 1,
+        bottom: 0,
+        left: 1,
+        right: 1,
+      },
+    });
+
+    this.bar = new Text("", 0, 0);
+    this.loadingText = new Text(this.theme.fg("text", message), 0, 0);
+
+    this.addChild(this.loadingText);
+    this.addChild(this.bar);
+
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(this.theme.fg("dim", "Esc/q to cancel and close"), 0, 0));
   }
 
-  setProgress(p: number): void {
+  setProgress(p: LoadingProgress): void {
     this.progress = p;
     this.invalidate();
   }
 
-  render(width: number): string[] {
-    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+  override render(width: number): string[] {
+    const innerWidth = width - 2 - 2;
+    this.bar.setText(
+      renderBar(
+        innerWidth,
+        this.progress.pct,
+        (s) => this.theme.bold(this.theme.fg("success", s)),
+        (s) => this.theme.fg("muted", s),
+        "█",
+        "░",
+      ),
+    );
 
-    const barW = Math.min(40, width - 10);
-    const filled = Math.round((this.progress / 100) * barW);
-    const bar = "█".repeat(filled) + "░".repeat(barW - filled);
+    const remainingStr =
+      this.progress.remainingTimeMs != null
+        ? this.theme.fg("dim", formatRemainingTime(this.progress.remainingTimeMs) + " remaining · ")
+        : "";
+    const loadingRightText =
+      remainingStr + this.progress.done + this.theme.fg("dim", "/" + this.progress.total);
+    this.loadingText.setText(
+      alignInWidthLR(this.theme.fg("text", this.message), loadingRightText, innerWidth),
+    );
 
-    const lines = ["", `  ${this.message}`, `  [${bar}] ${this.progress}%`, ""];
+    return super.render(width);
+  }
 
-    this.cachedLines = lines;
-    this.cachedWidth = width;
-    return lines;
+  override handleInput(data: string): void {
+    if (matchesKey(data, "escape") || data === "q" || data === "Q") {
+      this.onClose?.();
+      return;
+    }
   }
 
-  invalidate(): void {
-    this.cachedLines = null;
-    this.cachedWidth = -1;
+  override invalidate(): void {
+    super.invalidate();
+    this.bar.invalidate();
+    this.loadingText.invalidate();
   }
 }

package/src/components/{__tests__/MarqueeText.test.ts → MarqueeText.test.ts}

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "bun:test";
-import { makeMockTUI } from "../../__tests__/components.fixtures";
-import { MarqueeText } from "../MarqueeText";
+import { makeMockTUI } from "./components.fixtures";
+import { MarqueeText } from "./MarqueeText";
 
 describe("MarqueeText", () => {
   let tui: ReturnType<typeof makeMockTUI>;

package/src/components/{__tests__/RangeSelector.test.ts → RangeSelector.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { makeTheme } from "../../__tests__/components.fixtures";
-import { type RangeOption, RangeSelector } from "../RangeSelector";
+import { makeTheme } from "./components.fixtures";
+import { type RangeOption, RangeSelector } from "./RangeSelector";
 
 describe("RangeSelector", () => {
   const ranges: RangeOption[] = [

package/src/components/{__tests__/RankedBarList.test.ts → RankedBarList.test.ts}

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import chalk from "chalk";
-import { makeTheme } from "../../__tests__/components.fixtures";
-import { RankedBarList } from "../RankedBarList";
+import { makeTheme } from "./components.fixtures";
+import { RankedBarList } from "./RankedBarList";
 
 describe("RankedBarList", () => {
   it("renders a single item with 100% bar width", () => {

package/src/components/{__tests__/SortedTable.test.ts → SortedTable.test.ts}

@@ -1,8 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "bun:test";
-import { makeMockTUI, makeTheme } from "../../__tests__/components.fixtures";
-
-import { cell } from "../cells";
-import { type ColumnDef, SortedTable } from "../SortedTable";
+import { cell } from "./cells";
+import { makeMockTUI, makeTheme } from "./components.fixtures";
+import { type ColumnDef, SortedTable } from "./SortedTable";
 
 const CURSOR = SortedTable.DEFAULT_CURSOR_CHAR;
 const mockTui = makeMockTUI();

package/src/components/{__tests__/TabBar.test.ts → TabBar.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { makeTheme } from "../../__tests__/components.fixtures";
-import { TabBar } from "../TabBar";
+import { makeTheme } from "./components.fixtures";
+import { TabBar } from "./TabBar";
 
 describe("TabBar", () => {
   const tabs = ["Overview", "Languages", "Models", "Projects + Tools"];

package/src/components/__tests__/SortedTable.integration.test.ts

@@ -1,13 +1,10 @@
-/**
- * Integration test: Dashboard → Models → SortedTable keyboard interaction.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "bun:test";
-import { makeMockTUI, makeRangeSelector, makeTheme } from "../../__tests__/components.fixtures";
-import { makeSummary } from "../../__tests__/compute.fixtures";
+import { describe, expect, it } from "bun:test";
+import { makeSummary } from "../../compute.fixtures";
+import type { StatsSummary, TimeRange } from "../../types";
+import { makeMockTUI, makeRangeSelector, makeTheme } from "../components.fixtures";
 import { Dashboard } from "../Dashboard";
+import { allRanges, mapAllSummaries } from "../Dashboard.test";
 import { SortedTable } from "../SortedTable";
-import { allRanges, mapAllSummaries } from "./Dashboard.test";
-import type { StatsSummary, TimeRange } from "../../types";
 
 const CURSOR = SortedTable.DEFAULT_CURSOR_CHAR;
 const mockTui = makeMockTUI();

package/src/components/{__tests__/cells.test.ts → cells.test.ts}

@@ -1,7 +1,7 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { afterEach, beforeEach, describe, expect, it, vi } from "bun:test";
-import { makeMockTUI } from "../../__tests__/components.fixtures";
-import { cell } from "../cells";
+import { cell } from "./cells";
+import { makeMockTUI } from "./components.fixtures";
 
 describe("cell.text", () => {
   it("renders content truncated to width", () => {

package/src/{__tests__ → components}/components.fixtures.ts

@@ -1,7 +1,7 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { TUI } from "@earendil-works/pi-tui";
 import { ColorPalette } from "../colorPalette";
-import { type RangeOption, RangeSelector } from "../components/RangeSelector";
+import { RangeSelector, type RangeOption } from "./RangeSelector";
 
 /**
  * Pass-through mock theme for tests. All styling methods return text unchanged.

package/src/components/shared/Bar.ts

@@ -1,3 +1,5 @@
+export const BAR_DEFAULT_FILLED_CHAR = "■";
+export const BAR_DEFAULT_EMPTY_CHAR = "■";
 /**
  * Render a horizontal bar using ■ characters.
  *
@@ -5,18 +7,24 @@
  * @param fillPct  Fill percentage (0–100, clamped)
  * @param filledStyle  Styling function for the filled portion (e.g. chalk.green)
  * @param emptyStyle  Styling function for the empty/unfilled portion (e.g. s => theme.fg("dim", s))
+ * @param filledChar Character to repeat for the part that's filled
+ * @param emptyChar Character to repeat for the part that's empty
  */
 export function renderBar(
   width: number,
   fillPct: number,
   filledStyle: (text: string) => string,
   emptyStyle: "transparent" | ((text: string) => string),
+  filledChar: string = BAR_DEFAULT_FILLED_CHAR,
+  emptyChar: string = BAR_DEFAULT_EMPTY_CHAR,
 ): string {
   const clamped = Math.max(0, Math.min(100, fillPct));
   const filledCount = Math.round((clamped / 100) * Math.max(0, width));
   const emptyCount = Math.max(0, width - filledCount);
   return (
-    filledStyle("■".repeat(filledCount)) +
-    (emptyStyle !== "transparent" ? emptyStyle("■".repeat(emptyCount)) : " ".repeat(emptyCount))
+    filledStyle(filledChar.repeat(filledCount)) +
+    (emptyStyle !== "transparent"
+      ? emptyStyle(emptyChar.repeat(emptyCount))
+      : " ".repeat(emptyCount))
   );
 }

package/src/{__tests__/compute.fixtures.ts → compute.fixtures.ts}

@@ -1,4 +1,4 @@
-import { type StatsSummary } from "../types";
+import { type StatsSummary } from "./types";
 
 export const makeSummary = (): StatsSummary => ({
   totalCost: 5.0,
@@ -40,6 +40,11 @@ export const makeSummary = (): StatsSummary => ({
       name: "bash",
     },
   ],
+  providers: [],
+  compactionCount: 0,
+  compactedTokens: 0,
+  modelChanges: 0,
+  thinkingLevelCount: {},
   dailySpend: [
     { date: "2026-06-06", cost: 1.0 },
     { date: "2026-06-07", cost: 2.0 },

package/src/{__tests__/compute.test.ts → compute.test.ts}

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
-import { summarize } from "../compute";
-import { dateFromISOString } from "../format";
-import { emptyDay, mergeDay } from "../parser";
+import { summarize } from "./compute";
+import { dateFromISOString } from "./format";
+import { emptyDay, mergeDay } from "./parser";
 
 describe("summarize", () => {
   it("returns zeros for empty day list", () => {
@@ -323,6 +323,127 @@ describe("summarize", () => {
     expect(s.hourlySpend[23]!.cost).toBe(0);
   });
 
+  it("returns providers sorted by cost descending", () => {
+    const d = emptyDay("2026-06-08");
+    mergeDay(d, {
+      ...emptyDay(""),
+      providerCost: { anthropic: 5.0, openai: 1.0, free: 0 },
+      providerCount: { anthropic: 15, openai: 5, free: 100 },
+    });
+    const days = [d];
+
+    const s = summarize(days, "All");
+    expect(s.providers).toEqual([
+      { provider: "anthropic", cost: 5.0, calls: 15 },
+      { provider: "openai", cost: 1.0, calls: 5 },
+      { provider: "free", cost: 0, calls: 100 },
+    ]);
+  });
+
+  it("surfaces entry-type fields (compaction, modelChanges, thinkingLevel)", () => {
+    const d = emptyDay("2026-06-08");
+    mergeDay(d, {
+      ...emptyDay(""),
+      compactionCount: 2,
+      compactedTokens: 15000,
+      modelChanges: 3,
+      thinkingLevelCount: { low: 1, high: 2 },
+    });
+    const days = [d];
+
+    const s = summarize(days, "All");
+    expect(s.compactionCount).toBe(2);
+    expect(s.compactedTokens).toBe(15000);
+    expect(s.modelChanges).toBe(3);
+    expect(s.thinkingLevelCount).toEqual({ low: 1, high: 2 });
+  });
+
+  it("attaches provider to model stats from modelToProvider", () => {
+    const d = emptyDay("2026-06-08");
+    mergeDay(d, {
+      ...emptyDay(""),
+      modelCost: { sonnet: 2.0, haiku: 0.5 },
+      modelCount: { sonnet: 5, haiku: 2 },
+      modelToProvider: new Map([
+        ["sonnet", "anthropic"],
+        ["haiku", "anthropic"],
+      ]),
+    });
+    const days = [d];
+
+    const s = summarize(days, "All");
+    expect(s.models).toHaveLength(2);
+    expect(s.models.find((m) => m.model === "sonnet")?.provider).toBe("anthropic");
+    expect(s.models.find((m) => m.model === "haiku")?.provider).toBe("anthropic");
+  });
+
+  it("deduplicates session IDs across days", () => {
+    const d1 = emptyDay("2026-06-01");
+    d1.cost = 1;
+    d1.sessionIds = new Set(["shared-session"]);
+    const d2 = emptyDay("2026-06-02");
+    d2.cost = 2;
+    d2.sessionIds = new Set(["shared-session"]);
+    const d3 = emptyDay("2026-06-03");
+    d3.cost = 3;
+    d3.sessionIds = new Set(["unique-session"]);
+    const days = [d1, d2, d3];
+
+    const s = summarize(days, "All");
+    expect(s.sessionCount).toBe(2);
+    expect(s.totalCost).toBe(6);
+    expect(s.daysActive).toBe(3);
+  });
+
+  it("accumulates project stats across days", () => {
+    const d1 = emptyDay("2026-06-01");
+    d1.cost = 10;
+    d1.sessionIds = new Set(["s1"]);
+    d1.projectCost = { pi: 10 };
+    d1.projectSessions = { pi: new Set(["s1"]) };
+
+    const d2 = emptyDay("2026-06-02");
+    d2.cost = 5;
+    d2.sessionIds = new Set(["s2"]);
+    d2.projectCost = { pi: 5, other: 5 };
+    d2.projectSessions = { pi: new Set(["s2"]), other: new Set(["s2"]) };
+
+    const s = summarize([d1, d2], "All");
+    expect(s.projects).toHaveLength(2);
+    // pi: cost=15, sessions=2; other: cost=5, sessions=1
+    // sorted by cost desc
+    expect(s.projects[0]).toEqual({ project: "pi", cost: 15, sessions: 2 });
+    expect(s.projects[1]).toEqual({ project: "other", cost: 5, sessions: 1 });
+  });
+
+  it("excludes days with zero sessions from daysActive", () => {
+    const d1 = emptyDay("2026-06-01");
+    d1.cost = 10;
+    d1.sessionIds = new Set(["s1"]);
+    const d2 = emptyDay("2026-06-02");
+    d2.cost = 5;
+    d2.sessionIds = new Set(["s2"]);
+    const d3 = emptyDay("2026-06-03");
+    d3.cost = 20;
+    d3.sessionIds = new Set(); // no sessions
+
+    const s = summarize([d1, d2, d3], "All");
+    expect(s.daysActive).toBe(2);
+    expect(s.totalCost).toBe(35); // d3 still counts toward total
+    expect(s.avgCostPerDay).toBeCloseTo(17.5); // 35 / 2
+  });
+
+  it("fillDailySpend returns single entry for single day in bounded range", () => {
+    const today = dateFromISOString(new Date().toISOString());
+    const d = emptyDay(today);
+    d.cost = 5;
+    d.sessionIds = new Set(["s1"]);
+
+    const s = summarize([d], "1d");
+    expect(s.dailySpend).toHaveLength(1);
+    expect(s.dailySpend[0]).toEqual({ date: today, cost: 5 });
+  });
+
   it("hourlySpend is empty for 7d, 30d, All ranges", () => {
     const d = emptyDay("2026-06-01");
     d.cost = 5;
@@ -333,4 +454,15 @@ describe("summarize", () => {
     expect(summarize(days, "30d").hourlySpend).toEqual([]);
     expect(summarize(days, "All").hourlySpend).toEqual([]);
   });
+
+  it("hourlySpend is empty when 1d range has no matching days", () => {
+    // Date is in the past, not matching today
+    const d = emptyDay("2026-06-01");
+    d.cost = 5;
+    d.sessionIds = new Set(["s1"]);
+
+    const s = summarize([d], "1d");
+    expect(s.hourlySpend).toEqual([]);
+    expect(s.dailySpend).toEqual([]);
+  });
 });

package/src/compute.ts

@@ -6,6 +6,7 @@ import type {
   LangStat,
   ModelStat,
   ProjectStat,
+  ProviderStat,
   StatsSummary,
   TimeRange,
   ToolStat,
@@ -98,6 +99,10 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
   const projectCost: Record<string, number> = {};
   const projectSessions: Record<string, Set<string>> = {};
   const toolCount: Record<string, number> = {};
+  let compactionCount = 0;
+  let compactedTokens = 0;
+  let modelChanges = 0;
+  const thinkingLevelCount: Record<string, number> = {};
 
   let modelToProvider: Map<string, string> = new Map();
 
@@ -110,10 +115,9 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     totalCacheReadTokens += day.crTok;
     totalCacheWriteTokens += day.cwTok;
 
-    modelToProvider = new Map([
-      ...(modelToProvider.size > 0 ? modelToProvider.entries() : []),
-      ...(day.modelToProvider.size > 0 ? day.modelToProvider.entries() : []),
-    ]);
+    for (const [model, provider] of day.modelToProvider) {
+      modelToProvider.set(model, provider);
+    }
 
     if (day.date === todayStr) todayCost += day.cost;
 
@@ -157,6 +161,13 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     for (const [tool, count] of Object.entries(day.toolCount)) {
       toolCount[tool] = (toolCount[tool] ?? 0) + count;
     }
+
+    compactionCount += day.compactionCount;
+    compactedTokens += day.compactedTokens;
+    modelChanges += day.modelChanges;
+    for (const [level, count] of Object.entries(day.thinkingLevelCount)) {
+      thinkingLevelCount[level] = (thinkingLevelCount[level] ?? 0) + count;
+    }
   }
 
   const daysActive = filtered.filter((d) => d.sessionIds.size > 0).length;
@@ -186,6 +197,10 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     .map(([tool, count]) => ({ name: tool, count }))
     .sort((a, b) => b.count - a.count);
 
+  const providers: ProviderStat[] = Object.entries(providerCost)
+    .map(([provider, cost]) => ({ provider, cost, calls: providerCount[provider] ?? 0 }))
+    .sort((a, b) => b.cost - a.cost || b.calls - a.calls);
+
   const hourlySpend = buildHourlySpend(filtered, range);
 
   return {
@@ -204,6 +219,11 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     models,
     projects,
     tools,
+    providers,
+    compactionCount,
+    compactedTokens,
+    modelChanges,
+    thinkingLevelCount,
     dailySpend: fillDailySpend(filtered, range),
     hourlySpend,
   };