@mohndoe/pi-atlas 0.1.2 → 0.1.4

package/.github/workflows/release-please.yml

@@ -0,0 +1,25 @@
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
+name: release-please
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: googleapis/release-please-action@v4
+        with:
+          # this assumes that you have created a personal access token
+          # (PAT) and configured it as a GitHub action secret named
+          # `MY_RELEASE_PLEASE_TOKEN` (this secret name is not important).
+          token: ${{ secrets.MY_RELEASE_PLEASE_TOKEN }}
+          # this is a built-in strategy in release-please, see "Action Inputs"
+          # for more options
+          release-type: node

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## [0.1.4](https://github.com/MohnDoe/pi-atlas/compare/v0.1.3...v0.1.4) (2026-06-29)
+
+
+### Features
+
+* add Release Please GH Action ([5629007](https://github.com/MohnDoe/pi-atlas/commit/5629007ecacbeb013277bbccd4171b50ff3d3c36))
+* add screenshot for pi.dev packages directory ([413890d](https://github.com/MohnDoe/pi-atlas/commit/413890d1c694b2c81b4dfcb7bb4219a36ad43937))
+* add screenshot to README ([5e0895d](https://github.com/MohnDoe/pi-atlas/commit/5e0895d4620ac3220ddc0c93a0edcb5e659ee4c5))
+
+
+### Bug Fixes
+
+* **compute:** consolidate fragile double-sort into single sort ([781c5e4](https://github.com/MohnDoe/pi-atlas/commit/781c5e4950473b0c9d10371400147c24334f851b))
+* Release Please workflow ([81b47ff](https://github.com/MohnDoe/pi-atlas/commit/81b47ff1797984d1bfc0e1b70f53e33bc17de615))
+* replace invalid locale "en-EN" with "en-US" ([8e7f360](https://github.com/MohnDoe/pi-atlas/commit/8e7f3609761e8ce113e4d0601429521515f905e1))
+* tables for languages, models, projects and usage have better proportions ([9866ef1](https://github.com/MohnDoe/pi-atlas/commit/9866ef173459be29158d3ef6d55676b93d48e9a9))
+
+
+### Miscellaneous Chores
+
+* force version ([899f17d](https://github.com/MohnDoe/pi-atlas/commit/899f17d508689dd18c2d8adc5b247e51b412ef87))

package/README.md

@@ -1,45 +1,48 @@
-# Pi Atlas
+# @mohndoe/pi-atlas
 
-[![npm](https://img.shields.io/npm/v/@mohndoe/pi-atlas)](https://www.npmjs.com/package/@mohndoe/pi-atlas)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+<p align="center">
+  <strong>See your AI usage and cost directly in Pi.</strong>
+</p>
+<p align="center">
+  <a href="https://www.npmjs.com/package/@mohndoe/pi-atlas"><img src="https://img.shields.io/npm/v/@mohndoe/pi-atlas" alt="Version"></a>
+  <img src="https://img.shields.io/badge/coverage-97%25-green" alt="Coverage">
+  <img src="https://img.shields.io/badge/TypeScript-3178C6?style=flat&colorA=222222&logo=typescript&logoColor=white" alt="TypeScript">
+  <img src="https://img.shields.io/badge/runtime-Bun-f472b6?style=flat&colorA=222222" alt="Bun">
+  <a href="https://github.com/mohndoe/pi-atlas/blob/main/LICENSE"><img src="https://img.shields.io/github/license/mohndoe/pi-atlas?style=flat&colorA=222222&colorB=58A6FF" alt="License"></a>
+</p>
 
-A terminal UI extension for [pi](https://pi.dev) that turns your agent session logs into an interactive dashboard — costs, languages, models, projects, tools, and token usage at a glance.
+A [pi](https://pi.dev) extension that turns your session logs into an interactive dashboard — costs, languages, models, projects, tools, and token usage at a glance.
+
+<p align="center">
+ <img alt="pi-atlas screenshot" src="./media/screenshot.png" />
+</p>
 
 ---
 
 ## Features
 
-- **Cost tracking** — per-model, per-project, and daily spend with ASCII bar charts
-- **Language breakdown** — lines written and edited, ranked with proportional bars
-- **Model analytics** — provider-aware model cost, call count, and sortable table
-- **Project attribution** — cost and session count per project directory
-- **Tool usage** — call frequency and token breakdown (input, output, cache read/write)
 - **Multiple time ranges** — Today, Last 7 days, Last 30 days, or All time
-- **Cache** — SHA-256-gated persists day aggregates; near-instant open on repeat visits
-- **Zero dependencies beyond pi** — uses only the pi TUI and the `pi-tui-extras` component library
+- **Cost tracking** — per-model, per-project, based on real usage costs
+- **Language breakdown** — lines written and edited
+- **Model analytics** — provider-aware model cost, call count, works with local LLMs too
+- **Project attribution** — cost and session count per project directory
+- **Usage overview** — tool call frequency and token breakdown (input, output, cache read/write)
+- **Cache** — SHA-256-gated persists day aggregates; near-instant open on next visits
+- **Zero dependencies** — uses only the pi TUI and the [`@mohndoe/pi-tui-extras`](https://github.com/MohnDoe/pi-tui-extras) component library
 
 ## Dashboard
 
-The dashboard opens as a centered overlay popup (50% width, max 80% height). Navigate with the keyboard:
-
-| Key            | Action                                           |
-| -------------- | ------------------------------------------------ |
-| `←` `→`        | Switch tabs                                      |
-| `r`            | Cycle time range (Today → 7d → 30d → All)        |
-| `↑` `↓`        | Scroll table rows (Models, Projects, Usage tabs) |
-| `q` / `Escape` | Close dashboard                                  |
-
 ### Tabs
 
-- **Overview** — KPI cards (Total Cost, Sessions, Messages, Active Days, Avg/Day, Tokens) in a compact grid. Below: a daily spend bar chart auto-scaled to fill available height. Bottom row shows top language, top model, and top project side by side. On the 1d range, the bar chart switches to hourly spend.
-- **Languages** — Table of all programming languages detected in session logs. Color-coded per-language palette.
-- **Models** — Table of all models and providers used. Columns: Model, Provider, Calls, Cost. Color-coded per-provider palette.
+- **Overview** — Cards displaying total cost, sessions count, messages count, active days, average cost per day, total tokens. A bar chart displaying cost overtime. And top language, top model, and top project side by side.
+- **Languages** — Languages ranked by line written.
+- **Models** — Models ranked by cost. Shows providers, calls and cost per model.
 - **Projects** — Projects ranked by cost. Shows session count and cost per project.
 - **Usage** — Token breakdown (Total, Input, Output, Cache Read, Cache Write) and table of tool usage.
 
-## Install
+All tabs displayed data correspond to the selected time range (press `r` to change it). Press left/right arrows to change tabs.
 
-### Via pi
+## Install
 
 ```bash
 pi install npm:@mohndoe/pi-atlas
@@ -49,7 +52,7 @@ Then run `/reload` in pi (or restart pi). The `/atlas` command is now available.
 
 ## Usage
 
-In the pi terminal, type `/atlas` to open the atlas dashboard. Session data is loaded from `~/.pi/agent/sessions/` — on first load this may take a moment while JSONL files are parsed. Subsequent opens use a cached snapshot and load instantly.
+In the pi terminal, type `/atlas` to open the atlas dashboard. Session data is loaded from `~/.pi/agent/sessions/` -- on first load this may take a moment while JSONL files are parsed. Subsequent opens use a cached snapshot and load instantly.
 
 ## How it works
 

package/bunfig.toml

@@ -0,0 +1,37 @@
+[test]
+root = "src"
+coverageThreshold = { lines = 0.85, functions = 0.90, statements = 0.80 }
+coveragePathIgnorePatterns = [
+  # Test files
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "**/*.e2e.ts",
+  "**/*.fixtures.ts",
+
+  # Configuration files
+  "*.config.js",
+  "*.config.ts",
+  "webpack.config.*",
+  "vite.config.*",
+
+  # Build output
+  "dist/**",
+  "build/**",
+  ".next/**",
+
+  # Generated code
+  "generated/**",
+  "**/*.generated.ts",
+
+  # Vendor/third-party
+  "vendor/**",
+  "third-party/**",
+
+  # Utilities that don't need testing
+  "src/utils/constants.ts",
+  "src/types/**",
+
+  "node_modules/**",
+  # ignores linked local-dev package
+  "../pi-tui-extras/**",
+]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mohndoe/pi-atlas",
-  "version": "0.1.2",
-  "description": "Pi extension providing an atlas of agent activity — costs, languages, models, projects, and tools from session logs.",
+  "version": "0.1.4",
+  "description": "See your agent usage and cost directly in Pi — costs, languages, models, projects, and tools from session logs.",
   "keywords": [
     "pi",
     "pi-extension",
@@ -44,6 +44,7 @@
   "pi": {
     "extensions": [
       "./src/index.ts"
-    ]
+    ],
+    "image": "https://github.com/mohndoe/pi-atlas/raw/main/media/screenshot.png"
   }
 }

package/src/__tests__/e2e.test.ts

@@ -2,12 +2,12 @@ import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { allRanges } from "../components/__tests__/Dashboard.test";
+import { makeMockTUI, makeRangeSelector, makeTheme } from "../components/components.fixtures";
 import { Dashboard } from "../components/Dashboard";
+import { allRanges } from "../components/Dashboard.test";
 import { summarize } from "../compute";
 import { parseFile } from "../parser";
-import { type DayAgg } from "../types";
-import { makeMockTUI, makeRangeSelector, makeTheme } from "./components.fixtures";
+import type { DayAgg } from "../types";
 
 const mockTui = makeMockTUI();
 

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

@@ -1,16 +1,18 @@
 import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
+  type LoadingProgress,
   computeSignature,
   getCacheTimestamp,
+  isCacheValid,
   loadAggregate,
   readCache,
   writeCache,
-} from "../cache";
-import { emptyDay } from "../parser";
-import { type DayAgg } from "../types";
+} from "./cache";
+import { emptyDay } from "./parser";
+import type { DayAgg } from "./types";
 
 describe("computeSignature", () => {
   let tmpDir: string;
@@ -72,6 +74,17 @@ describe("computeSignature", () => {
     expect(sig.length).toBeGreaterThan(0);
   });
 
+  it("scans nested subdirectories two levels deep", async () => {
+    const lvl1 = join(tmpDir, "project-a");
+    const lvl2 = join(lvl1, "nested");
+    await mkdir(lvl2, { recursive: true });
+    await writeFile(join(lvl2, "s1.jsonl"), "data\n");
+
+    const sig = await computeSignature(tmpDir);
+    expect(sig).toBeTruthy();
+    expect(sig.length).toBeGreaterThan(0);
+  });
+
   it("ignores non-.jsonl files", async () => {
     await writeFile(join(tmpDir, "README.md"), "docs\n");
     const sig = await computeSignature(tmpDir);
@@ -79,6 +92,57 @@ describe("computeSignature", () => {
   });
 });
 
+describe("isCacheValid", () => {
+  let tmpDir: string;
+  let cachePath: string;
+  let sessionsDir: string;
+
+  beforeEach(async () => {
+    tmpDir = join(tmpdir(), `pi-atlas-isvalid-${Date.now()}`);
+    await mkdir(tmpDir, { recursive: true });
+    cachePath = join(tmpDir, "cache.json");
+    sessionsDir = join(tmpDir, "sessions");
+    await mkdir(sessionsDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns false when cache file does not exist", async () => {
+    const valid = await isCacheValid(cachePath, sessionsDir);
+    expect(valid).toBe(false);
+  });
+
+  it("returns false when cache signature differs from current", async () => {
+    // Write a session file, compute its signature, write cache with that sig
+    await writeFile(join(sessionsDir, "s1.jsonl"), "data\n");
+    const sig = await computeSignature(sessionsDir);
+    const d = emptyDay("2026-06-08");
+    await writeCache(cachePath, sig, [d]);
+
+    const validBefore = await isCacheValid(cachePath, sessionsDir);
+    expect(validBefore).toBe(true);
+
+    // Add a session file that changes the real signature
+    await writeFile(join(sessionsDir, "s2.jsonl"), "data\n");
+
+    const valid = await isCacheValid(cachePath, sessionsDir);
+    expect(valid).toBe(false);
+  });
+
+  it("returns true when cache signature matches current", async () => {
+    // Write a session file, compute its signature, write cache with that sig
+    await writeFile(join(sessionsDir, "s1.jsonl"), "data\n");
+    const sig = await computeSignature(sessionsDir);
+    const d = emptyDay("2026-06-08");
+    await writeCache(cachePath, sig, [d]);
+
+    const valid = await isCacheValid(cachePath, sessionsDir);
+    expect(valid).toBe(true);
+  });
+});
+
 describe("cache read/write", () => {
   let tmpDir: string;
   let cachePath: string;
@@ -121,6 +185,18 @@ describe("cache read/write", () => {
     expect(payload).toBeNull();
   });
 
+  it("returns null when cached JSON lacks a signature", async () => {
+    await writeFile(cachePath, JSON.stringify({ days: [] }));
+    const payload = await readCache(cachePath);
+    expect(payload).toBeNull();
+  });
+
+  it("returns null when cached JSON has signature but days is not an array", async () => {
+    await writeFile(cachePath, JSON.stringify({ signature: "sig", days: {} }));
+    const payload = await readCache(cachePath);
+    expect(payload).toBeNull();
+  });
+
   it("returns generatedAt from valid cache", async () => {
     const d = emptyDay("2026-06-08");
     await writeCache(cachePath, "sig-abc", [d]);
@@ -135,10 +211,49 @@ describe("cache read/write", () => {
     expect(ts).toBeNull();
   });
 
-  it("returns null for corrupt cache", async () => {
-    await writeFile(cachePath, "not-json");
-    const ts = await getCacheTimestamp(cachePath);
-    expect(ts).toBeNull();
+  it("preserves hourCost values through round-trip (numeric keys become strings in JSON)", async () => {
+    const d = emptyDay("2026-06-08");
+    d.hourCost = { 10: 0.5, 14: 1.25 };
+    const days: DayAgg[] = [d];
+    await writeCache(cachePath, "sig-hc", days);
+
+    // Read raw JSON — numeric keys are stored as strings
+    const raw = await readFile(cachePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.days[0].hourCost).toEqual({ "10": 0.5, "14": 1.25 });
+
+    // Round-trip via loadAggregate
+    const sesDir = join(tmpDir, "sessions");
+    await mkdir(sesDir, { recursive: true });
+    await writeFile(
+      join(sesDir, "dummy.jsonl"),
+      JSON.stringify({
+        type: "session",
+        version: 3,
+        id: "s1",
+        timestamp: "2026-06-08T10:00:00.000Z",
+        cwd: "/p",
+      }) + "\n",
+    );
+    const sig = await computeSignature(sesDir);
+    await writeFile(
+      cachePath,
+      JSON.stringify({
+        signature: sig,
+        generatedAt: new Date().toISOString(),
+        days: [
+          {
+            ...parsed.days[0],
+            modelToProvider: {},
+          },
+        ],
+      }),
+    );
+    const loaded = await loadAggregate(cachePath, sesDir);
+    expect(loaded).toHaveLength(1);
+    // Numeric access still works via JS coercion
+    expect(loaded[0]!.hourCost[10]).toBe(0.5);
+    expect(loaded[0]!.hourCost[14]).toBe(1.25);
   });
 
   it("serializes and deserializes modelToProvider Map", async () => {
@@ -261,6 +376,90 @@ describe("loadAggregate", () => {
     expect(days[0]!.userMsgs).toBe(1);
   });
 
+  it("merges data from multiple files sharing the same date", async () => {
+    const projA = join(sessionsDir, "proj-a");
+    const projB = join(sessionsDir, "proj-b");
+    await mkdir(projA, { recursive: true });
+    await mkdir(projB, { recursive: true });
+
+    // Two files, same date, different sessions
+    await writeFile(
+      join(projA, "s1.jsonl"),
+      [
+        JSON.stringify({
+          type: "session",
+          version: 3,
+          id: "s1",
+          timestamp: "2026-06-08T10:00:00.000Z",
+          cwd: "/home/doe/proj-a",
+        }),
+        JSON.stringify({
+          type: "message",
+          id: "m1",
+          parentId: "p",
+          timestamp: "2026-06-08T10:01:00.000Z",
+          message: { role: "user", content: [{ type: "text", text: "hi from a" }] },
+        }),
+      ].join("\n"),
+    );
+
+    await writeFile(
+      join(projB, "s2.jsonl"),
+      [
+        JSON.stringify({
+          type: "session",
+          version: 3,
+          id: "s2",
+          timestamp: "2026-06-08T14:00:00.000Z",
+          cwd: "/home/doe/proj-b",
+        }),
+        JSON.stringify({
+          type: "message",
+          id: "m1",
+          parentId: "p",
+          timestamp: "2026-06-08T14:01:00.000Z",
+          message: { role: "user", content: [{ type: "text", text: "hi from b" }] },
+        }),
+      ].join("\n"),
+    );
+
+    const days = await loadAggregate(cachePath, sessionsDir, true);
+    expect(days).toHaveLength(1);
+    expect(days[0]!.date).toBe("2026-06-08");
+    expect(days[0]!.userMsgs).toBe(2); // one from each file
+    expect(days[0]!.sessionIds.size).toBe(2); // s1 and s2 merged
+  });
+
+  it("writes a cache file on disk after parsing", async () => {
+    const subDir = join(sessionsDir, "proj-a");
+    await mkdir(subDir);
+    await writeFile(
+      join(subDir, "s1.jsonl"),
+      [
+        JSON.stringify({
+          type: "session",
+          version: 3,
+          id: "s1",
+          timestamp: "2026-06-08T10:00:00.000Z",
+          cwd: "/home/doe/proj-a",
+        }),
+      ].join("\n"),
+    );
+
+    await loadAggregate(cachePath, sessionsDir);
+
+    // Verify the cache file was written
+    const payload = await readCache(cachePath);
+    expect(payload).not.toBeNull();
+    expect(payload!.days).toHaveLength(1);
+    expect(payload!.days[0]!.date).toBe("2026-06-08");
+    expect(payload!.generatedAt).toBeTruthy();
+
+    // Verify the signature corresponds to the actual session files
+    const realSig = await computeSignature(sessionsDir);
+    expect(payload!.signature).toBe(realSig);
+  });
+
   it("caches results and reuses them", async () => {
     const subDir = join(sessionsDir, "proj-a");
     await mkdir(subDir);
@@ -363,6 +562,73 @@ describe("loadAggregate", () => {
     }
   });
 
+  it("force=true re-parses even when valid cache exists", async () => {
+    // Create a session file
+    const subDir = join(sessionsDir, "proj-a");
+    await mkdir(subDir);
+    await writeFile(
+      join(subDir, "s1.jsonl"),
+      [
+        JSON.stringify({
+          type: "session",
+          version: 3,
+          id: "s1",
+          timestamp: "2026-06-08T10:00:00.000Z",
+          cwd: "/home/doe/proj-a",
+        }),
+        JSON.stringify({
+          type: "message",
+          id: "m1",
+          parentId: "p",
+          timestamp: "2026-06-08T10:01:00.000Z",
+          message: { role: "user", content: [{ type: "text", text: "hi" }] },
+        }),
+      ].join("\n"),
+    );
+
+    // Compute the real signature for these files
+    const realSig = await computeSignature(sessionsDir);
+
+    // Write a cache file directly with the correct signature but STALE data
+    await writeFile(
+      cachePath,
+      JSON.stringify({
+        signature: realSig,
+        generatedAt: new Date().toISOString(),
+        days: [
+          {
+            date: "2026-06-08",
+            cost: 0,
+            inTok: 0,
+            outTok: 0,
+            crTok: 0,
+            cwTok: 0,
+            userMsgs: 9999, // stale: real data has 1
+            asstMsgs: 0,
+            toolResults: 0,
+            sessionIds: [],
+            langLines: {},
+            langEdits: {},
+            modelCost: {},
+            modelCount: {},
+            providerCost: {},
+            providerCount: {},
+            modelToProvider: {},
+            projectCost: {},
+            projectSessions: {},
+            toolCount: {},
+          },
+        ],
+      }),
+    );
+
+    // force=true should ignore the stale cache and re-parse
+    const days = await loadAggregate(cachePath, sessionsDir, true);
+    expect(days).toHaveLength(1);
+    expect(days[0]!.userMsgs).toBe(1);
+    expect(days[0]!.asstMsgs).toBe(0);
+  });
+
   it("calls onProgress during parsing", async () => {
     const subDir = join(sessionsDir, "proj-a");
     await mkdir(subDir);
@@ -379,10 +645,45 @@ describe("loadAggregate", () => {
       ].join("\n"),
     );
 
-    const progress: number[] = [];
+    const progress: LoadingProgress[] = [];
     await loadAggregate(cachePath, sessionsDir, false, (p) => progress.push(p));
 
-    // Should have reported some progress
+    // Should have reported some progress and reached 100%
     expect(progress.length).toBeGreaterThan(0);
+    expect(progress[progress.length - 1]!.pct).toBe(100);
+  });
+
+  it("reports intermediate progress with multiple files", async () => {
+    const projA = join(sessionsDir, "a");
+    const projB = join(sessionsDir, "b");
+    await mkdir(projA, { recursive: true });
+    await mkdir(projB, { recursive: true });
+
+    await writeFile(
+      join(projA, "s1.jsonl"),
+      JSON.stringify({
+        type: "session",
+        version: 3,
+        id: "s1",
+        timestamp: "2026-06-08T10:00:00.000Z",
+        cwd: "/p",
+      }) + "\n",
+    );
+    await writeFile(
+      join(projB, "s2.jsonl"),
+      JSON.stringify({
+        type: "session",
+        version: 3,
+        id: "s2",
+        timestamp: "2026-06-09T10:00:00.000Z",
+        cwd: "/p",
+      }) + "\n",
+    );
+
+    const progress: LoadingProgress[] = [];
+    await loadAggregate(cachePath, sessionsDir, true, (p) => progress.push(p));
+
+    // Two files: should get 50% and 100%
+    expect(progress.map((p) => p.pct)).toEqual([50, 100]);
   });
 });

package/src/cache.ts

@@ -105,6 +105,9 @@ export async function isCacheValid(cachePath: string, sessionsDir: string): Prom
   return cached.signature === currentSig;
 }
 
+/** Sleep helper for debug delay */
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
 // ---- Aggregate loading ----
 
 async function findAllJsonlFiles(dir: string): Promise<string[]> {
@@ -125,15 +128,24 @@ async function findAllJsonlFiles(dir: string): Promise<string[]> {
   await walk(dir);
   return result;
 }
+export interface LoadingProgress {
+  total: number;
+  done: number;
+  pct: number;
+  remainingTimeMs?: number;
+}
 
 export async function loadAggregate(
   cachePath: string,
   sessionsDir: string,
   force = false,
-  onProgress?: (p: number) => void,
+  onProgress?: (p: LoadingProgress) => void,
 ): Promise<DayAgg[]> {
+  // Debug flags: PI_ATLAS_FORCE_CACHE=1 skips cache, PI_ATLAS_SLOW_DELAY_MS=<ms> adds per-file delay
+  const effectiveForce = force || Boolean(Number(process.env["PI_ATLAS_FORCE_CACHE"] ?? 0));
+
   // Try cache first
-  if (!force) {
+  if (!effectiveForce) {
     const valid = await isCacheValid(cachePath, sessionsDir);
     if (valid) {
       const cached = await readCache(cachePath);
@@ -146,7 +158,16 @@ export async function loadAggregate(
   const map = new Map<string, DayAgg>();
   let totalCorrupt = 0;
 
+  const slowDelayMs = Number(process.env["PI_ATLAS_SLOW_DELAY_MS"] ?? 0);
+  const parseStart = performance.now();
+
   for (let i = 0; i < files.length; i++) {
+    if (slowDelayMs > 0) {
+      // Progress callback to show we're alive before first file
+      if (i === 0 && onProgress) onProgress({ total: 0, done: 0, pct: 0 });
+      await sleep(slowDelayMs);
+    }
+
     let lastCount = 0;
     const fileMap = parseFile(files[i]!, (count) => {
       lastCount = count;
@@ -161,7 +182,19 @@ export async function loadAggregate(
         map.set(date, day);
       }
     }
-    if (onProgress) onProgress(Math.round(((i + 1) / files.length) * 100));
+    if (onProgress) {
+      const done = i + 1;
+      const elapsedMs = performance.now() - parseStart;
+      // Minimum 3 samples before showing estimate (too noisy before that)
+      const remainingTimeMs =
+        done >= 3 ? Math.round((elapsedMs / done) * (files.length - done)) : undefined;
+      onProgress({
+        done,
+        total: files.length,
+        pct: Math.round((done / files.length) * 100),
+        remainingTimeMs,
+      });
+    }
   }
 
   if (totalCorrupt > 0) {