exe-watcher 0.2.66 → 0.2.68

package/dist/cli.js

@@ -2125,12 +2125,12 @@ function getPricingWarnings() {
 }
 function getPricingMetadata() {
   return {
-    basis: "latest-rates",
+    basis: "recorded-rates",
     currency: "USD",
     refreshedAt: _pricingLastUpdated ? new Date(_pricingLastUpdated).toISOString() : null,
     fallbackVerifiedOn: verified_pricing_default.verifiedOn,
     sources: OFFICIAL_PRICING_SOURCES,
-    note: "Historical and current usage are valued at the latest available API list rates. This is an API-equivalent estimate, not a reconstruction of past invoices."
+    note: "Counted usage keeps its recorded API-equivalent cost. Latest available rates apply to newly observed usage; price refreshes do not revalue saved history. This is an estimate, not a reconstruction of invoices."
   };
 }
 function getCachePath() {
@@ -2690,12 +2690,223 @@ var init_discovery_cache = __esm({
   }
 });
 
+// src/sqlite.ts
+import { createRequire } from "module";
+function loadDriver() {
+  if (loadAttempted) return DatabaseSync !== null;
+  loadAttempted = true;
+  const origEmit = process.emit.bind(process);
+  let restored = false;
+  const restore = () => {
+    if (restored) return;
+    restored = true;
+    process.emit = origEmit;
+  };
+  process.emit = function patchedEmit(event, ...args) {
+    if (event === "warning") {
+      const warning = args[0];
+      if (warning?.name === "ExperimentalWarning" && typeof warning.message === "string" && /SQLite/i.test(warning.message)) {
+        return false;
+      }
+    }
+    return origEmit.call(this, event, ...args);
+  };
+  try {
+    const mod = requireForSqlite("node:sqlite");
+    DatabaseSync = mod.DatabaseSync;
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    loadError = `Watcher saved costs and SQLite-based providers need Node 22.13+ (Node 23 requires 23.4+) with node:sqlite.
+Current Node: ${process.version}.
+Upgrade Node (https://nodejs.org) and run exe-watcher again.
+(underlying error: ${message})`;
+    return false;
+  } finally {
+    setTimeout(restore, 0);
+  }
+}
+function isSqliteAvailable() {
+  return loadDriver();
+}
+function getSqliteLoadError() {
+  return loadError ?? "SQLite driver not available";
+}
+function openDatabase(path) {
+  if (!loadDriver() || DatabaseSync === null) {
+    throw new Error(getSqliteLoadError());
+  }
+  const db = new DatabaseSync(path, { readOnly: true });
+  return {
+    query(sql, params = []) {
+      const rows2 = [];
+      let bytes = 0;
+      for (const row of db.prepare(sql).iterate(...params)) {
+        const size = Buffer.byteLength(JSON.stringify(row));
+        bytes += size;
+        if (rows2.length >= 1e5 || bytes > 32 * 1024 * 1024) throw new ResourceBudgetError("SQLite result budget");
+        chargeRead(size);
+        rows2.push(row);
+      }
+      return rows2;
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+var requireForSqlite, DatabaseSync, loadAttempted, loadError;
+var init_sqlite = __esm({
+  "src/sqlite.ts"() {
+    "use strict";
+    init_resource_budget();
+    requireForSqlite = createRequire(import.meta.url);
+    DatabaseSync = null;
+    loadAttempted = false;
+    loadError = null;
+  }
+});
+
+// src/recorded-costs.ts
+import { createHash as createHash2 } from "crypto";
+import { createRequire as createRequire2 } from "module";
+import { chmodSync, existsSync, lstatSync, mkdirSync } from "fs";
+import { join as join9 } from "path";
+function database() {
+  const directory = getCacheDir();
+  const path = join9(directory, "recorded-costs.sqlite");
+  if (opened?.path === path && existsSync(path)) return opened.db;
+  opened?.db.close();
+  opened = void 0;
+  if (!isSqliteAvailable()) throw new Error(getSqliteLoadError());
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  if (existsSync(path) && !lstatSync(path).isFile()) throw new Error("Watcher pricing ledger must be a regular file");
+  const { DatabaseSync: DatabaseSync2 } = require2("node:sqlite");
+  const db = new DatabaseSync2(path);
+  chmodSync(path, 384);
+  db.exec("PRAGMA busy_timeout=1000; PRAGMA cache_size=-1024; PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;");
+  const pageSize = Number(db.prepare("PRAGMA page_size").get().page_size);
+  db.exec(`PRAGMA max_page_count=${Math.floor(512 * 1024 * 1024 / pageSize)}`);
+  db.exec("CREATE TABLE IF NOT EXISTS costs (id BLOB PRIMARY KEY, usd REAL NOT NULL CHECK(usd >= 0)) WITHOUT ROWID");
+  opened = { path, db };
+  return db;
+}
+function costRow(value) {
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const { provider, model, deduplicationKey, costUSD } = record;
+  if (typeof provider !== "string" || typeof model !== "string" || typeof deduplicationKey !== "string" || !deduplicationKey || typeof costUSD !== "number" || !Number.isFinite(costUSD) || costUSD < 0) return null;
+  if (costUSD === 0 && !getModelCosts(model)) return "unpriced";
+  const usage = record.usage ?? record;
+  const fields2 = ["inputTokens", "outputTokens", "cacheCreationInputTokens", "cacheReadInputTokens", "cacheCreation1hInputTokens", "webSearchRequests"];
+  const tokens = fields2.map((field) => usage[field] ?? 0);
+  if (!tokens.every((value2) => typeof value2 === "number" && Number.isFinite(value2) && value2 >= 0)) return null;
+  const id = createHash2("sha256").update(JSON.stringify([provider, deduplicationKey, model, record.speed ?? "standard", ...tokens])).digest();
+  return { record, id };
+}
+function lockRecordedCosts(data) {
+  let db;
+  let batch = [];
+  let hasUnpricedUsage = false;
+  const flush = () => {
+    if (!batch.length) return;
+    chargeRead(0);
+    db ??= database();
+    const placeholders = batch.map(() => "?").join(",");
+    const query = db.prepare(`SELECT id, usd FROM costs WHERE id IN (${placeholders})`);
+    const read = () => new Map(query.all(...batch.map((row) => row.id)).map((row) => {
+      const cost = Number(row.usd);
+      if (!Number.isFinite(cost) || cost < 0) throw new Error("Watcher pricing ledger contains an invalid recorded cost");
+      return [Buffer.from(row.id).toString("hex"), cost];
+    }));
+    let known = read();
+    const missing = batch.filter((row) => !known.has(row.id.toString("hex")));
+    if (missing.length) {
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const insert = db.prepare("INSERT OR IGNORE INTO costs (id, usd) VALUES (?, ?)");
+        for (const row of missing) insert.run(row.id, row.record.costUSD);
+        db.exec("COMMIT");
+      } catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+      }
+      known = read();
+    }
+    chargeRead(known.size * 40);
+    for (const row of batch) row.record.costUSD = known.get(row.id.toString("hex"));
+    batch = [];
+  };
+  const add2 = (value) => {
+    const row = costRow(value);
+    if (row === "unpriced") hasUnpricedUsage = true;
+    else if (row) batch.push(row);
+    if (batch.length === BATCH) flush();
+  };
+  for (const entry of data) {
+    if (entry && typeof entry === "object" && Array.isArray(entry.assistantCalls)) {
+      for (const call of entry.assistantCalls) add2(call);
+    } else add2(entry);
+  }
+  flush();
+  return hasUnpricedUsage;
+}
+var require2, BATCH, opened;
+var init_recorded_costs = __esm({
+  "src/recorded-costs.ts"() {
+    "use strict";
+    init_cache_dir();
+    init_models();
+    init_resource_budget();
+    init_sqlite();
+    require2 = createRequire2(import.meta.url);
+    BATCH = 128;
+  }
+});
+
 // src/parsed-file-cache.ts
 import { gzip, gunzip } from "zlib";
 import { promisify } from "util";
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir8, readFile as readFile7, stat as stat5, writeFile as writeFile3, rename as rename6, unlink as unlink5, readdir as readdir3 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
+function encodeEntry(value) {
+  let bytes = 0;
+  try {
+    return JSON.stringify(value, (key2, item) => {
+      bytes += key2 ? Buffer.byteLength(JSON.stringify(key2)) + 2 : 0;
+      bytes += item && typeof item === "object" ? 2 : Buffer.byteLength(JSON.stringify(item) ?? "null");
+      if (bytes > MAX_ENTRY) throw new Error("parsed entry limit");
+      return item;
+    });
+  } catch {
+    return void 0;
+  }
+}
+function fileProgress(path, dir, cachePath, before) {
+  let startingOffset = 0;
+  return {
+    async load(valid) {
+      if (!before) return;
+      try {
+        const size = (await stat5(cachePath)).size;
+        if (size > MAX_ENTRY) return;
+        chargeRead(size);
+        const saved = JSON.parse((await decompress(await readFile7(cachePath), { maxOutputLength: MAX_ENTRY })).toString("utf8"));
+        if (saved.v !== VERSION2 || saved.fingerprint !== before || !Number.isSafeInteger(saved.offset) || saved.offset <= 0 || saved.offset > Number(before.split(":")[2]) || !valid(saved.state)) return;
+        startingOffset = saved.offset;
+        return { offset: saved.offset, state: saved.state };
+      } catch (error) {
+        if (error instanceof ResourceBudgetError) throw error;
+      }
+    },
+    async save(state, offset) {
+      if (!before || offset <= startingOffset || offset > Number(before.split(":")[2]) || await fingerprint(path) !== before) return;
+      const payload = encodeEntry({ v: VERSION2, fingerprint: before, offset, state });
+      if (payload) await storeParsedEntry(dir, cachePath, payload);
+    }
+  };
+}
 async function fingerprint(path) {
   try {
     const s = await stat5(path);
@@ -2706,12 +2917,15 @@ async function fingerprint(path) {
   }
 }
 async function cachedFileParse(path, kind, parse, warnings, range) {
-  const dir = join9(getCacheDir(), "parsed-files");
-  const key2 = createHash2("sha256").update(`${VERSION2}:${kind}:${path}:${getPricingFingerprint()}`).digest("hex");
-  const cachePath = join9(dir, `v${VERSION2}-${key2}.json.gz`);
+  const dir = join10(getCacheDir(), "parsed-files");
+  const key2 = createHash3("sha256").update(`${VERSION2}:${kind}:${path}`).digest("hex");
+  const cachePath = join10(dir, `v${VERSION2}-${key2}.json.gz`);
+  const progressPath = join10(dir, `v${VERSION2}-progress-${key2}.json.gz`);
+  const legacyKey = createHash3("sha256").update(`3:${kind}:${path}:${getPricingFingerprint()}`).digest("hex");
+  const legacyPath = join10(dir, `v3-${legacyKey}.json.gz`);
   const fingerprintPath = kind === "opencode" ? path.slice(0, path.lastIndexOf(":")) : path;
   const before = await fingerprint(fingerprintPath);
-  const rangeKind = `usage-range:${VERSION2}:${kind}`;
+  const rangeKind = `usage-range:3:${kind}`;
   const bounds = range && before ? await readDiscoveryFact(rangeKind, path, before) : void 0;
   if (range && bounds && (bounds.last < range.start.getTime() || bounds.first > range.end.getTime())) {
     if (Array.isArray(bounds.warnings)) warnings?.push(...bounds.warnings);
@@ -2729,32 +2943,52 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
     }
     await rememberDiscoveryFact(rangeKind, path, before, { first: data2.length ? first : 0, last: data2.length ? last : -1, warnings });
   };
+  let migrated;
   if (before) {
-    try {
-      const s = await stat5(cachePath);
-      if (s.size <= MAX_ENTRY) {
-        chargeRead(s.size);
-        const saved = JSON.parse((await decompress(await readFile7(cachePath), { maxOutputLength: MAX_ENTRY })).toString("utf8"));
-        if (saved.v === VERSION2 && saved.fingerprint === before && Array.isArray(saved.data)) {
-          if (Array.isArray(saved.warnings)) warnings?.push(...saved.warnings.filter((w) => typeof w === "string"));
-          await rememberRange(saved.data);
-          return saved.data;
+    for (const candidate of [cachePath, legacyPath]) {
+      try {
+        const s = await stat5(candidate);
+        if (s.size <= MAX_ENTRY) {
+          chargeRead(s.size);
+          const saved = JSON.parse((await decompress(await readFile7(candidate), { maxOutputLength: MAX_ENTRY })).toString("utf8"));
+          if ((saved.v === VERSION2 || saved.v === 3) && saved.fingerprint === before && Array.isArray(saved.data)) {
+            if (Array.isArray(saved.warnings)) warnings?.push(...saved.warnings.filter((w) => typeof w === "string"));
+            await rememberRange(saved.data);
+            if (saved.v === VERSION2 && saved.pricesLocked === true) {
+              if (!saved.hasUnpricedUsage || saved.pricingFingerprint === getPricingFingerprint()) return saved.data;
+              continue;
+            }
+            migrated = saved.data;
+            break;
+          }
         }
+      } catch (err) {
+        if (err instanceof ResourceBudgetError) throw err;
       }
-    } catch (err) {
-      if (err instanceof ResourceBudgetError) throw err;
     }
   }
-  const data = await parse();
+  const data = migrated ?? await parse(fileProgress(fingerprintPath, dir, progressPath, before));
+  const hasUnpricedUsage = lockRecordedCosts(data);
   if (!before || await fingerprint(fingerprintPath) !== before) return data;
   await rememberRange(data);
-  const payload = JSON.stringify({ v: VERSION2, fingerprint: before, data, warnings });
-  if (Buffer.byteLength(payload) > MAX_ENTRY) return data;
+  const payload = encodeEntry({
+    v: VERSION2,
+    fingerprint: before,
+    data,
+    warnings,
+    pricesLocked: true,
+    hasUnpricedUsage,
+    pricingFingerprint: getPricingFingerprint()
+  });
+  if (payload) await storeParsedEntry(dir, cachePath, payload, progressPath);
+  return data;
+}
+async function storeParsedEntry(dir, cachePath, payload, obsolete) {
   await mkdir8(dir, { recursive: true });
   const encoded = await compress(Buffer.from(payload));
-  const release = await acquireFileLock(join9(dir, "writes.lock"));
+  const release = await acquireFileLock(join10(dir, "writes.lock"));
   try {
-    const quotaPath = join9(dir, "quota");
+    const quotaPath = join10(dir, "quota");
     const quota = await readFile7(quotaPath, "utf8").catch(() => "");
     let total = /^\d+$/.test(quota) ? Number(quota) : NaN;
     const writeQuota = async (bytes) => {
@@ -2772,12 +3006,12 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
       const rows2 = [];
       for (const name of files) {
         if (!name.endsWith(".json") && !name.endsWith(".json.gz") && !name.endsWith(".tmp")) continue;
-        if (!name.startsWith(`v${VERSION2}-`)) {
-          await unlink5(join9(dir, name)).catch(() => {
+        if (!name.startsWith(`v${VERSION2}-`) && !name.startsWith("v3-")) {
+          await unlink5(join10(dir, name)).catch(() => {
           });
           continue;
         }
-        const p = join9(dir, name), s = await stat5(p).catch(() => null);
+        const p = join10(dir, name), s = await stat5(p).catch(() => null);
         if (s) rows2.push({ path: p, size: s.size, mtime: s.mtimeMs });
       }
       total = rows2.reduce((n, r) => n + r.size, 0);
@@ -2792,12 +3026,12 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
     if (!(await readFile7(cachePath).catch(() => Buffer.alloc(0))).equals(encoded)) {
       const oldSize = (await stat5(cachePath).catch(() => null))?.size ?? 0;
       let nextSize = total + encoded.length;
-      if (!Number.isFinite(nextSize)) return data;
+      if (!Number.isFinite(nextSize)) return;
       if (nextSize > MAX_DISK) {
         const rows2 = [];
         for (const name of await readdir3(dir)) {
           if (!name.endsWith(".json.gz")) continue;
-          const p = join9(dir, name);
+          const p = join10(dir, name);
           if (p === cachePath) continue;
           const s = await stat5(p).catch(() => null);
           if (s) rows2.push({ path: p, size: s.size, mtime: s.mtimeMs });
@@ -2808,25 +3042,33 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
           });
           nextSize -= row.size;
         }
-        if (nextSize > MAX_DISK) return data;
+        if (nextSize > MAX_DISK) return;
       }
       const tmp = `${cachePath}.${randomUUID2()}.tmp`;
       try {
         await writeQuota(nextSize);
         await writeFile3(tmp, encoded, { mode: 384 });
         await rename6(tmp, cachePath);
+        mutationCount++;
         if (oldSize) await writeQuota(nextSize - oldSize);
+        total = nextSize - oldSize;
       } finally {
         await unlink5(tmp).catch(() => {
         });
       }
     }
+    if (obsolete) {
+      const size = (await stat5(obsolete).catch(() => null))?.size ?? 0;
+      if (size) {
+        await unlink5(obsolete);
+        await writeQuota(Math.max(0, total - size));
+      }
+    }
   } finally {
     await release();
   }
-  return data;
 }
-var VERSION2, compress, decompress, MAX_ENTRY, MAX_DISK;
+var VERSION2, compress, decompress, MAX_ENTRY, MAX_DISK, mutationCount, parsedFileProgress;
 var init_parsed_file_cache = __esm({
   "src/parsed-file-cache.ts"() {
     "use strict";
@@ -2835,11 +3077,14 @@ var init_parsed_file_cache = __esm({
     init_resource_budget();
     init_file_lock();
     init_discovery_cache();
-    VERSION2 = 3;
+    init_recorded_costs();
+    VERSION2 = 4;
     compress = promisify(gzip);
     decompress = promisify(gunzip);
     MAX_ENTRY = 16 * 1024 * 1024;
     MAX_DISK = 256 * 1024 * 1024;
+    mutationCount = 0;
+    parsedFileProgress = () => mutationCount;
   }
 });
 
@@ -2948,23 +3193,22 @@ function readSessionFileSync(filePath) {
     closeSync(fd);
   }
 }
-async function* readSessionLines(filePath, startByte = 0, skipOversizedRecord) {
+async function* readSessionLines(filePath, startByte = 0, skipOversizedRecord, completedLine) {
   const handle = await open5(filePath, "r").catch(() => null);
   if (!handle) return;
   try {
     const size = (await handle.stat()).size;
     if (size <= startByte) return;
-    chargeRead(size - startByte);
-    const stream = handle.createReadStream({ encoding: "utf-8", start: startByte, end: size - 1, autoClose: false });
+    const stream = handle.createReadStream({ start: startByte, end: size - 1, autoClose: false });
     let pieces = [];
     let lineBytes = 0;
     let discarding = false;
     const maxLineBytes = 32 * 1024 * 1024;
     const append = (piece) => {
       if (discarding) return;
-      lineBytes += Buffer.byteLength(piece);
+      lineBytes += piece.length;
       if (lineBytes > maxLineBytes) {
-        const prefix = (pieces.slice(0, 4).join("") + piece.slice(0, 1024)).slice(0, 1024);
+        const prefix = Buffer.concat([...pieces.slice(0, 4), piece.subarray(0, 1024)]).toString("utf8").slice(0, 1024);
         if (!skipOversizedRecord?.(prefix)) throw new ResourceBudgetError(`32 MiB JSONL record budget in ${filePath}`);
         discarding = true;
         pieces = [];
@@ -2972,23 +3216,31 @@ async function* readSessionLines(filePath, startByte = 0, skipOversizedRecord) {
       }
       pieces.push(piece);
     };
+    let readThrough = startByte;
     try {
       for await (const chunk of stream) {
+        chargeRead(chunk.length);
+        const chunkStart = readThrough;
+        readThrough += chunk.length;
         let start = 0;
         let newline;
-        while ((newline = chunk.indexOf("\n", start)) >= 0) {
-          append(chunk.slice(start, newline));
+        while ((newline = chunk.indexOf(10, start)) >= 0) {
+          append(chunk.subarray(start, newline));
           chargeRead(0);
-          const line = discarding ? null : pieces.join("").replace(/\r$/, "");
+          const line = discarding ? null : (pieces.length === 1 ? pieces[0] : Buffer.concat(pieces)).toString("utf8").replace(/\r$/, "");
           pieces = [];
           lineBytes = 0;
           discarding = false;
           if (line !== null) yield line;
+          completedLine?.(chunkStart + newline + 1);
           start = newline + 1;
         }
-        if (start < chunk.length) append(chunk.slice(start));
+        if (start < chunk.length) append(chunk.subarray(start));
+      }
+      if (pieces.length) {
+        yield (pieces.length === 1 ? pieces[0] : Buffer.concat(pieces)).toString("utf8").replace(/\r$/, "");
+        completedLine?.(readThrough);
       }
-      if (pieces.length) yield pieces.join("").replace(/\r$/, "");
     } finally {
       stream.destroy();
     }
@@ -3011,15 +3263,15 @@ var init_fs_utils = __esm({
 
 // src/providers/claude.ts
 import { readdir as readdir4, stat as stat6 } from "fs/promises";
-import { basename as basename2, join as join10, resolve as resolve2 } from "path";
+import { basename as basename2, join as join11, resolve as resolve2 } from "path";
 import { homedir as homedir4 } from "os";
 function getClaudeDir() {
-  return process.env["CLAUDE_CONFIG_DIR"] || join10(homedir4(), ".claude");
+  return process.env["CLAUDE_CONFIG_DIR"] || join11(homedir4(), ".claude");
 }
 function getDesktopSessionsDir() {
-  if (process.platform === "darwin") return join10(homedir4(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
-  if (process.platform === "win32") return join10(homedir4(), "AppData", "Roaming", "Claude", "local-agent-mode-sessions");
-  return join10(homedir4(), ".config", "Claude", "local-agent-mode-sessions");
+  if (process.platform === "darwin") return join11(homedir4(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+  if (process.platform === "win32") return join11(homedir4(), "AppData", "Roaming", "Claude", "local-agent-mode-sessions");
+  return join11(homedir4(), ".config", "Claude", "local-agent-mode-sessions");
 }
 async function findDesktopProjectDirs(base) {
   const results = [];
@@ -3028,13 +3280,13 @@ async function findDesktopProjectDirs(base) {
     const entries = await readdir4(dir).catch(() => []);
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join10(dir, entry);
+      const full = join11(dir, entry);
       const s = await stat6(full).catch(() => null);
       if (!s?.isDirectory()) continue;
       if (entry === "projects") {
         const projectDirs = await readdir4(full).catch(() => []);
         for (const pd of projectDirs) {
-          const pdFull = join10(full, pd);
+          const pdFull = join11(full, pd);
           const pdStat = await stat6(pdFull).catch(() => null);
           if (pdStat?.isDirectory()) results.push(pdFull);
         }
@@ -3088,11 +3340,11 @@ var init_claude = __esm({
         const config = await readConfig();
         const roots = /* @__PURE__ */ new Set([getClaudeDir(), ...config.claudeConfigDirs ?? []]);
         for (const root of roots) {
-          const projectsDir = join10(root.startsWith("~/") ? join10(homedir4(), root.slice(2)) : resolve2(root), "projects");
+          const projectsDir = join11(root.startsWith("~/") ? join11(homedir4(), root.slice(2)) : resolve2(root), "projects");
           try {
             const entries = await readdir4(projectsDir);
             for (const dirName of entries) {
-              const dirPath = join10(projectsDir, dirName);
+              const dirPath = join11(projectsDir, dirName);
               const dirStat = await stat6(dirPath).catch(() => null);
               if (dirStat?.isDirectory()) {
                 sources.push({ path: dirPath, project: dirName, provider: "claude" });
@@ -3119,10 +3371,10 @@ var init_claude = __esm({
 
 // src/providers/codex.ts
 import { readdir as readdir5, stat as stat7 } from "fs/promises";
-import { basename as basename3, join as join11 } from "path";
+import { basename as basename3, join as join12 } from "path";
 import { homedir as homedir5 } from "os";
 function getCodexDir(override) {
-  return override ?? process.env["CODEX_HOME"] ?? join11(homedir5(), ".codex");
+  return override ?? process.env["CODEX_HOME"] ?? join12(homedir5(), ".codex");
 }
 function sanitizeProject(cwd) {
   return cwd.replace(/^\//, "").replace(/\//g, "-");
@@ -3143,12 +3395,12 @@ async function readCodexHeader(filePath) {
   return { project: sanitizeProject(entry.payload?.cwd ?? "unknown") };
 }
 async function discoverSessionsInDir(codexDir) {
-  const sessionsDir = join11(codexDir, "sessions");
+  const sessionsDir = join12(codexDir, "sessions");
   const sources = [];
-  const archivedDir = join11(codexDir, "archived_sessions");
+  const archivedDir = join12(codexDir, "archived_sessions");
   for (const file of await readdir5(archivedDir).catch(() => [])) {
     if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-    const filePath = join11(archivedDir, file);
+    const filePath = join12(archivedDir, file);
     const s = await stat7(filePath).catch(() => null);
     if (!s?.isFile()) continue;
     const header = await cachedDiscoveryHeader("codex", filePath, s, () => readCodexHeader(filePath));
@@ -3162,19 +3414,19 @@ async function discoverSessionsInDir(codexDir) {
   }
   for (const year of years) {
     if (!/^\d{4}$/.test(year)) continue;
-    const yearDir = join11(sessionsDir, year);
+    const yearDir = join12(sessionsDir, year);
     const months = await readdir5(yearDir).catch(() => []);
     for (const month of months) {
       if (!/^\d{2}$/.test(month)) continue;
-      const monthDir = join11(yearDir, month);
+      const monthDir = join12(yearDir, month);
       const days = await readdir5(monthDir).catch(() => []);
       for (const day of days) {
         if (!/^\d{2}$/.test(day)) continue;
-        const dayDir = join11(monthDir, day);
+        const dayDir = join12(monthDir, day);
         const files = await readdir5(dayDir).catch(() => []);
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = join11(dayDir, file);
+          const filePath = join12(dayDir, file);
           const s = await stat7(filePath).catch(() => null);
           if (!s?.isFile()) continue;
           const header = await cachedDiscoveryHeader("codex", filePath, s, () => readCodexHeader(filePath));
@@ -3393,10 +3645,10 @@ var init_codex = __esm({
 
 // src/providers/copilot.ts
 import { readdir as readdir6, stat as stat8 } from "fs/promises";
-import { basename as basename4, dirname as dirname3, join as join12 } from "path";
+import { basename as basename4, dirname as dirname3, join as join13 } from "path";
 import { homedir as homedir6 } from "os";
 function getCopilotSessionStateDir(override) {
-  return override ?? join12(homedir6(), ".copilot", "session-state");
+  return override ?? join13(homedir6(), ".copilot", "session-state");
 }
 function parseCwd(yaml) {
   const match = yaml.match(/^cwd:\s*(.+)$/m);
@@ -3471,11 +3723,11 @@ async function discoverSessionsInDir2(sessionStateDir) {
     return sources;
   }
   for (const sessionId of sessionDirs) {
-    const eventsPath = join12(sessionStateDir, sessionId, "events.jsonl");
+    const eventsPath = join13(sessionStateDir, sessionId, "events.jsonl");
     const s = await stat8(eventsPath).catch(() => null);
     if (!s?.isFile()) continue;
     let project = sessionId;
-    const yaml = await readSessionFile(join12(sessionStateDir, sessionId, "workspace.yaml"));
+    const yaml = await readSessionFile(join13(sessionStateDir, sessionId, "workspace.yaml"));
     if (yaml !== null) {
       const cwd = parseCwd(yaml);
       if (cwd) project = basename4(cwd);
@@ -3589,13 +3841,13 @@ var init_bash_utils = __esm({
 
 // src/providers/pi.ts
 import { readdir as readdir7, stat as stat9 } from "fs/promises";
-import { basename as basename6, join as join13 } from "path";
+import { basename as basename6, join as join14 } from "path";
 import { homedir as homedir7 } from "os";
 function getPiSessionsDir(override) {
-  return override ?? join13(homedir7(), ".pi", "agent", "sessions");
+  return override ?? join14(homedir7(), ".pi", "agent", "sessions");
 }
 function getOmpSessionsDir(override) {
-  return override ?? join13(homedir7(), ".omp", "agent", "sessions");
+  return override ?? join14(homedir7(), ".omp", "agent", "sessions");
 }
 async function readFirstEntry(filePath) {
   const line = await readSessionFirstLine(filePath);
@@ -3615,7 +3867,7 @@ async function discoverSessionsInDir3(sessionsDir, providerName) {
     return sources;
   }
   for (const dirName of projectDirs) {
-    const dirPath = join13(sessionsDir, dirName);
+    const dirPath = join14(sessionsDir, dirName);
     const dirStat = await stat9(dirPath).catch(() => null);
     if (!dirStat?.isDirectory()) continue;
     let files;
@@ -3626,7 +3878,7 @@ async function discoverSessionsInDir3(sessionsDir, providerName) {
     }
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = join13(dirPath, file);
+      const filePath = join14(dirPath, file);
       const fileStat = await stat9(filePath).catch(() => null);
       if (!fileStat?.isFile()) continue;
       const first = await readFirstEntry(filePath);
@@ -3783,12 +4035,12 @@ var init_pi = __esm({
 });
 
 // src/providers/kimi.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { readdir as readdir8, readFile as readFile8, stat as stat10 } from "fs/promises";
-import { basename as basename7, dirname as dirname4, join as join14 } from "path";
+import { basename as basename7, dirname as dirname4, join as join15 } from "path";
 import { homedir as homedir8 } from "os";
 function createKimiProvider(home) {
-  const root = () => home ?? process.env["KIMI_CODE_HOME"] ?? join14(homedir8(), ".kimi-code");
+  const root = () => home ?? process.env["KIMI_CODE_HOME"] ?? join15(homedir8(), ".kimi-code");
   return {
     name: "kimi",
     displayName: "Kimi",
@@ -3796,7 +4048,7 @@ function createKimiProvider(home) {
     toolDisplayName: (tool) => tool,
     async discoverSessions() {
       const projects = /* @__PURE__ */ new Map();
-      const catalog = join14(root(), "workspaces.json");
+      const catalog = join15(root(), "workspaces.json");
       try {
         const size = (await stat10(catalog)).size;
         if (size <= 2 * 1024 * 1024) {
@@ -3818,16 +4070,16 @@ function createKimiProvider(home) {
         const entries = await readdir8(dir, { withFileTypes: true }).catch(() => []);
         for (const entry of entries) {
           if (entry.name.startsWith(".")) continue;
-          const path = join14(dir, entry.name);
+          const path = join15(dir, entry.name);
           if (entry.isDirectory()) await walk(path, project, depth + 1);
           else if (entry.isFile() && entry.name === "wire.jsonl") sources.push({ path, project, provider: "kimi" });
         }
       }
-      const sessions = join14(root(), "sessions");
+      const sessions = join15(root(), "sessions");
       for (const entry of await readdir8(sessions, { withFileTypes: true }).catch(() => [])) {
         if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
         const project = projects.get(entry.name) ?? entry.name.replace(/^wd_/, "").replace(/_[a-f\d]{12}$/, "");
-        await walk(join14(sessions, entry.name), project, 0);
+        await walk(join15(sessions, entry.name), project, 0);
       }
       return sources.sort((a, b) => a.path.localeCompare(b.path));
     },
@@ -3866,7 +4118,7 @@ function createKimiProvider(home) {
               const warning = `No API pricing for model "${model}"; its tokens are counted but its cost is excluded. Configure a model alias only when the underlying API model is known.`;
               if (!warnings.includes(warning)) warnings.push(warning);
             }
-            const key2 = "kimi:" + createHash3("sha256").update(JSON.stringify([
+            const key2 = "kimi:" + createHash4("sha256").update(JSON.stringify([
               data.agentId ?? agent,
               data.time,
               data.model,
@@ -3916,10 +4168,10 @@ var init_kimi = __esm({
 // src/cursor-cache.ts
 import { readFile as readFile9, mkdir as mkdir9, stat as stat11, rename as rename7 } from "fs/promises";
 import { open as open6 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 function getCachePath2() {
-  return join15(getCacheDir(), CACHE_FILE);
+  return join16(getCacheDir(), CACHE_FILE);
 }
 async function getDbFingerprint(dbPath) {
   try {
@@ -3984,100 +4236,23 @@ var init_cursor_cache = __esm({
   }
 });
 
-// src/sqlite.ts
-import { createRequire } from "module";
-function loadDriver() {
-  if (loadAttempted) return DatabaseSync !== null;
-  loadAttempted = true;
-  const origEmit = process.emit.bind(process);
-  let restored = false;
-  const restore = () => {
-    if (restored) return;
-    restored = true;
-    process.emit = origEmit;
-  };
-  process.emit = function patchedEmit(event, ...args) {
-    if (event === "warning") {
-      const warning = args[0];
-      if (warning?.name === "ExperimentalWarning" && typeof warning.message === "string" && /SQLite/i.test(warning.message)) {
-        return false;
-      }
-    }
-    return origEmit.call(this, event, ...args);
-  };
-  try {
-    const mod = requireForSqlite("node:sqlite");
-    DatabaseSync = mod.DatabaseSync;
-    return true;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    loadError = `SQLite-based providers (Cursor, OpenCode) need Node 22+ with the node:sqlite module.
-Current Node: ${process.version}.
-Upgrade Node (https://nodejs.org) and run exe-watcher again.
-(underlying error: ${message})`;
-    return false;
-  } finally {
-    setTimeout(restore, 0);
-  }
-}
-function isSqliteAvailable() {
-  return loadDriver();
-}
-function getSqliteLoadError() {
-  return loadError ?? "SQLite driver not available";
-}
-function openDatabase(path) {
-  if (!loadDriver() || DatabaseSync === null) {
-    throw new Error(getSqliteLoadError());
-  }
-  const db = new DatabaseSync(path, { readOnly: true });
-  return {
-    query(sql, params = []) {
-      const rows2 = [];
-      let bytes = 0;
-      for (const row of db.prepare(sql).iterate(...params)) {
-        const size = Buffer.byteLength(JSON.stringify(row));
-        bytes += size;
-        if (rows2.length >= 1e5 || bytes > 32 * 1024 * 1024) throw new ResourceBudgetError("SQLite result budget");
-        chargeRead(size);
-        rows2.push(row);
-      }
-      return rows2;
-    },
-    close() {
-      db.close();
-    }
-  };
-}
-var requireForSqlite, DatabaseSync, loadAttempted, loadError;
-var init_sqlite = __esm({
-  "src/sqlite.ts"() {
-    "use strict";
-    init_resource_budget();
-    requireForSqlite = createRequire(import.meta.url);
-    DatabaseSync = null;
-    loadAttempted = false;
-    loadError = null;
-  }
-});
-
 // src/providers/cursor.ts
 var cursor_exports = {};
 __export(cursor_exports, {
   createCursorProvider: () => createCursorProvider,
   cursor: () => cursor
 });
-import { existsSync } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir9 } from "os";
 function getCursorDbPath() {
   if (process.platform === "darwin") {
-    return join16(homedir9(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+    return join17(homedir9(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
   }
   if (process.platform === "win32") {
-    return join16(homedir9(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb");
+    return join17(homedir9(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb");
   }
-  return join16(homedir9(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+  return join17(homedir9(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
 }
 function extractLanguages(codeBlocksJson) {
   if (!codeBlocksJson) return [];
@@ -4249,7 +4424,7 @@ function createCursorProvider(dbPathOverride) {
     async discoverSessions() {
       if (!isSqliteAvailable()) return [];
       const dbPath = dbPathOverride ?? getCursorDbPath();
-      if (!existsSync(dbPath)) return [];
+      if (!existsSync2(dbPath)) return [];
       return [{ path: dbPath, project: "cursor", provider: "cursor" }];
     },
     createSessionParser(source, seenKeys) {
@@ -4320,19 +4495,19 @@ __export(opencode_exports, {
   opencode: () => opencode
 });
 import { readdir as readdir9 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { homedir as homedir10 } from "os";
 function sanitize2(dir) {
   return dir.replace(/^\//, "").replace(/\//g, "-");
 }
 function getDataDir(dataDir) {
-  const base = dataDir ?? process.env["XDG_DATA_HOME"] ?? join17(homedir10(), ".local", "share");
-  return join17(base, "opencode");
+  const base = dataDir ?? process.env["XDG_DATA_HOME"] ?? join18(homedir10(), ".local", "share");
+  return join18(base, "opencode");
 }
 async function findDbFiles(dir) {
   try {
     const entries = await readdir9(dir);
-    return entries.filter((f) => f.startsWith("opencode") && f.endsWith(".db")).map((f) => join17(dir, f));
+    return entries.filter((f) => f.startsWith("opencode") && f.endsWith(".db")).map((f) => join18(dir, f));
   } catch (error) {
     if (error instanceof ResourceBudgetError) throw error;
     return [];
@@ -4561,20 +4736,20 @@ __export(cursor_agent_exports, {
   createCursorAgentProvider: () => createCursorAgentProvider,
   cursor_agent: () => cursor_agent
 });
-import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync2 } from "fs";
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync3 } from "fs";
 import { readdir as readdir10, stat as stat12 } from "fs/promises";
-import { join as join18, basename as basename8 } from "path";
+import { join as join19, basename as basename8 } from "path";
 import { homedir as homedir11 } from "os";
 function getCursorAgentBaseDir(baseDirOverride) {
   if (baseDirOverride) return baseDirOverride;
-  return join18(homedir11(), ".cursor");
+  return join19(homedir11(), ".cursor");
 }
 function getProjectsDir(baseDir) {
-  return join18(baseDir, "projects");
+  return join19(baseDir, "projects");
 }
 function getAttributionDbPath(baseDir) {
-  return join18(baseDir, "ai-tracking", "ai-code-tracking.db");
+  return join19(baseDir, "ai-tracking", "ai-code-tracking.db");
 }
 function estimateTokens(charCount) {
   if (charCount <= 0) return 0;
@@ -4625,7 +4800,7 @@ function resolveModel3(raw) {
 function toConversationId(transcriptPath) {
   const filename = basename8(transcriptPath, ".txt");
   if (filename.length === 36 && UUID_LIKE.test(filename)) return filename;
-  return createHash4("sha1").update(transcriptPath).digest("hex").slice(0, 16);
+  return createHash5("sha1").update(transcriptPath).digest("hex").slice(0, 16);
 }
 function extractUserQuery(userBlock) {
   const chunks = [];
@@ -4734,7 +4909,7 @@ function createParser6(source, seenKeys, dbPath, summariesByConversationId) {
       let db = null;
       try {
         if (!summary) {
-          if (existsSync2(dbPath)) {
+          if (existsSync3(dbPath)) {
             try {
               db = openDatabase(dbPath);
               const rows2 = db.query(CONVERSATION_SUMMARY_QUERY, [conversationId]);
@@ -4827,19 +5002,19 @@ function createCursorAgentProvider(baseDirOverride) {
       return rawTool;
     },
     async discoverSessions() {
-      if (!existsSync2(projectsDir)) return [];
+      if (!existsSync3(projectsDir)) return [];
       const projectEntries = await readdir10(projectsDir, { withFileTypes: true });
       const sources = [];
       for (const entry of projectEntries) {
         if (!entry.isDirectory()) continue;
         const projectId = prettifyProjectId(entry.name);
-        const transcriptDir = join18(projectsDir, entry.name, "agent-transcripts");
-        if (!existsSync2(transcriptDir)) continue;
+        const transcriptDir = join19(projectsDir, entry.name, "agent-transcripts");
+        if (!existsSync3(transcriptDir)) continue;
         const transcriptEntries = await readdir10(transcriptDir, { withFileTypes: true });
         for (const transcript of transcriptEntries) {
           if (!transcript.isFile()) continue;
           if (!transcript.name.endsWith(".txt")) continue;
-          const transcriptPath = join18(transcriptDir, transcript.name);
+          const transcriptPath = join19(transcriptDir, transcript.name);
           sources.push({
             path: transcriptPath,
             project: projectId,
@@ -5153,15 +5328,15 @@ var init_classifier = __esm({
 
 // src/session-index.ts
 import { stat as stat13 } from "fs/promises";
-import { existsSync as existsSync3, unlinkSync } from "fs";
+import { existsSync as existsSync4, unlinkSync } from "fs";
 import { readFile as readFile11, mkdir as mkdir10, rename as rename8, unlink as unlink6, open as open7 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { randomBytes as randomBytes5 } from "crypto";
 function emptyIndex() {
   return { v: SESSION_INDEX_VERSION, e: {} };
 }
 function indexPath() {
-  return join19(getCacheDir(), INDEX_FILENAME);
+  return join20(getCacheDir(), INDEX_FILENAME);
 }
 async function loadSessionIndex() {
   if (currentIndex) return currentIndex;
@@ -5181,7 +5356,7 @@ async function loadSessionIndex() {
 }
 async function saveSessionIndex(index) {
   const dir = getCacheDir();
-  if (!existsSync3(dir)) await mkdir10(dir, { recursive: true });
+  if (!existsSync4(dir)) await mkdir10(dir, { recursive: true });
   const finalPath = indexPath();
   const tempPath = `${finalPath}.${randomBytes5(8).toString("hex")}.tmp`;
   const payload = JSON.stringify(index);
@@ -5263,7 +5438,7 @@ __export(parser_exports, {
 });
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import { readdir as readdir11, stat as stat14 } from "fs/promises";
-import { basename as basename9, join as join20 } from "path";
+import { basename as basename9, join as join21 } from "path";
 function getParseWarnings() {
   return _parseWarnings;
 }
@@ -5349,71 +5524,95 @@ function parseApiCall(entry) {
     deduplicationKey: msg.id ?? `claude:${entry.timestamp}`
   };
 }
-async function parseTurns(filePath) {
+function validTurnScan(value) {
+  const x = value;
+  const amount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+  const calls = (list) => Array.isArray(list) && list.every((c) => c && typeof c.deduplicationKey === "string" && typeof c.model === "string" && typeof c.timestamp === "string" && amount(c.costUSD) && c.usage && ["inputTokens", "outputTokens", "cacheCreationInputTokens", "cacheReadInputTokens"].every((key2) => amount(c.usage[key2])) && Array.isArray(c.tools) && Array.isArray(c.bashCommands));
+  return !!x && Array.isArray(x.turns) && x.turns.every((t) => t && calls(t.assistantCalls) && typeof t.userMessage === "string" && typeof t.timestamp === "string" && typeof t.sessionId === "string") && calls(x.currentCalls) && typeof x.currentUserMessage === "string" && Number.isSafeInteger(x.currentUserSignals) && x.currentUserSignals >= 0 && typeof x.currentTimestamp === "string" && typeof x.currentSessionId === "string" && Number.isSafeInteger(x.lineNumber) && x.lineNumber >= 0;
+}
+async function parseTurns(filePath, progress) {
+  const checkpoint = await progress.load(validTurnScan);
+  const saved = checkpoint?.state;
   const seenCalls = /* @__PURE__ */ new Map();
-  const turns = [];
-  let currentUserMessage = "";
-  let currentUserSignals = 0;
-  let currentCalls = [];
-  let currentTimestamp = "";
-  let currentSessionId = "";
-  let lineNumber = 0;
-  for await (const line of readSessionLines(filePath)) {
-    lineNumber++;
-    const entry = parseJsonlLine(line);
-    if (!entry) continue;
-    if (entry.type === "user") {
-      const text = getUserMessageText(entry);
-      if (text.trim()) {
-        if (currentCalls.length > 0) {
-          turns.push({
-            userMessage: currentUserMessage,
-            userMessageSignals: currentUserSignals,
-            assistantCalls: currentCalls,
-            timestamp: currentTimestamp,
-            sessionId: currentSessionId
-          });
+  const turns = saved?.turns ?? [];
+  let currentUserMessage = saved?.currentUserMessage ?? "";
+  let currentUserSignals = saved?.currentUserSignals ?? 0;
+  let currentCalls = saved?.currentCalls ?? [];
+  let currentTimestamp = saved?.currentTimestamp ?? "";
+  let currentSessionId = saved?.currentSessionId ?? "";
+  for (const turn of turns) for (const call of turn.assistantCalls) seenCalls.set(call.deduplicationKey, call);
+  for (const call of currentCalls) seenCalls.set(call.deduplicationKey, call);
+  let lineNumber = saved?.lineNumber ?? 0;
+  let offset = checkpoint?.offset ?? 0;
+  try {
+    for await (const line of readSessionLines(filePath, offset, void 0, (next) => {
+      offset = next;
+    })) {
+      chargeRecord();
+      lineNumber++;
+      const entry = parseJsonlLine(line);
+      if (!entry) continue;
+      if (entry.type === "user") {
+        const text = getUserMessageText(entry);
+        if (text.trim()) {
+          if (currentCalls.length > 0) {
+            turns.push({
+              userMessage: currentUserMessage,
+              userMessageSignals: currentUserSignals,
+              assistantCalls: currentCalls,
+              timestamp: currentTimestamp,
+              sessionId: currentSessionId
+            });
+          }
+          const compact = compactUserMessage(text);
+          currentUserMessage = compact.userMessage;
+          currentUserSignals = compact.userMessageSignals;
+          currentCalls = [];
+          currentTimestamp = entry.timestamp ?? "";
+          currentSessionId = entry.sessionId ?? "";
         }
-        const compact = compactUserMessage(text);
-        currentUserMessage = compact.userMessage;
-        currentUserSignals = compact.userMessageSignals;
-        currentCalls = [];
-        currentTimestamp = entry.timestamp ?? "";
-        currentSessionId = entry.sessionId ?? "";
-      }
-    } else if (entry.type === "assistant") {
-      const msgId = getMessageId(entry);
-      const call = parseApiCall(entry);
-      if (!call) continue;
-      const previous = msgId ? seenCalls.get(msgId) : void 0;
-      if (previous) {
-        for (const key2 of Object.keys(call.usage)) {
-          previous.usage[key2] = Math.max(previous.usage[key2] ?? 0, call.usage[key2] ?? 0);
+      } else if (entry.type === "assistant") {
+        const msgId = getMessageId(entry);
+        const call = parseApiCall(entry);
+        if (!call) continue;
+        const previous = msgId ? seenCalls.get(msgId) : void 0;
+        if (previous) {
+          for (const key2 of Object.keys(call.usage)) {
+            previous.usage[key2] = Math.max(previous.usage[key2] ?? 0, call.usage[key2] ?? 0);
+          }
+          previous.tools = [.../* @__PURE__ */ new Set([...previous.tools, ...call.tools])];
+          previous.mcpTools = extractMcpTools(previous.tools);
+          previous.bashCommands = [.../* @__PURE__ */ new Set([...previous.bashCommands, ...call.bashCommands])];
+          previous.hasAgentSpawn ||= call.hasAgentSpawn;
+          previous.hasPlanMode ||= call.hasPlanMode;
+          if (call.speed === "fast") previous.speed = "fast";
+          previous.costUSD = calculateCost(
+            previous.model,
+            previous.usage.inputTokens,
+            previous.usage.outputTokens,
+            previous.usage.cacheCreationInputTokens,
+            previous.usage.cacheReadInputTokens,
+            previous.usage.webSearchRequests,
+            previous.speed,
+            previous.usage.inputTokens + previous.usage.cacheCreationInputTokens + previous.usage.cacheReadInputTokens,
+            previous.usage.cacheCreation1hInputTokens
+          );
+          continue;
         }
-        previous.tools = [.../* @__PURE__ */ new Set([...previous.tools, ...call.tools])];
-        previous.mcpTools = extractMcpTools(previous.tools);
-        previous.bashCommands = [.../* @__PURE__ */ new Set([...previous.bashCommands, ...call.bashCommands])];
-        previous.hasAgentSpawn ||= call.hasAgentSpawn;
-        previous.hasPlanMode ||= call.hasPlanMode;
-        if (call.speed === "fast") previous.speed = "fast";
-        previous.costUSD = calculateCost(
-          previous.model,
-          previous.usage.inputTokens,
-          previous.usage.outputTokens,
-          previous.usage.cacheCreationInputTokens,
-          previous.usage.cacheReadInputTokens,
-          previous.usage.webSearchRequests,
-          previous.speed,
-          previous.usage.inputTokens + previous.usage.cacheCreationInputTokens + previous.usage.cacheReadInputTokens,
-          previous.usage.cacheCreation1hInputTokens
-        );
-        continue;
+        if (msgId) seenCalls.set(msgId, call);
+        else call.deduplicationKey = `${filePath}:${lineNumber}`;
+        currentCalls.push(call);
+      }
+    }
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) {
+      try {
+        await progress.save({ turns, currentCalls, currentUserMessage, currentUserSignals, currentTimestamp, currentSessionId, lineNumber }, offset);
+      } catch {
+        _parseWarnings.push("A historical transcript checkpoint could not be saved; its unfinished usage remains unknown.");
       }
-      if (msgId) seenCalls.set(msgId, call);
-      else call.deduplicationKey = `${filePath}:${lineNumber}`;
-      chargeRecord();
-      currentCalls.push(call);
     }
+    throw error;
   }
   if (currentCalls.length > 0) {
     turns.push({
@@ -5518,7 +5717,7 @@ async function parseSessionFile(filePath, project, seenMsgIds, dateRange) {
     } catch {
     }
   }
-  const rawTurns = await cachedFileParse(filePath, "claude-turns", () => parseTurns(filePath));
+  const rawTurns = await cachedFileParse(filePath, "claude-turns", (progress) => parseTurns(filePath, progress));
   const sessionId = basename9(filePath, ".jsonl");
   const turns = [];
   for (const turn of rawTurns) {
@@ -5553,13 +5752,13 @@ async function parseSessionFile(filePath, project, seenMsgIds, dateRange) {
 }
 async function collectJsonlFiles2(dirPath) {
   const files = await readdir11(dirPath).catch(() => []);
-  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).map((f) => join20(dirPath, f));
+  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).map((f) => join21(dirPath, f));
   for (const entry of files) {
     if (entry.endsWith(".jsonl")) continue;
-    const subagentsPath = join20(dirPath, entry, "subagents");
+    const subagentsPath = join21(dirPath, entry, "subagents");
     const subFiles = await readdir11(subagentsPath).catch(() => []);
     for (const sf of subFiles) {
-      if (sf.endsWith(".jsonl")) jsonlFiles.push(join20(subagentsPath, sf));
+      if (sf.endsWith(".jsonl")) jsonlFiles.push(join21(subagentsPath, sf));
     }
   }
   return jsonlFiles;
@@ -5925,8 +6124,8 @@ var init_parser = __esm({
 init_cache_dir();
 init_file_lock();
 init_resource_budget();
-import { existsSync as existsSync7, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
+import { join as join31 } from "path";
 import { homedir as homedir17 } from "os";
 import { Command } from "commander";
 
@@ -6657,19 +6856,19 @@ function renderStatusBar(projects) {
 
 // src/menubar-json.ts
 import { readdirSync, readFileSync } from "fs";
-import { join as join21, dirname as dirname5 } from "path";
+import { join as join22, dirname as dirname5 } from "path";
 init_models();
 import { fileURLToPath } from "url";
 function getCliVersion() {
   try {
-    const pkgPath = join21(dirname5(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkgPath = join22(dirname5(fileURLToPath(import.meta.url)), "..", "package.json");
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
-var MIN_APP_VERSION = "0.2.59";
+var MIN_APP_VERSION = "0.2.67";
 var TOP_ACTIVITIES_LIMIT = 20;
 var TOP_MODELS_LIMIT = 20;
 var TOP_FINDINGS_LIMIT = 10;
@@ -6825,18 +7024,18 @@ function buildMenubarPayload(current, providers, optimize, dailyHistory, agentSt
 // src/daily-cache.ts
 init_cache_dir();
 init_models();
-import { createHash as createHash5, randomBytes as randomBytes6 } from "crypto";
-import { existsSync as existsSync4 } from "fs";
+import { createHash as createHash6, randomBytes as randomBytes6 } from "crypto";
+import { existsSync as existsSync5 } from "fs";
 import { mkdir as mkdir11, open as open8, readFile as readFile12, rename as rename9, unlink as unlink7 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var DAILY_CACHE_VERSION = 9;
 var DEFAULT_DAILY_CACHE_SCOPE = "global";
 var DAILY_CACHE_FILENAME = "daily-cache.json";
 function getCachePath3(scopeKey) {
   if (scopeKey === DEFAULT_DAILY_CACHE_SCOPE) {
-    return join22(getCacheDir(), DAILY_CACHE_FILENAME);
+    return join23(getCacheDir(), DAILY_CACHE_FILENAME);
   }
-  return join22(getCacheDir(), `daily-cache-${scopeKey}.json`);
+  return join23(getCacheDir(), `daily-cache-${scopeKey}.json`);
 }
 function emptyCache(scopeKey) {
   return { version: DAILY_CACHE_VERSION, scopeKey, lastComputedDate: null, days: [] };
@@ -6851,7 +7050,7 @@ function buildDailyCacheScopeKey(include, exclude) {
     return DEFAULT_DAILY_CACHE_SCOPE;
   }
   const raw = JSON.stringify({ include: normalizedInclude, exclude: normalizedExclude });
-  return `scope-${createHash5("sha1").update(raw).digest("hex").slice(0, 12)}`;
+  return `scope-${createHash6("sha1").update(raw).digest("hex").slice(0, 12)}`;
 }
 function isValidCache(parsed) {
   if (!parsed || typeof parsed !== "object") return false;
@@ -6859,6 +7058,7 @@ function isValidCache(parsed) {
   if (c.version !== DAILY_CACHE_VERSION && c.version !== 8) return false;
   if (typeof c.scopeKey !== "string" || c.scopeKey.length === 0) return false;
   if (!Array.isArray(c.days)) return false;
+  if (c.historyScanProgress !== void 0 && (!Number.isSafeInteger(c.historyScanProgress) || c.historyScanProgress < 0)) return false;
   if (c.missingProviders && (!Array.isArray(c.missingProviders) || !c.missingProviders.every((p) => typeof p === "string"))) return false;
   if (c.historyBuild) {
     const stage = c.historyBuild;
@@ -6869,20 +7069,20 @@ function isValidCache(parsed) {
 }
 async function loadDailyCache(scopeKey = DEFAULT_DAILY_CACHE_SCOPE) {
   const path = getCachePath3(scopeKey);
-  if (!existsSync4(path)) return emptyCache(scopeKey);
+  if (!existsSync5(path)) return emptyCache(scopeKey);
   try {
     const raw = await readFile12(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCache(parsed)) return emptyCache(scopeKey);
     if (parsed.scopeKey !== scopeKey) return emptyCache(scopeKey);
-    if ((parsed.days.length || parsed.historyBuild) && parsed.pricingFingerprint !== getPricingFingerprint()) {
-      return {
-        ...parsed,
-        version: DAILY_CACHE_VERSION,
-        historyBuild: void 0,
-        needsRepricing: true,
-        previousHistoryStart: parsed.days[0]?.date ?? parsed.historyBuild?.start
-      };
+    if (parsed.needsRepricing) {
+      const repricing = parsed.historyBuild;
+      if (parsed.days.length) {
+        parsed.historyBuild = void 0;
+        parsed.backfill = repricing?.previousBackfill ?? null;
+      }
+      delete parsed.needsRepricing;
+      delete parsed.previousHistoryStart;
     }
     if (parsed.version !== DAILY_CACHE_VERSION) {
       return {
@@ -6899,7 +7099,7 @@ async function loadDailyCache(scopeKey = DEFAULT_DAILY_CACHE_SCOPE) {
 }
 async function saveDailyCache(cache) {
   const dir = getCacheDir();
-  if (!existsSync4(dir)) await mkdir11(dir, { recursive: true });
+  if (!existsSync5(dir)) await mkdir11(dir, { recursive: true });
   const scopeKey = cache.scopeKey || DEFAULT_DAILY_CACHE_SCOPE;
   const finalPath = getCachePath3(scopeKey);
   const tempPath = `${finalPath}.${randomBytes6(8).toString("hex")}.tmp`;
@@ -6937,6 +7137,7 @@ function addNewDays(cache, incoming, newestDate, options = {}) {
     lastComputedDate: nextLast,
     days: merged,
     revalidatedAt: cache.revalidatedAt,
+    historyScanProgress: cache.historyScanProgress,
     backfill: cache.backfill,
     partialDates: cache.partialDates
   };
@@ -6959,16 +7160,16 @@ init_types();
 init_cache_dir();
 init_models();
 import { readFile as readFile13, stat as stat16, mkdir as mkdir12, writeFile as writeFile4, rename as rename10, unlink as unlink8 } from "fs/promises";
-import { createHash as createHash6, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
 import { homedir as homedir12 } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/history-start.ts
 init_discovery_cache();
 init_fs_utils();
 init_parser();
 import { readdir as readdir12, stat as stat15 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function parseHistoryStartDate(value) {
   if (!value || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
   const [year, month, day] = value.split("-").map(Number);
@@ -6988,7 +7189,7 @@ async function resolveHistoryStart(configured, cachedDates, now = /* @__PURE__ *
   for (const source of sources) {
     const sourceStat = await stat15(source.path).catch(() => null);
     if (!sourceStat) continue;
-    const paths = sourceStat.isDirectory() ? (await readdir12(source.path)).filter((name) => name.endsWith(".jsonl")).map((name) => join23(source.path, name)) : source.path.endsWith(".jsonl") ? [source.path] : [];
+    const paths = sourceStat.isDirectory() ? (await readdir12(source.path)).filter((name) => name.endsWith(".jsonl")).map((name) => join24(source.path, name)) : source.path.endsWith(".jsonl") ? [source.path] : [];
     for (const path of paths) {
       const fileStat = await stat15(path).catch(() => null);
       if (!fileStat) continue;
@@ -7007,6 +7208,20 @@ async function resolveHistoryStart(configured, cachedDates, now = /* @__PURE__ *
 }
 
 // src/claude-recovery.ts
+init_recorded_costs();
+function lockClaudeRecovery(recovery) {
+  if (!recovery) return null;
+  const rows2 = recovery.models.map((row) => ({
+    ...row,
+    provider: "claude",
+    deduplicationKey: "claude-stats-recovery",
+    cacheCreationInputTokens: row.cacheWriteTokens,
+    cacheReadInputTokens: row.cacheReadTokens
+  }));
+  lockRecordedCosts(rows2);
+  const models = recovery.models.map((row, index) => ({ ...row, costUSD: rows2[index].costUSD }));
+  return { ...recovery, models, costUSD: models.reduce((sum2, row) => sum2 + row.costUSD, 0) };
+}
 var fields = ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"];
 var emptyTokens = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
 function applyClaudeRecovery(data, recovery) {
@@ -7025,9 +7240,9 @@ function applyClaudeRecovery(data, recovery) {
   }
 }
 async function readClaudeUsageSnapshot() {
-  const root = process.env["CLAUDE_CONFIG_DIR"] || join24(homedir12(), ".claude");
-  const path = join24(root, "stats-cache.json");
-  const savedPath = join24(getCacheDir(), `claude-lifetime-${createHash6("sha256").update(root).digest("hex").slice(0, 16)}.json`);
+  const root = process.env["CLAUDE_CONFIG_DIR"] || join25(homedir12(), ".claude");
+  const path = join25(root, "stats-cache.json");
+  const savedPath = join25(getCacheDir(), `claude-lifetime-${createHash7("sha256").update(root).digest("hex").slice(0, 16)}.json`);
   const read = async (file) => {
     try {
       if ((await stat16(file)).size > 2 * 1024 ** 2) return null;
@@ -7111,7 +7326,7 @@ function recoverClaudeUsage(snapshot, recorded, rangeStart) {
     ...totals,
     costUSD: models.reduce((sum2, row) => sum2 + row.costUSD, 0),
     models,
-    note: "Includes historical Claude token counters missing from retained transcripts, reconciled per model and token type to avoid double-counting. Their dates, calls, projects, request sizes, cache TTL and speed are unavailable; recovered cost uses latest standard API rates, short-context rates and 5-minute cache writes. Time-based discounts cannot be reconstructed. Earlier usage without logs or counters remains unknown."
+    note: "Includes historical Claude token counters missing from retained transcripts, reconciled per model and token type to avoid double-counting. Their dates, calls, projects, request sizes, cache TTL and speed are unavailable; recovered cost uses the standard rates available when counted, short-context rates and 5-minute cache writes. Saved estimates are not revalued on pricing refresh. Time-based discounts cannot be reconstructed. Earlier usage without logs or counters remains unknown."
   };
 }
 async function getClaudeRecoveryForRange(range, signal) {
@@ -7132,7 +7347,7 @@ async function getClaudeRecoveryForRange(range, signal) {
       recorded.set(model, total);
     }
   }
-  return recoverClaudeUsage(snapshot, recorded, range.start);
+  return lockClaudeRecovery(recoverClaudeUsage(snapshot, recorded, range.start));
 }
 
 // src/latest-load.ts
@@ -7195,8 +7410,8 @@ init_resource_budget();
 init_providers();
 import chalk2 from "chalk";
 import { readdir as readdir13, stat as stat17 } from "fs/promises";
-import { existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { basename as basename10, join as join25 } from "path";
+import { existsSync as existsSync6, statSync as statSync2 } from "fs";
+import { basename as basename10, join as join26 } from "path";
 import { homedir as homedir13 } from "os";
 var ORANGE = "#F59E0B";
 var DIM = "#666666";
@@ -7279,13 +7494,13 @@ var DEFAULT_TREND_PERIOD_MS = DEFAULT_TREND_PERIOD_DAYS * 24 * 60 * 60 * 1e3;
 var IMPROVING_THRESHOLD = 0.5;
 async function collectJsonlFiles3(dirPath) {
   const files = await readdir13(dirPath).catch(() => []);
-  const result = files.filter((f) => f.endsWith(".jsonl")).map((f) => join25(dirPath, f));
+  const result = files.filter((f) => f.endsWith(".jsonl")).map((f) => join26(dirPath, f));
   for (const entry of files) {
     if (entry.endsWith(".jsonl")) continue;
-    const subPath = join25(dirPath, entry, "subagents");
+    const subPath = join26(dirPath, entry, "subagents");
     const subFiles = await readdir13(subPath).catch(() => []);
     for (const sf of subFiles) {
-      if (sf.endsWith(".jsonl")) result.push(join25(subPath, sf));
+      if (sf.endsWith(".jsonl")) result.push(join26(subPath, sf));
     }
   }
   return result;
@@ -7475,16 +7690,16 @@ function isReadTool(name) {
 function loadMcpConfigs(projectCwds) {
   const servers = /* @__PURE__ */ new Map();
   const configPaths = [
-    join25(homedir13(), ".claude", "settings.json"),
-    join25(homedir13(), ".claude", "settings.local.json")
+    join26(homedir13(), ".claude", "settings.json"),
+    join26(homedir13(), ".claude", "settings.local.json")
   ];
   for (const cwd of projectCwds) {
-    configPaths.push(join25(cwd, ".mcp.json"));
-    configPaths.push(join25(cwd, ".claude", "settings.json"));
-    configPaths.push(join25(cwd, ".claude", "settings.local.json"));
+    configPaths.push(join26(cwd, ".mcp.json"));
+    configPaths.push(join26(cwd, ".claude", "settings.json"));
+    configPaths.push(join26(cwd, ".claude", "settings.local.json"));
   }
   for (const p of configPaths) {
-    if (!existsSync5(p)) continue;
+    if (!existsSync6(p)) continue;
     const config = readJsonFile(p);
     if (!config) continue;
     let mtime = 0;
@@ -7634,13 +7849,13 @@ function expandImports(filePath, seen, depth) {
   if (content === null) return { totalLines: 0, importedFiles: 0 };
   let totalLines = content.split("\n").length;
   let importedFiles = 0;
-  const dir = join25(filePath, "..");
+  const dir = join26(filePath, "..");
   IMPORT_PATTERN.lastIndex = 0;
   for (const match of content.matchAll(IMPORT_PATTERN)) {
     const rawPath = match[1];
     if (!rawPath) continue;
-    const resolved = rawPath.startsWith("/") ? rawPath : join25(dir, rawPath);
-    if (!existsSync5(resolved)) continue;
+    const resolved = rawPath.startsWith("/") ? rawPath : join26(dir, rawPath);
+    if (!existsSync6(resolved)) continue;
     const nested = expandImports(resolved, seen, depth + 1);
     totalLines += nested.totalLines;
     importedFiles += 1 + nested.importedFiles;
@@ -7651,8 +7866,8 @@ function detectBloatedClaudeMd(projectCwds) {
   const bloated = [];
   for (const cwd of projectCwds) {
     for (const name of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-      const fullPath = join25(cwd, name);
-      if (!existsSync5(fullPath)) continue;
+      const fullPath = join26(cwd, name);
+      if (!existsSync6(fullPath)) continue;
       const { totalLines, importedFiles } = expandImports(fullPath, /* @__PURE__ */ new Set(), 0);
       if (totalLines > CLAUDEMD_HEALTHY_LINES) {
         bloated.push({ path: `${shortHomePath(cwd)}/${name}`, expandedLines: totalLines, imports: importedFiles });
@@ -7780,7 +7995,7 @@ function detectCacheBloat(apiCalls, projects, dateRange) {
   };
 }
 async function listMarkdownFiles(dir) {
-  if (!existsSync5(dir)) return [];
+  if (!existsSync6(dir)) return [];
   try {
     const entries = await readdir13(dir);
     return entries.filter((e) => e.endsWith(".md")).map((e) => e.replace(/\.md$/, ""));
@@ -7789,12 +8004,12 @@ async function listMarkdownFiles(dir) {
   }
 }
 async function listSkillDirs(dir) {
-  if (!existsSync5(dir)) return [];
+  if (!existsSync6(dir)) return [];
   try {
     const entries = await readdir13(dir);
     const names = [];
     for (const entry of entries) {
-      if (existsSync5(join25(dir, entry, "SKILL.md"))) names.push(entry);
+      if (existsSync6(join26(dir, entry, "SKILL.md"))) names.push(entry);
     }
     return names;
   } catch {
@@ -7802,7 +8017,7 @@ async function listSkillDirs(dir) {
   }
 }
 async function detectGhostAgents(calls) {
-  const defined = await listMarkdownFiles(join25(homedir13(), ".claude", "agents"));
+  const defined = await listMarkdownFiles(join26(homedir13(), ".claude", "agents"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const call of calls) {
@@ -7827,7 +8042,7 @@ async function detectGhostAgents(calls) {
   };
 }
 async function detectGhostSkills(calls) {
-  const defined = await listSkillDirs(join25(homedir13(), ".claude", "skills"));
+  const defined = await listSkillDirs(join26(homedir13(), ".claude", "skills"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const call of calls) {
@@ -7852,7 +8067,7 @@ async function detectGhostSkills(calls) {
   };
 }
 async function detectGhostCommands(userMessages) {
-  const defined = await listMarkdownFiles(join25(homedir13(), ".claude", "commands"));
+  const defined = await listMarkdownFiles(join26(homedir13(), ".claude", "commands"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const msg of userMessages) {
@@ -7880,8 +8095,8 @@ async function detectGhostCommands(userMessages) {
 }
 function readShellProfileLimit() {
   for (const profile of SHELL_PROFILES) {
-    const path = join25(homedir13(), profile);
-    if (!existsSync5(path)) continue;
+    const path = join26(homedir13(), profile);
+    if (!existsSync6(path)) continue;
     const content = readSessionFileSync(path);
     if (content === null) continue;
     const match = content.match(/^\s*export\s+BASH_MAX_OUTPUT_LENGTH\s*=\s*['"]?(\d+)['"]?/m);
@@ -8104,7 +8319,7 @@ import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 import { stat as stat18, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { join as join26, resolve as resolve3 } from "path";
+import { join as join27, resolve as resolve3 } from "path";
 function codeBlock(content, language) {
   const longest = (content.match(/`+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);
   const fence = "`".repeat(Math.max(3, longest + 1));
@@ -8198,7 +8413,7 @@ async function copyOptimizeMarkdown(markdown) {
   throw new Error("Could not copy. Press e to save a Markdown file instead.");
 }
 async function saveOptimizeMarkdown(markdown, directory) {
-  const downloads = join26(homedir14(), "Downloads");
+  const downloads = join27(homedir14(), "Downloads");
   const folder = directory ?? ((await stat18(downloads).catch(() => null))?.isDirectory() ? downloads : process.cwd());
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const path = resolve3(folder, `exe-watcher-optimizer-${stamp}-${randomUUID4().slice(0, 8)}.md`);
@@ -8209,8 +8424,8 @@ async function saveOptimizeMarkdown(markdown, directory) {
 // src/context-budget.ts
 init_fs_utils();
 import { readdir as readdir14 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join28 } from "path";
 import { homedir as homedir15 } from "os";
 var CHARS_PER_TOKEN2 = 4;
 var SYSTEM_BASE_TOKENS = 10400;
@@ -8220,7 +8435,7 @@ function estimateTokens2(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN2);
 }
 async function readConfigFile(path) {
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   const raw = await readSessionFile(path);
   if (raw === null) return null;
   try {
@@ -8232,13 +8447,13 @@ async function readConfigFile(path) {
 async function countMcpTools(projectPath) {
   const home = homedir15();
   const configPaths = [
-    join27(home, ".claude", "settings.json"),
-    join27(home, ".claude", "settings.local.json")
+    join28(home, ".claude", "settings.json"),
+    join28(home, ".claude", "settings.local.json")
   ];
   if (projectPath) {
-    configPaths.push(join27(projectPath, ".mcp.json"));
-    configPaths.push(join27(projectPath, ".claude", "settings.json"));
-    configPaths.push(join27(projectPath, ".claude", "settings.local.json"));
+    configPaths.push(join28(projectPath, ".mcp.json"));
+    configPaths.push(join28(projectPath, ".claude", "settings.json"));
+    configPaths.push(join28(projectPath, ".claude", "settings.local.json"));
   }
   const servers = /* @__PURE__ */ new Set();
   let toolCount = 0;
@@ -8255,16 +8470,16 @@ async function countMcpTools(projectPath) {
   return toolCount;
 }
 async function countSkills(projectPath) {
-  const dirs = [join27(homedir15(), ".claude", "skills")];
-  if (projectPath) dirs.push(join27(projectPath, ".claude", "skills"));
+  const dirs = [join28(homedir15(), ".claude", "skills")];
+  if (projectPath) dirs.push(join28(projectPath, ".claude", "skills"));
   let count = 0;
   for (const dir of dirs) {
-    if (!existsSync6(dir)) continue;
+    if (!existsSync7(dir)) continue;
     try {
       const entries = await readdir14(dir);
       for (const entry of entries) {
-        const skillFile = join27(dir, entry, "SKILL.md");
-        if (existsSync6(skillFile)) count++;
+        const skillFile = join28(dir, entry, "SKILL.md");
+        if (existsSync7(skillFile)) count++;
       }
     } catch {
       continue;
@@ -8276,15 +8491,15 @@ async function scanMemoryFiles(projectPath) {
   const home = homedir15();
   const files = [];
   const paths = [
-    { path: join27(home, ".claude", "CLAUDE.md"), name: "~/.claude/CLAUDE.md" }
+    { path: join28(home, ".claude", "CLAUDE.md"), name: "~/.claude/CLAUDE.md" }
   ];
   if (projectPath) {
-    paths.push({ path: join27(projectPath, "CLAUDE.md"), name: "CLAUDE.md" });
-    paths.push({ path: join27(projectPath, ".claude", "CLAUDE.md"), name: ".claude/CLAUDE.md" });
-    paths.push({ path: join27(projectPath, "CLAUDE.local.md"), name: "CLAUDE.local.md" });
+    paths.push({ path: join28(projectPath, "CLAUDE.md"), name: "CLAUDE.md" });
+    paths.push({ path: join28(projectPath, ".claude", "CLAUDE.md"), name: ".claude/CLAUDE.md" });
+    paths.push({ path: join28(projectPath, "CLAUDE.local.md"), name: "CLAUDE.local.md" });
   }
   for (const { path, name } of paths) {
-    if (!existsSync6(path)) continue;
+    if (!existsSync7(path)) continue;
     const content = await readSessionFile(path);
     if (content === null) continue;
     files.push({ name, tokens: estimateTokens2(content) });
@@ -8318,7 +8533,7 @@ async function discoverProjectCwd(sessionDir) {
   if (files.length === 0) return null;
   const firstFile = files[0];
   if (!firstFile) return null;
-  const content = await readSessionFile(join27(sessionDir, firstFile));
+  const content = await readSessionFile(join28(sessionDir, firstFile));
   if (content === null) return null;
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -9012,20 +9227,20 @@ function owlFrame(tick) {
 }
 
 // src/dashboard.tsx
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // src/time-index.ts
 init_cache_dir();
 init_file_lock();
 init_resource_budget();
-import { createHash as createHash8, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash9, randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir13, open as open9, readFile as readFile14, rename as rename11, stat as stat19, unlink as unlink9, readdir as readdir15 } from "fs/promises";
-import { basename as basename11, dirname as dirname6, join as join28 } from "path";
+import { basename as basename11, dirname as dirname6, join as join29 } from "path";
 import { gzip as gzip2, gunzip as gunzip2 } from "zlib";
 import { promisify as promisify2 } from "util";
 
 // src/time-tracking.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 var TIME_HISTORY_START = (/* @__PURE__ */ new Date("2025-07-01T00:00:00")).getTime();
 var TIME_PROVIDERS = ["claude", "codex", "cursor", "cursor-agent", "copilot", "opencode", "kimi", "pi", "omp"];
 function timestamp(value) {
@@ -9238,7 +9453,7 @@ function summarizeTime(index, range, provider = "all", include, exclude) {
     runnableFiles: pending.length - waitingFiles,
     waitingFiles,
     pendingBytes: pending.reduce((n, f) => n + Math.max(0, f.size - f.offset), 0),
-    token: createHash7("sha256").update(files.map((f) => `${f.identity}:${f.size}:${f.mtime}:${f.offset}:${f.dbOffset ?? 0}:${!!f.waitingForAppend}:${!!f.unavailable}`).join("|")).digest("hex")
+    token: createHash8("sha256").update(files.map((f) => `${f.identity}:${f.size}:${f.mtime}:${f.offset}:${f.dbOffset ?? 0}:${!!f.waitingForAppend}:${!!f.unavailable}`).join("|")).digest("hex")
   };
   return {
     indexedAt: index.updatedAt,
@@ -9371,7 +9586,7 @@ var MAX_DISK2 = 16 * 1024 ** 2;
 var MAX_FILES = 2e4;
 var BLOCK = 2 * 1024 ** 2;
 var adapterVersion = (provider) => provider === "opencode" ? 2 : 1;
-var indexPath2 = () => join28(getCacheDir(), "time-index-v1.json.gz");
+var indexPath2 = () => join29(getCacheDir(), "time-index-v1.json.gz");
 var empty = () => ({ version: 1, files: /* @__PURE__ */ Object.create(null), updatedAt: (/* @__PURE__ */ new Date()).toISOString(), warnings: [] });
 async function readTimeIndex() {
   try {
@@ -9434,11 +9649,11 @@ async function expandSources(sources, warnings) {
       continue;
     }
     for (const entry of await readdir15(source.path, { withFileTypes: true }).catch(() => [])) {
-      if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push({ ...source, path: join28(source.path, entry.name) });
+      if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push({ ...source, path: join29(source.path, entry.name) });
       else if (entry.isDirectory()) {
-        const folder = join28(source.path, entry.name, "subagents");
+        const folder = join29(source.path, entry.name, "subagents");
         for (const agent of await readdir15(folder, { withFileTypes: true }).catch(() => [])) {
-          if (agent.isFile() && agent.name.endsWith(".jsonl")) out.push({ ...source, path: join28(folder, agent.name) });
+          if (agent.isFile() && agent.name.endsWith(".jsonl")) out.push({ ...source, path: join29(folder, agent.name) });
         }
       }
     }
@@ -9452,7 +9667,7 @@ async function anchor(path, offset) {
     await handle.read(head, 0, head.length, 0);
     await handle.read(tail, 0, tail.length, Math.max(0, offset - tail.length));
     chargeRead(head.length + tail.length);
-    return createHash8("sha256").update(head).update(tail).digest("hex");
+    return createHash9("sha256").update(head).update(tail).digest("hex");
   } finally {
     await handle.close();
   }
@@ -9535,7 +9750,7 @@ async function refreshTimeIndex(options = {}) {
   let current;
   let release;
   try {
-    release = await acquireFileLock(join28(getCacheDir(), "time-index.lock"), 100);
+    release = await acquireFileLock(join29(getCacheDir(), "time-index.lock"), 100);
   } catch {
     current = await readTimeIndex();
     current.warnings.push("Another timing update is running; showing the saved timing snapshot.");
@@ -9555,17 +9770,17 @@ async function refreshTimeIndex(options = {}) {
       let fileCount = Object.keys(current.files).length;
       for (const source of expanded) {
         chargeRead(0);
-        const database = source.provider === "opencode" ? source.path.slice(0, source.path.lastIndexOf(":")) : source.path;
-        const s = await stat19(database).catch(() => null);
+        const database2 = source.provider === "opencode" ? source.path.slice(0, source.path.lastIndexOf(":")) : source.path;
+        const s = await stat19(database2).catch(() => null);
         if (!s) continue;
-        const wal = ["cursor", "opencode"].includes(source.provider) ? await stat19(database + "-wal").catch(() => null) : null;
+        const wal = ["cursor", "opencode"].includes(source.provider) ? await stat19(database2 + "-wal").catch(() => null) : null;
         candidates.push({ source, s, wal });
       }
       candidates.sort((a, b) => b.s.mtimeMs - a.s.mtimeMs || a.source.path.localeCompare(b.source.path));
       if (candidates.length > MAX_FILES) current.warnings.push("Some timing sources exceed the bounded file limit; their time remains unknown.");
       const deadline = Date.now() + (options.history ? 15e3 : 750);
       for (const { source, s, wal } of candidates) {
-        const key2 = createHash8("sha256").update(`${source.provider}:${source.path}`).digest("hex");
+        const key2 = createHash9("sha256").update(`${source.provider}:${source.path}`).digest("hex");
         if (!current.files[key2] && fileCount < MAX_FILES) {
           current.files[key2] = fresh(source, `${s.dev}:${s.ino}:${wal?.size ?? 0}:${wal?.mtimeMs ?? 0}`, s.size, s.mtimeMs, s.ctimeMs);
           changed = true;
@@ -9577,7 +9792,7 @@ async function refreshTimeIndex(options = {}) {
       }
       for (const { source, s, wal } of candidates) {
         chargeRead(0);
-        const key2 = createHash8("sha256").update(`${source.provider}:${source.path}`).digest("hex");
+        const key2 = createHash9("sha256").update(`${source.provider}:${source.path}`).digest("hex");
         const identity = `${s.dev}:${s.ino}:${wal?.size ?? 0}:${wal?.mtimeMs ?? 0}`;
         let row = current.files[key2];
         const sameAdapter = (row?.adapterVersion ?? 1) === adapterVersion(source.provider);
@@ -10482,11 +10697,11 @@ function InteractiveDashboard({ initialPeriod, initialProvider, refreshSeconds,
   useEffect2(() => {
     let cancelled = false;
     async function loadBudgets() {
-      const claudeDir = join29(homedir16(), ".claude", "projects");
+      const claudeDir = join30(homedir16(), ".claude", "projects");
       const budgets = /* @__PURE__ */ new Map();
       for (const project of projects.slice(0, 8)) {
         if (cancelled) return;
-        const cwd = await discoverProjectCwd(join29(claudeDir, project.project));
+        const cwd = await discoverProjectCwd(join30(claudeDir, project.project));
         if (!cwd) continue;
         budgets.set(project.project, await estimateContextBudget(cwd));
       }
@@ -10809,6 +11024,10 @@ function shouldSkipBlockedChunk(cursor2, date2, maxAttempts = MAX_BLOCKED_CHUNK_
 // src/period-snapshots.ts
 init_day_aggregator();
 init_models();
+import { createHash as createHash10 } from "crypto";
+function hasRecordedHistory(cache, today) {
+  return cache.days.some((day) => day.date < today && (day.cost > 0 || day.calls > 0 || day.inputTokens > 0 || day.outputTokens > 0));
+}
 function assertHistoryComplete(cache, start, today) {
   if (start >= today) return;
   const required = Math.round((Date.parse(today) - Date.parse(start)) / 864e5);
@@ -10830,7 +11049,27 @@ function buildPeriodSnapshots(cache, todayDays, today, windows, provider, names,
   for (const window of windows) {
     const required = Math.max(0, Math.round((Date.parse(today) - Date.parse(window.start)) / 864e5));
     const covered = [...dates].filter((d) => d >= window.start && !partial.has(d)).length;
-    if (window.key !== "today" && (cache.needsRepricing || cache.historyBuild || cache.missingProviders?.length || covered !== required)) continue;
+    const incomplete = window.key !== "today" && (cache.needsRepricing || cache.historyBuild || cache.missingProviders?.length || covered !== required);
+    const committed = closed.filter((day) => day.date >= window.start).sort((a, b) => a.date.localeCompare(b.date));
+    const recorded = (day) => day.cost > 0 || day.calls > 0 || day.inputTokens > 0 || day.outputTokens > 0;
+    const hasData = committed.some(recorded) || window.key !== "all" && live2.some(recorded);
+    const savedHistory = incomplete && (window.key !== "all" || hasData) ? {
+      through: committed.at(-1)?.date ?? today,
+      hasData,
+      progressToken: createHash10("sha256").update(JSON.stringify([
+        window.start,
+        cache.lastComputedDate,
+        cache.days.length,
+        cache.historyBuild?.completedProviders,
+        cache.historyBuild?.chunked,
+        cache.missingProviders,
+        cache.partialDates,
+        cache.backfill,
+        cache.historyScanProgress
+      ])).digest("hex"),
+      message: window.key === "all" ? `Saved history through ${committed.at(-1).date}${live2.length ? ", plus today" : ""}. Some history is still missing; this is not the complete All total.` : `${hasData ? "Showing known usage" : "Recovering local usage"} for ${window.label}. ${covered} of ${required} historical days loaded${live2.some(recorded) ? ", plus today" : ""}. Missing days are unknown; this total is incomplete.`
+    } : void 0;
+    if (incomplete && !savedHistory) continue;
     const selected = periodDays(window.start);
     const scoped = provider === "all" ? selected : filterDaysToProvider(selected, provider);
     const data = buildPeriodDataFromDays(scoped, window.label);
@@ -10852,6 +11091,7 @@ function buildPeriodSnapshots(cache, todayDays, today, windows, provider, names,
     const providers = provider === "all" ? Object.entries(totals).map(([name, cost]) => ({ name: names.get(name) ?? name, cost })) : [{ name: names.get(provider) ?? provider, cost: data.cost }];
     const built = buildMenubarPayload(data, providers, null);
     result[window.key] = {
+      ...savedHistory ? { savedHistory } : {},
       current: built.current,
       projectSpend: buildProjectSpendFromDays(selected, live2, periodDays(week.start), periodDays(month.start)),
       diagnostics: { daysCount: selected.length, parseTimeMs, warnings: notes },
@@ -10862,6 +11102,23 @@ function buildPeriodSnapshots(cache, todayDays, today, windows, provider, names,
   return result;
 }
 
+// src/saved-history.ts
+init_day_aggregator();
+function buildSavedHistory(cache, today, provider, window = { start: "0000-01-01", label: "All Time" }) {
+  if (!hasRecordedHistory(cache, today)) throw new Error("No saved history yet. Watcher is recovering local usage.");
+  const closed = cache.days.filter((day) => day.date >= window.start && day.date < today).sort((a, b) => a.date.localeCompare(b.date));
+  if (!closed.some((day) => day.cost > 0 || day.calls > 0 || day.inputTokens > 0 || day.outputTokens > 0)) throw new Error("No saved usage in this period yet. Watcher is recovering local usage.");
+  const days = provider === "all" ? closed : filterDaysToProvider(closed, provider);
+  const current = buildPeriodDataFromDays(days, window.label);
+  const totals = /* @__PURE__ */ new Map();
+  for (const day of days) for (const [name, data] of Object.entries(day.providers)) totals.set(name, (totals.get(name) ?? 0) + data.cost);
+  const payload = buildMenubarPayload(current, [...totals].map(([name, cost]) => ({ name, cost })), null);
+  return { ...payload, savedHistory: {
+    through: closed.at(-1).date,
+    message: `Saved ${window.label} history through ${closed.at(-1).date}. Newer usage has not loaded yet.`
+  } };
+}
+
 // src/history-build.ts
 init_day_aggregator();
 init_report_summary();
@@ -10960,8 +11217,9 @@ async function completeHistoryBuild(cache, start, end, providers, scan, save2, o
 }
 
 // src/cli.ts
+init_parsed_file_cache();
 import { createInterface } from "readline";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 
 // src/menubar-lifecycle.ts
 var live = { parent: () => process.ppid, checkAlive: (pid) => {
@@ -10995,8 +11253,8 @@ function buildTimeSnapshots(index, ranges, provider = "all", include, exclude) {
 }
 
 // src/cli.ts
-var require2 = createRequire2(import.meta.url);
-var { version } = require2("../package.json");
+var require3 = createRequire3(import.meta.url);
+var { version } = require3("../package.json");
 var MS_PER_DAY4 = 24 * 60 * 60 * 1e3;
 var configuredHistoryStart = null;
 function toDateString(date2) {
@@ -11111,14 +11369,14 @@ async function runJsonReport(period, provider, project, exclude) {
   console.log(JSON.stringify({ ...report, pricing: getPricingMetadata() }, null, 2));
 }
 var program = new Command().name("exe-watcher").description("See where your AI coding tokens go - by task, tool, model, and project").version(version).option("--verbose", "print warnings to stderr on read failures and skipped files");
-program.hook("preAction", async (thisCommand) => {
+program.hook("preAction", async (thisCommand, command) => {
   const config = await readConfig();
   setModelAliases(config.modelAliases ?? {});
   configuredHistoryStart = parseHistoryStartDate(config.historyStartDate);
   if (thisCommand.opts().verbose) {
     process.env["EXE_WATCHER_VERBOSE"] = "1";
   }
-  await loadCurrency();
+  if (!command.opts().cachedOnly) await loadCurrency();
 });
 function buildJsonReport(projects, period, periodKey) {
   const sessions = projects.flatMap((p) => p.sessions);
@@ -11308,7 +11566,19 @@ function buildPeriodData(label, projects) {
     models: Object.entries(modelTotals).sort(([, a], [, b]) => b.cost - a.cost).map(([name, d]) => ({ name, ...d }))
   };
 }
-program.command("status").description("Compact status output (today + week + month)").option("--format <format>", "Output format: terminal, menubar-json, json", "terminal").option("--provider <provider>", "Filter by provider: all, claude, codex, cursor, cursor-agent, copilot, opencode, kimi, pi, omp", "all").option("--project <name>", "Show only projects matching name (repeatable)", collect, []).option("--exclude <name>", "Exclude projects matching name (repeatable)", collect, []).option("--period <period>", "Primary period for menubar-json: today, week, 30days, month, all", "today").option("--no-optimize", "Skip optimize findings (menubar-json only, faster)").action(async (opts) => {
+program.command("status").description("Compact status output (today + week + month)").option("--format <format>", "Output format: terminal, menubar-json, json", "terminal").option("--provider <provider>", "Filter by provider: all, claude, codex, cursor, cursor-agent, copilot, opencode, kimi, pi, omp", "all").option("--project <name>", "Show only projects matching name (repeatable)", collect, []).option("--exclude <name>", "Exclude projects matching name (repeatable)", collect, []).option("--period <period>", "Primary period for menubar-json: today, week, 30days, month, all", "today").option("--no-optimize", "Skip optimize findings (menubar-json only, faster)").option("--cached-only", "Read saved period totals without scanning or networking (menubar-json only)").action(async (opts) => {
+  if (opts.cachedOnly) {
+    if (opts.format !== "menubar-json" || !["week", "30days", "month", "all"].includes(opts.period) || opts.optimize !== false) throw new Error("--cached-only requires menubar-json, a historical period and --no-optimize");
+    const cache = await loadDailyCache(buildDailyCacheScopeKey(opts.project, opts.exclude));
+    const window = getDateRange2(opts.period);
+    console.log(JSON.stringify(buildSavedHistory(
+      cache,
+      toDateString(/* @__PURE__ */ new Date()),
+      opts.provider,
+      { start: opts.period === "all" ? "0000-01-01" : toDateString(window.range.start), label: window.label }
+    )));
+    return;
+  }
   await loadPricing();
   const pf = opts.provider;
   const fp = (p) => filterProjectsByName(p, opts.project, opts.exclude);
@@ -11327,20 +11597,31 @@ program.command("status").description("Compact status output (today + week + mon
     const isAllProviders = pf === "all";
     const dailyCacheScope = buildDailyCacheScopeKey(opts.project, opts.exclude);
     const backfillWarnings = [];
-    const runChunkedBackfill = async (cache2, start, end, order) => {
+    let savedParserProgress = parsedFileProgress();
+    const saveHistoryCache = async (c) => {
+      const progress = parsedFileProgress();
+      const advanced = progress > savedParserProgress;
+      c.historyScanProgress = (c.historyScanProgress ?? 0) + progress - savedParserProgress;
+      savedParserProgress = progress;
+      if (c.backfill) {
+        c.backfill.attempts = advanced ? 0 : Math.min(c.backfill.attempts, MAX_BLOCKED_CHUNK_ATTEMPTS);
+      }
+      await saveDailyCache(c);
+    };
+    const runChunkedBackfill = async (cache2, start, end, order, repair = false) => {
       let c = cache2;
       const chunks = planBackfillChunks(start, end);
       if (order === "newest-first") chunks.reverse();
       for (const chunk of chunks) {
         const chunkDate = toDateString(chunk.start);
         const coveredThrough = toDateString(chunk.end);
-        if (shouldSkipBlockedChunk(c.backfill, chunkDate)) {
+        if (!repair && shouldSkipBlockedChunk(c.backfill, chunkDate)) {
           const blanks = fillMissingDays(chunk.start, chunk.end, []);
           c = addNewDays(c, blanks, yesterdayStr, { coveredThrough });
           c.partialDates = [.../* @__PURE__ */ new Set([...c.partialDates ?? [], ...blanks.map((d) => d.date)])];
           c.backfill = null;
           c.revalidatedAt = Date.now();
-          await saveDailyCache(c);
+          await saveHistoryCache(c);
           const warn2 = `history for ${chunkDate} exceeded the scan budget ${MAX_BLOCKED_CHUNK_ATTEMPTS} times; recorded as incomplete so newer days can load`;
           backfillWarnings.push(warn2);
           process.stderr.write(`[exe-watcher] WARNING: ${warn2}
@@ -11352,14 +11633,15 @@ program.command("status").description("Compact status output (today + week + mon
           const chunkProjects = filterProjectsByName(await parseAllSessions(chunkRange, "all", true), opts.project, opts.exclude);
           const chunkDays = fillMissingDays(chunk.start, chunk.end, aggregateProjectsIntoDays(chunkProjects));
           c = addNewDays(c, chunkDays, yesterdayStr, { coveredThrough });
+          c.partialDates = (c.partialDates ?? []).filter((date2) => date2 < chunkDate || date2 > coveredThrough);
           c.backfill = null;
           c.revalidatedAt = Date.now();
-          await saveDailyCache(c);
+          await saveHistoryCache(c);
         } catch (err) {
           if (!(err instanceof ResourceBudgetError)) throw err;
           c.backfill = nextBackfillCursor(c.backfill, chunkDate);
           c.revalidatedAt = Date.now();
-          await saveDailyCache(c);
+          await saveHistoryCache(c);
           const warn2 = `history backfill paused at ${chunkDate} (attempt ${c.backfill.attempts}): ${err.message}`;
           backfillWarnings.push(warn2);
           process.stderr.write(`[exe-watcher] WARNING: ${warn2}
@@ -11380,7 +11662,7 @@ program.command("status").description("Compact status output (today + week + mon
         opts.project,
         opts.exclude
       )),
-      saveDailyCache,
+      saveHistoryCache,
       { mergeExisting }
     );
     const pausedHistory = (c) => {
@@ -11388,8 +11670,9 @@ program.command("status").description("Compact status output (today + week + mon
       backfillWarnings.push(`History rebuild paused at ${c.historyBuild.chunked?.nextDate ?? c.historyBuild.start}; completed scans are saved and will resume on the next historical refresh.`);
       return true;
     };
-    const cache = await withDailyCacheLock(async () => {
+    const cache = await withScanBudget(() => withScanSlice(() => withDailyCacheLock(async () => {
       let c = await loadDailyCache(dailyCacheScope);
+      const repairDates = [...new Set(c.partialDates ?? [])].sort();
       if (opts.period === "today" && opts.optimize === false) return c;
       if (c.missingProviders?.length && c.days.length && !c.needsRepricing) {
         const from = parseHistoryStartDate(c.days[0].date);
@@ -11405,19 +11688,13 @@ program.command("status").description("Compact status output (today + week + mon
         c = await buildHistory2(c, from, through);
         if (pausedHistory(c)) return c;
       }
-      if (c.needsRepricing || opts.period === "all" && c.days.length === 0) {
+      if (opts.period === "all" && c.days.length === 0) {
         const start = parseHistoryStartDate(c.previousHistoryStart) ?? historyStart;
         if (start <= yesterdayEnd) {
           c = await buildHistory2(c, start, yesterdayEnd);
           if (pausedHistory(c)) return c;
         }
       }
-      const hadYesterday = c.days.some((d) => d.date >= yesterdayStr);
-      if (hadYesterday && (!c.revalidatedAt || Date.now() - c.revalidatedAt >= 5 * 6e4)) {
-        const freshDays = c.days.filter((d) => d.date < yesterdayStr);
-        const latestFresh = freshDays.length > 0 ? freshDays[freshDays.length - 1]?.date ?? null : null;
-        c = { ...c, days: freshDays, lastComputedDate: latestFresh };
-      }
       const oldestCachedDate = c.days.length > 0 ? c.days[0]?.date ?? null : null;
       const effectiveGapStart = computeProgressiveBackfillStart({
         lastComputedDate: c.lastComputedDate,
@@ -11441,9 +11718,22 @@ program.command("status").description("Compact status output (today + week + mon
           c = await runChunkedBackfill(c, clampedNeeded, backEnd, "newest-first");
         }
       }
+      if (!c.backfill || repairDates.includes(c.backfill.blockedDate)) {
+        const selectedStart = toDateString(periodInfo.range.start);
+        for (const date2 of repairDates) {
+          if (date2 < selectedStart || date2 > yesterdayStr || !c.partialDates?.includes(date2)) continue;
+          const start = parseHistoryStartDate(date2);
+          const end = new Date(start);
+          end.setHours(23, 59, 59, 999);
+          c = await runChunkedBackfill(c, start, end, "oldest-first", true);
+          if (c.backfill) break;
+        }
+      }
       return c;
-    });
-    assertHistoryComplete(cache, toDateString(periodInfo.range.start), toDateString(todayStart));
+    }), { maxMs: 1e4, maxBytes: 8 * 1024 ** 3, maxRecords: 2e6 }), 2e6, void 0, 8 * 1024 ** 3);
+    if (opts.optimize !== false || opts.period === "all" && !hasRecordedHistory(cache, toDateString(todayStart))) {
+      assertHistoryComplete(cache, toDateString(periodInfo.range.start), toDateString(todayStart));
+    }
     let currentData;
     const scanRange = periodInfo.range;
     const todayRange = { start: todayStart, end: periodInfo.range.end };
@@ -11517,7 +11807,7 @@ program.command("status").description("Compact status output (today + week + mon
     let historicalRecovery = null;
     if ((opts.period === "all" || opts.optimize === false) && (isAllProviders || pf === "claude") && !opts.project.length && !opts.exclude.length && !cache.partialDates?.length && !cache.backfill) {
       const snapshot = await readClaudeUsageSnapshot();
-      historicalRecovery = recoverClaudeUsage(snapshot, sumClaudeModelTokens([...cache.days, ...todayDays], snapshot?.lastComputedDate ?? ""), historyStart);
+      historicalRecovery = lockClaudeRecovery(recoverClaudeUsage(snapshot, sumClaudeModelTokens([...cache.days, ...todayDays], snapshot?.lastComputedDate ?? ""), historyStart));
       if (historicalRecovery && opts.period === "all") {
         applyClaudeRecovery(currentData, historicalRecovery);
         const claudeProvider = providers.find((p) => p.name.toLowerCase() === "claude");
@@ -11585,13 +11875,13 @@ program.command("status").description("Compact status output (today + week + mon
 `);
       }
     }
-    const exeOsDir = join30(homedir17(), ".exe-os");
-    const exeOsDetected = existsSync7(exeOsDir);
+    const exeOsDir = join31(homedir17(), ".exe-os");
+    const exeOsDetected = existsSync8(exeOsDir);
     let agentStats = null;
     let statsFileAge = null;
     try {
-      const statsPath = join30(exeOsDir, "agent-stats.json");
-      if (existsSync7(statsPath)) {
+      const statsPath = join31(exeOsDir, "agent-stats.json");
+      if (existsSync8(statsPath)) {
         statsFileAge = Math.round((Date.now() - statSync3(statsPath).mtimeMs) / 1e3);
         const parsed = JSON.parse(readFileSync2(statsPath, "utf-8"));
         if (parsed && Array.isArray(parsed.agents) && typeof parsed.generated === "string") {
@@ -11654,7 +11944,15 @@ program.command("status").description("Compact status output (today + week + mon
     if (periodSnapshots) for (const [key2, snapshot] of Object.entries(periodSnapshots)) {
       snapshot.time = summarizeTime(timeIndex, getDateRange2(key2, now).range, pf, opts.project, opts.exclude);
     }
-    const json = JSON.stringify({ ...payload, time, periodSnapshots, costBasis: "api-equivalent", pricing: getPricingMetadata(), historicalRecovery: opts.period === "all" ? historicalRecovery : null });
+    const json = JSON.stringify({
+      ...payload,
+      time,
+      periodSnapshots,
+      ...periodSnapshots?.[opts.period]?.savedHistory ? { savedHistory: periodSnapshots[opts.period].savedHistory } : {},
+      costBasis: "api-equivalent",
+      pricing: getPricingMetadata(),
+      historicalRecovery: opts.period === "all" ? historicalRecovery : null
+    });
     console.log(json);
     return;
   }
@@ -11984,12 +12282,12 @@ program.command("compare").description("Compare two AI models side-by-side").opt
   await renderCompare(range, opts.provider);
 });
 program.command("agent-status").description("Diagnose exe-os agent data pipeline").action(() => {
-  const exeOsDir = join30(homedir17(), ".exe-os");
-  const statsPath = join30(exeOsDir, "agent-stats.json");
-  const pidPath = join30(exeOsDir, "exed.pid");
-  const dirExists = existsSync7(exeOsDir);
-  const statsExists = dirExists && existsSync7(statsPath);
-  const pidExists = dirExists && existsSync7(pidPath);
+  const exeOsDir = join31(homedir17(), ".exe-os");
+  const statsPath = join31(exeOsDir, "agent-stats.json");
+  const pidPath = join31(exeOsDir, "exed.pid");
+  const dirExists = existsSync8(exeOsDir);
+  const statsExists = dirExists && existsSync8(statsPath);
+  const pidExists = dirExists && existsSync8(pidPath);
   const lines = [];
   lines.push(`exe-os directory:  ${dirExists ? "\u2713 found" : "\u2717 not found"} (${exeOsDir})`);
   lines.push(`daemon pid file:   ${pidExists ? "\u2713 found" : "\u2717 not found"}`);
@@ -12021,7 +12319,7 @@ program.command("agent-status").description("Diagnose exe-os agent data pipeline
 var releaseScan;
 var stopParentWatch = watchMenubarParent(Number(process.env["EXE_WATCHER_PARENT_PID"]));
 program.hook("preAction", async (_root, command) => {
-  if (command.name() === "status") releaseScan = await acquireFileLock(join30(getCacheDir(), "scan.lock"));
+  if (command.name() === "status" && !command.opts().cachedOnly) releaseScan = await acquireFileLock(join31(getCacheDir(), "scan.lock"));
 });
 program.hook("postAction", async () => {
   await releaseScan?.();