exe-watcher 0.2.67 → 0.2.69

package/README.md

@@ -31,7 +31,7 @@ npm install -g exe-watcher
 exe-watcher report
 ```
 
-Version 0.2.67 preserves recorded API-equivalent costs and keeps saved All totals available through refresh failures, restarts and day changes. AI time and the floating quota display are included. Terminal installs require Node 22.13 or newer; the Mac app includes its own compatible runtime. Download the matching app from [Releases](https://github.com/AskExe/exe-watcher/releases/latest) or [odd.community/watcher](https://odd.community/watcher). To run the current CLI from source:
+Version 0.2.69 explains that first-time history setup can take 10 minutes or more for large AI histories, with saved progress and recovery details. Large Claude history scans resume within the existing resource limits. Recorded API-equivalent costs and saved totals are preserved through refresh failures, restarts and day changes. AI time and the floating quota display are included. Terminal installs require Node 22.13 or newer; the Mac app includes its own compatible runtime. Download the matching app from [Releases](https://github.com/AskExe/exe-watcher/releases/latest) or [odd.community/watcher](https://odd.community/watcher). To run the current CLI from source:
 
 ```bash
 git clone https://github.com/AskExe/exe-watcher.git

package/dist/cli.js

@@ -2870,6 +2870,43 @@ import { promisify } from "util";
 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 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);
@@ -2883,6 +2920,7 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
   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;
@@ -2929,11 +2967,11 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
       }
     }
   }
-  const data = migrated ?? 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({
+  const payload = encodeEntry({
     v: VERSION2,
     fingerprint: before,
     data,
@@ -2942,7 +2980,10 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
     hasUnpricedUsage,
     pricingFingerprint: getPricingFingerprint()
   });
-  if (Buffer.byteLength(payload) > MAX_ENTRY) return data;
+  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(join10(dir, "writes.lock"));
@@ -2985,7 +3026,7 @@ 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)) {
@@ -3001,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";
@@ -3034,6 +3083,8 @@ var init_parsed_file_cache = __esm({
     decompress = promisify(gunzip);
     MAX_ENTRY = 16 * 1024 * 1024;
     MAX_DISK = 256 * 1024 * 1024;
+    mutationCount = 0;
+    parsedFileProgress = () => mutationCount;
   }
 });
 
@@ -3142,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 = [];
@@ -3166,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();
     }
@@ -5466,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);
       }
-      if (msgId) seenCalls.set(msgId, call);
-      else call.deduplicationKey = `${filePath}:${lineNumber}`;
-      chargeRecord();
-      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.");
+      }
+    }
+    throw error;
   }
   if (currentCalls.length > 0) {
     turns.push({
@@ -5635,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) {
@@ -6976,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;
@@ -7054,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
   };
@@ -10980,7 +11064,8 @@ function buildPeriodSnapshots(cache, todayDays, today, windows, provider, names,
         cache.historyBuild?.chunked,
         cache.missingProviders,
         cache.partialDates,
-        cache.backfill
+        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;
@@ -11132,6 +11217,7 @@ async function completeHistoryBuild(cache, start, end, providers, scan, save2, o
 }
 
 // src/cli.ts
+init_parsed_file_cache();
 import { createInterface } from "readline";
 import { createRequire as createRequire3 } from "module";
 
@@ -11511,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}
@@ -11536,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}
@@ -11564,7 +11662,7 @@ program.command("status").description("Compact status output (today + week + mon
         opts.project,
         opts.exclude
       )),
-      saveDailyCache,
+      saveHistoryCache,
       { mergeExisting }
     );
     const pausedHistory = (c) => {
@@ -11574,6 +11672,7 @@ program.command("status").description("Compact status output (today + week + mon
     };
     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);
@@ -11619,6 +11718,17 @@ 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;
     }), { 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))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exe-watcher",
-  "version": "0.2.67",
+  "version": "0.2.69",
   "description": "The owl watching your AI coding spend — cost, tokens, agents, and projects in your terminal and menu bar",
   "type": "module",
   "main": "./dist/cli.js",