exe-watcher 0.2.50 → 0.2.53

package/dist/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --max-old-space-size=256 --expose-gc
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -10,13 +10,13 @@ var __export = (target, all) => {
 };
 
 // src/cache-dir.ts
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { join } from "path";
+import { homedir } from "os";
 function getCacheDir() {
   const explicit = process.env["EXE_WATCHER_CACHE_DIR"];
   if (explicit) return explicit;
   const xdgCache = process.env["XDG_CACHE_HOME"];
-  return join2(xdgCache || join2(homedir2(), ".cache"), "exe-watcher");
+  return join(xdgCache || join(homedir(), ".cache"), "exe-watcher");
 }
 var init_cache_dir = __esm({
   "src/cache-dir.ts"() {
@@ -24,11 +24,60 @@ var init_cache_dir = __esm({
   }
 });
 
+// src/resource-budget.ts
+import { getHeapStatistics } from "v8";
+import { AsyncLocalStorage } from "async_hooks";
+function effectiveMaxBytes(requested) {
+  const override = Number(process.env["EXE_WATCHER_MAX_SCAN_BYTES"]);
+  return Number.isFinite(override) && override > 0 ? Math.min(requested, override) : requested;
+}
+function withScanBudget(fn, maxRecords = 2e5, signal, maxBytes = 1024 * 1024 * 1024) {
+  if (scans.getStore()) return fn();
+  return scans.run({ bytes: 0, records: 0, started: Date.now(), maxRecords, signal, maxBytes: effectiveMaxBytes(maxBytes) }, fn);
+}
+function chargeRead(bytes) {
+  const budget = scans.getStore();
+  if (!budget) return;
+  if (budget.signal?.aborted) throw new ResourceBudgetError("scan cancelled");
+  budget.bytes += bytes;
+  if (budget.bytes > budget.maxBytes) throw new ResourceBudgetError(`${budget.maxBytes / 1024 ** 3} GiB read budget per scan`);
+  if (Date.now() - budget.started > 3e4) throw new ResourceBudgetError("30 second scan budget");
+  const heapBudget = Math.min(384 * 1024 * 1024, getHeapStatistics().heap_size_limit * 0.65);
+  if (process.memoryUsage().heapUsed > heapBudget) {
+    global.gc?.();
+    if (process.memoryUsage().heapUsed > heapBudget) throw new ResourceBudgetError("parser heap budget");
+  }
+}
+function chargeRecord() {
+  const budget = scans.getStore();
+  if (!budget) return;
+  if (++budget.records > budget.maxRecords) throw new ResourceBudgetError(`${budget.maxRecords.toLocaleString()} scanned usage records`);
+  if (budget.records % 256 === 0) chargeRead(0);
+}
+function checkFileSize(size, cap) {
+  if (size <= cap) return true;
+  if (scans.getStore()) throw new ResourceBudgetError(`file exceeds ${cap} bytes`);
+  return false;
+}
+var ResourceBudgetError, scans;
+var init_resource_budget = __esm({
+  "src/resource-budget.ts"() {
+    "use strict";
+    ResourceBudgetError = class extends Error {
+      constructor(detail) {
+        super(`Resource limit reached (${detail}). Showing the last successful refresh; retry after background ingestion progresses.`);
+        this.name = "ResourceBudgetError";
+      }
+    };
+    scans = new AsyncLocalStorage();
+  }
+});
+
 // src/models.ts
-import { readFile as readFile3, mkdir as mkdir5, rename as rename4, unlink as unlink2 } from "fs/promises";
-import { open as open3 } from "fs/promises";
+import { readFile as readFile4, mkdir as mkdir6, rename as rename4, unlink as unlink3 } from "fs/promises";
+import { open as open4 } from "fs/promises";
 import { join as join6 } from "path";
-import { randomBytes as randomBytes3 } from "crypto";
+import { createHash, randomBytes as randomBytes3 } from "crypto";
 function getPricingWarnings() {
   return _pricingWarnings;
 }
@@ -72,10 +121,10 @@ async function fetchAndCachePricing() {
   for (const [name, costs] of fallbackStripped) {
     if (!pricing.has(name)) pricing.set(name, costs);
   }
-  await mkdir5(getCacheDir(), { recursive: true });
+  await mkdir6(getCacheDir(), { recursive: true });
   const finalPath = getCachePath();
   const tmpPath = `${finalPath}.${randomBytes3(8).toString("hex")}.tmp`;
-  const handle = await open3(tmpPath, "w", 384);
+  const handle = await open4(tmpPath, "w", 384);
   try {
     await handle.writeFile(JSON.stringify({
       timestamp: Date.now(),
@@ -89,7 +138,7 @@ async function fetchAndCachePricing() {
     await rename4(tmpPath, finalPath);
   } catch (err) {
     try {
-      await unlink2(tmpPath);
+      await unlink3(tmpPath);
     } catch {
     }
     throw err;
@@ -97,7 +146,7 @@ async function fetchAndCachePricing() {
   try {
     const lkgPath = getLastKnownGoodPath();
     const lkgTmp = `${lkgPath}.${randomBytes3(8).toString("hex")}.tmp`;
-    const lkgHandle = await open3(lkgTmp, "w", 384);
+    const lkgHandle = await open4(lkgTmp, "w", 384);
     try {
       await lkgHandle.writeFile(JSON.stringify({
         timestamp: Date.now(),
@@ -109,7 +158,7 @@ async function fetchAndCachePricing() {
     }
     await rename4(lkgTmp, lkgPath).catch(() => {
       try {
-        unlink2(lkgTmp);
+        unlink3(lkgTmp);
       } catch {
       }
     });
@@ -119,7 +168,7 @@ async function fetchAndCachePricing() {
 }
 async function loadCachedPricing() {
   try {
-    const raw = await readFile3(getCachePath(), "utf-8");
+    const raw = await readFile4(getCachePath(), "utf-8");
     const cached = JSON.parse(raw);
     if (Date.now() - cached.timestamp > CACHE_TTL_MS2) return null;
     return { map: new Map(Object.entries(cached.data)), timestamp: cached.timestamp };
@@ -129,7 +178,7 @@ async function loadCachedPricing() {
 }
 async function loadLastKnownGoodPricing() {
   try {
-    const raw = await readFile3(getLastKnownGoodPath(), "utf-8");
+    const raw = await readFile4(getLastKnownGoodPath(), "utf-8");
     const cached = JSON.parse(raw);
     return { map: new Map(Object.entries(cached.data)), timestamp: cached.timestamp };
   } catch {
@@ -267,7 +316,15 @@ function applyContextTier(costs, inputTokens) {
     cacheReadCostPerToken: tier.cacheReadCostPerToken ?? costs.cacheReadCostPerToken
   };
 }
-var LITELLM_URL, CACHE_TTL_MS2, WEB_SEARCH_COST, LONG_CONTEXT_1M_THRESHOLD_TOKENS, GEMINI_LONG_CONTEXT_THRESHOLD_TOKENS, DIRECT_PROVIDER_PREFIXES, FALLBACK_PRICING, pricingCache, _pricingWarnings, _pricingLastUpdated, STALENESS_WARN_MS, BUILTIN_ALIASES, userAliases;
+function getPricingFingerprint() {
+  if (!fingerprintValue || fingerprintPricing !== pricingCache || fingerprintAliases !== userAliases) {
+    fingerprintPricing = pricingCache;
+    fingerprintAliases = userAliases;
+    fingerprintValue = createHash("sha256").update(JSON.stringify([Array.from(pricingCache ?? []), FALLBACK_PRICING, userAliases])).digest("hex").slice(0, 16);
+  }
+  return fingerprintValue;
+}
+var LITELLM_URL, CACHE_TTL_MS2, WEB_SEARCH_COST, LONG_CONTEXT_1M_THRESHOLD_TOKENS, GEMINI_LONG_CONTEXT_THRESHOLD_TOKENS, DIRECT_PROVIDER_PREFIXES, FALLBACK_PRICING, pricingCache, _pricingWarnings, _pricingLastUpdated, STALENESS_WARN_MS, BUILTIN_ALIASES, userAliases, fingerprintPricing, fingerprintAliases, fingerprintValue;
 var init_models = __esm({
   "src/models.ts"() {
     "use strict";
@@ -376,6 +433,164 @@ var init_models = __esm({
       "anthropic--claude-4.5-haiku": "claude-haiku-4-5"
     };
     userAliases = {};
+    fingerprintValue = "";
+  }
+});
+
+// src/fs-utils.ts
+import { open as open5 } from "fs/promises";
+import { openSync, fstatSync, readSync, closeSync, constants } from "fs";
+function verbose() {
+  return process.env.EXE_WATCHER_VERBOSE === "1";
+}
+function warn(msg) {
+  if (verbose()) process.stderr.write(`exe-watcher: ${msg}
+`);
+}
+async function readSessionFirstLine(filePath) {
+  const handle = await open5(filePath, "r").catch(() => null);
+  if (!handle) return null;
+  try {
+    const chunks = [];
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let offset = 0;
+    const maxHeaderBytes = 8 * 1024 * 1024;
+    while (offset < maxHeaderBytes) {
+      const length = Math.min(offset === 0 ? 4096 : buffer.length, maxHeaderBytes - offset);
+      const { bytesRead } = await handle.read(buffer, 0, length, offset);
+      chargeRead(bytesRead);
+      if (bytesRead === 0) return Buffer.concat(chunks).toString("utf-8").replace(/\r$/, "");
+      const chunk = buffer.subarray(0, bytesRead);
+      const newline = chunk.indexOf(10);
+      if (newline >= 0) {
+        chunks.push(chunk.subarray(0, newline));
+        return Buffer.concat(chunks).toString("utf-8").replace(/\r$/, "");
+      }
+      chunks.push(Buffer.from(chunk));
+      offset += bytesRead;
+    }
+    if (!checkFileSize(offset + 1, maxHeaderBytes)) return null;
+    return null;
+  } catch (err) {
+    if (err instanceof ResourceBudgetError) throw err;
+    warn(`header read failed for ${filePath}: ${err.code ?? "unknown"}`);
+    return null;
+  } finally {
+    await handle.close();
+  }
+}
+async function readSessionFile(filePath) {
+  const handle = await open5(filePath, "r").catch(() => null);
+  if (!handle) return null;
+  try {
+    const size = (await handle.stat()).size;
+    if (!checkFileSize(size, MAX_SESSION_FILE_BYTES)) {
+      warn(`skipped oversize file ${filePath}`);
+      return null;
+    }
+    chargeRead(size);
+    const buffer = Buffer.allocUnsafe(size);
+    let offset = 0;
+    while (offset < size) {
+      const { bytesRead } = await handle.read(buffer, offset, Math.min(64 * 1024, size - offset), offset);
+      if (!bytesRead) break;
+      offset += bytesRead;
+    }
+    return buffer.toString("utf-8", 0, offset);
+  } catch (err) {
+    if (err instanceof ResourceBudgetError) throw err;
+    warn(`read failed for ${filePath}`);
+    return null;
+  } finally {
+    await handle.close();
+  }
+}
+function readSessionFileSync(filePath) {
+  const O_NOFOLLOW = constants["O_NOFOLLOW"] ?? 0;
+  let fd;
+  try {
+    fd = openSync(filePath, constants.O_RDONLY | O_NOFOLLOW);
+  } catch (err) {
+    const code = err.code ?? "unknown";
+    if (code === "ELOOP") {
+      warn(`skipped symlink ${filePath}`);
+      return null;
+    }
+    warn(`open failed for ${filePath}: ${code}`);
+    return null;
+  }
+  try {
+    const size = fstatSync(fd).size;
+    if (!checkFileSize(size, MAX_SESSION_FILE_BYTES)) {
+      warn(`skipped oversize file ${filePath} (${size} bytes > cap ${MAX_SESSION_FILE_BYTES})`);
+      return null;
+    }
+    chargeRead(size);
+    const buf = Buffer.allocUnsafe(size);
+    let offset = 0;
+    while (offset < size) {
+      const bytesRead = readSync(fd, buf, offset, size - offset, offset);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    return buf.toString("utf-8", 0, offset);
+  } catch (err) {
+    if (err instanceof ResourceBudgetError) throw err;
+    warn(`read failed for ${filePath}: ${err.code ?? "unknown"}`);
+    return null;
+  } finally {
+    closeSync(fd);
+  }
+}
+async function* readSessionLines(filePath, startByte = 0) {
+  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 });
+    let pieces = [];
+    let lineBytes = 0;
+    const maxLineBytes = 32 * 1024 * 1024;
+    const append = (piece) => {
+      lineBytes += Buffer.byteLength(piece);
+      if (lineBytes > maxLineBytes) throw new ResourceBudgetError("32 MiB JSONL record budget");
+      pieces.push(piece);
+    };
+    try {
+      for await (const chunk of stream) {
+        let start = 0;
+        let newline;
+        while ((newline = chunk.indexOf("\n", start)) >= 0) {
+          append(chunk.slice(start, newline));
+          chargeRead(0);
+          const line = pieces.join("").replace(/\r$/, "");
+          pieces = [];
+          lineBytes = 0;
+          yield line;
+          start = newline + 1;
+        }
+        if (start < chunk.length) append(chunk.slice(start));
+      }
+      if (pieces.length) yield pieces.join("").replace(/\r$/, "");
+    } finally {
+      stream.destroy();
+    }
+  } catch (err) {
+    if (err instanceof ResourceBudgetError) throw err;
+    warn(`stream read failed for ${filePath}`);
+  } finally {
+    await handle.close();
+  }
+}
+var MAX_SESSION_FILE_BYTES, STREAM_THRESHOLD_BYTES;
+var init_fs_utils = __esm({
+  "src/fs-utils.ts"() {
+    "use strict";
+    init_resource_budget();
+    MAX_SESSION_FILE_BYTES = 128 * 1024 * 1024;
+    STREAM_THRESHOLD_BYTES = 8 * 1024 * 1024;
   }
 });
 
@@ -421,17 +636,18 @@ var init_bash_utils = __esm({
 });
 
 // src/cursor-cache.ts
-import { readFile as readFile5, mkdir as mkdir6, stat as stat8, rename as rename5 } from "fs/promises";
-import { open as open4 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile8, mkdir as mkdir9, stat as stat10, rename as rename7 } from "fs/promises";
+import { open as open6 } from "fs/promises";
+import { join as join14 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 function getCachePath2() {
-  return join11(getCacheDir(), CACHE_FILE);
+  return join14(getCacheDir(), CACHE_FILE);
 }
 async function getDbFingerprint(dbPath) {
   try {
-    const s = await stat8(dbPath);
-    return { mtimeMs: s.mtimeMs, size: s.size };
+    const s = await stat10(dbPath);
+    const wal = await stat10(`${dbPath}-wal`).catch(() => null);
+    return [dbPath, s.dev, s.ino, s.ctimeMs, s.mtimeMs, s.size, wal?.ino, wal?.ctimeMs, wal?.mtimeMs, wal?.size, getPricingFingerprint()].join(":");
   } catch {
     return null;
   }
@@ -440,37 +656,42 @@ async function readCachedResults(dbPath) {
   try {
     const fp = await getDbFingerprint(dbPath);
     if (!fp) return null;
-    const raw = await readFile5(getCachePath2(), "utf-8");
+    const size = (await stat10(getCachePath2())).size;
+    if (size > 16 * 1024 * 1024) return null;
+    chargeRead(size);
+    const raw = await readFile8(getCachePath2(), "utf-8");
     const cache = JSON.parse(raw);
-    if (cache.dbMtimeMs === fp.mtimeMs && cache.dbSizeBytes === fp.size) {
+    if (cache.fingerprint === fp) {
       return cache.calls;
     }
     return null;
-  } catch {
+  } catch (err) {
+    if (err instanceof ResourceBudgetError) throw err;
     return null;
   }
 }
-async function writeCachedResults(dbPath, calls) {
+async function writeCachedResults(dbPath, calls, expected) {
   try {
     const fp = await getDbFingerprint(dbPath);
-    if (!fp) return;
+    if (!fp || expected !== void 0 && expected !== fp) return;
     const dir = getCacheDir();
-    await mkdir6(dir, { recursive: true });
+    await mkdir9(dir, { recursive: true });
     const cache = {
-      dbMtimeMs: fp.mtimeMs,
-      dbSizeBytes: fp.size,
+      fingerprint: fp,
       calls
     };
+    const payload = JSON.stringify(cache);
+    if (Buffer.byteLength(payload) > 16 * 1024 * 1024) return;
     const finalPath = getCachePath2();
     const tmpPath = `${finalPath}.${randomBytes4(8).toString("hex")}.tmp`;
-    const handle = await open4(tmpPath, "w", 384);
+    const handle = await open6(tmpPath, "w", 384);
     try {
-      await handle.writeFile(JSON.stringify(cache), { encoding: "utf-8" });
+      await handle.writeFile(payload, { encoding: "utf-8" });
       await handle.sync();
     } finally {
       await handle.close();
     }
-    await rename5(tmpPath, finalPath);
+    await rename7(tmpPath, finalPath);
   } catch {
   }
 }
@@ -478,6 +699,8 @@ var CACHE_FILE;
 var init_cursor_cache = __esm({
   "src/cursor-cache.ts"() {
     "use strict";
+    init_models();
+    init_resource_budget();
     init_cache_dir();
     CACHE_FILE = "cursor-results.json";
   }
@@ -532,7 +755,16 @@ function openDatabase(path) {
   const db = new DatabaseSync(path, { readOnly: true });
   return {
     query(sql, params = []) {
-      return db.prepare(sql).all(...params);
+      const rows = [];
+      let bytes = 0;
+      for (const row of db.prepare(sql).iterate(...params)) {
+        const size = Buffer.byteLength(JSON.stringify(row));
+        bytes += size;
+        if (rows.length >= 1e5 || bytes > 32 * 1024 * 1024) throw new ResourceBudgetError("SQLite result budget");
+        chargeRead(size);
+        rows.push(row);
+      }
+      return rows;
     },
     close() {
       db.close();
@@ -543,6 +775,7 @@ 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;
@@ -557,16 +790,16 @@ __export(cursor_exports, {
   cursor: () => cursor
 });
 import { existsSync } from "fs";
-import { join as join12 } from "path";
+import { join as join15 } from "path";
 import { homedir as homedir8 } from "os";
 function getCursorDbPath() {
   if (process.platform === "darwin") {
-    return join12(homedir8(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+    return join15(homedir8(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
   }
   if (process.platform === "win32") {
-    return join12(homedir8(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb");
+    return join15(homedir8(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb");
   }
-  return join12(homedir8(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+  return join15(homedir8(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
 }
 function extractLanguages(codeBlocksJson) {
   if (!codeBlocksJson) return [];
@@ -580,7 +813,8 @@ function extractLanguages(codeBlocksJson) {
       }
     }
     return [...langs];
-  } catch {
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
     return [];
   }
 }
@@ -598,7 +832,8 @@ function validateSchema(db) {
       "SELECT COUNT(*) as cnt FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' LIMIT 1"
     );
     return rows.length > 0;
-  } catch {
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
     return false;
   }
 }
@@ -612,7 +847,8 @@ function buildUserMessageMap(db, timeFloor) {
       existing.push(row.text);
       map.set(row.conversation_id, existing);
     }
-  } catch {
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
   }
   return map;
 }
@@ -625,7 +861,8 @@ function parseBubbles(db, seenKeys) {
   let rows;
   try {
     rows = db.query(BUBBLE_QUERY_SINCE, [timeFloor]);
-  } catch {
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
     return { calls: results };
   }
   for (const row of rows) {
@@ -668,7 +905,8 @@ function parseBubbles(db, seenKeys) {
         userMessage: userText,
         sessionId: conversationId
       });
-    } catch {
+    } catch (error) {
+      if (error instanceof ResourceBudgetError) throw error;
       skipped++;
     }
   }
@@ -685,6 +923,7 @@ function createParser4(source, seenKeys) {
         process.stderr.write(getSqliteLoadError() + "\n");
         return;
       }
+      const before = await getDbFingerprint(source.path);
       const cached = await readCachedResults(source.path);
       if (cached) {
         for (const call of cached) {
@@ -698,6 +937,7 @@ function createParser4(source, seenKeys) {
       try {
         db = openDatabase(source.path);
       } catch (err) {
+        if (err instanceof ResourceBudgetError) throw err;
         process.stderr.write(`exe-watcher: cannot open Cursor database: ${err instanceof Error ? err.message : err}
 `);
         return;
@@ -708,7 +948,7 @@ function createParser4(source, seenKeys) {
           return;
         }
         const { calls } = parseBubbles(db, seenKeys);
-        await writeCachedResults(source.path, calls);
+        await writeCachedResults(source.path, calls, before);
         for (const call of calls) {
           yield call;
         }
@@ -743,6 +983,7 @@ var CURSOR_DEFAULT_MODEL, modelDisplayNames4, BUBBLE_QUERY_BASE, USER_MESSAGES_Q
 var init_cursor = __esm({
   "src/providers/cursor.ts"() {
     "use strict";
+    init_resource_budget();
     init_models();
     init_cursor_cache();
     init_sqlite();
@@ -799,21 +1040,22 @@ __export(opencode_exports, {
   createOpenCodeProvider: () => createOpenCodeProvider,
   opencode: () => opencode
 });
-import { readdir as readdir6 } from "fs/promises";
-import { join as join13 } from "path";
+import { readdir as readdir8 } from "fs/promises";
+import { join as join16 } from "path";
 import { homedir as homedir9 } from "os";
-function sanitize(dir) {
+function sanitize2(dir) {
   return dir.replace(/^\//, "").replace(/\//g, "-");
 }
 function getDataDir(dataDir) {
-  const base = dataDir ?? process.env["XDG_DATA_HOME"] ?? join13(homedir9(), ".local", "share");
-  return join13(base, "opencode");
+  const base = dataDir ?? process.env["XDG_DATA_HOME"] ?? join16(homedir9(), ".local", "share");
+  return join16(base, "opencode");
 }
 async function findDbFiles(dir) {
   try {
-    const entries = await readdir6(dir);
-    return entries.filter((f) => f.startsWith("opencode") && f.endsWith(".db")).map((f) => join13(dir, f));
-  } catch {
+    const entries = await readdir8(dir);
+    return entries.filter((f) => f.startsWith("opencode") && f.endsWith(".db")).map((f) => join16(dir, f));
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
     return [];
   }
 }
@@ -824,13 +1066,14 @@ function parseTimestamp(raw) {
 function validateSchema2(db) {
   try {
     db.query(
-      "SELECT COUNT(*) as cnt FROM session LIMIT 1"
+      "SELECT id FROM session LIMIT 1"
     );
     db.query(
-      "SELECT COUNT(*) as cnt FROM message LIMIT 1"
+      "SELECT id FROM message LIMIT 1"
     );
     return true;
-  } catch {
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
     return false;
   }
 }
@@ -872,7 +1115,8 @@ function createParser5(source, seenKeys) {
             const list = partsByMsg.get(part.message_id) ?? [];
             list.push(parsed);
             partsByMsg.set(part.message_id, list);
-          } catch {
+          } catch (error) {
+            if (error instanceof ResourceBudgetError) throw error;
           }
         }
         let currentUserMessage = "";
@@ -880,7 +1124,8 @@ function createParser5(source, seenKeys) {
           let data;
           try {
             data = JSON.parse(msg.data);
-          } catch {
+          } catch (error) {
+            if (error instanceof ResourceBudgetError) throw error;
             continue;
           }
           if (data.role === "user") {
@@ -949,19 +1194,25 @@ async function discoverFromDb(dbPath) {
   let db;
   try {
     db = openDatabase(dbPath);
-  } catch {
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
     return [];
   }
   try {
+    if (!validateSchema2(db)) {
+      process.stderr.write("exe-watcher: OpenCode storage format not recognized. Update Watcher to read this database.\n");
+      return [];
+    }
     const rows = db.query(
       "SELECT id, directory, title, time_created FROM session WHERE time_archived IS NULL AND parent_id IS NULL ORDER BY time_created DESC"
     );
     return rows.map((row) => ({
       path: `${dbPath}:${row.id}`,
-      project: row.directory ? sanitize(row.directory) : sanitize(row.title),
+      project: row.directory ? sanitize2(row.directory) : sanitize2(row.title),
       provider: "opencode"
     }));
-  } catch {
+  } catch (error) {
+    if (error instanceof ResourceBudgetError) throw error;
     return [];
   } finally {
     db.close();
@@ -998,6 +1249,7 @@ var toolNameMap4, opencode;
 var init_opencode = __esm({
   "src/providers/opencode.ts"() {
     "use strict";
+    init_resource_budget();
     init_models();
     init_bash_utils();
     init_sqlite();
@@ -1025,20 +1277,20 @@ __export(cursor_agent_exports, {
   createCursorAgentProvider: () => createCursorAgentProvider,
   cursor_agent: () => cursor_agent
 });
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync2 } from "fs";
-import { readdir as readdir7, readFile as readFile6, stat as stat9 } from "fs/promises";
-import { join as join14, basename as basename7 } from "path";
+import { readdir as readdir9, stat as stat11 } from "fs/promises";
+import { join as join17, basename as basename7 } from "path";
 import { homedir as homedir10 } from "os";
 function getCursorAgentBaseDir(baseDirOverride) {
   if (baseDirOverride) return baseDirOverride;
-  return join14(homedir10(), ".cursor");
+  return join17(homedir10(), ".cursor");
 }
 function getProjectsDir2(baseDir) {
-  return join14(baseDir, "projects");
+  return join17(baseDir, "projects");
 }
 function getAttributionDbPath(baseDir) {
-  return join14(baseDir, "ai-tracking", "ai-code-tracking.db");
+  return join17(baseDir, "ai-tracking", "ai-code-tracking.db");
 }
 function estimateTokens(charCount) {
   if (charCount <= 0) return 0;
@@ -1089,7 +1341,7 @@ function resolveModel3(raw) {
 function toConversationId(transcriptPath) {
   const filename = basename7(transcriptPath, ".txt");
   if (filename.length === 36 && UUID_LIKE.test(filename)) return filename;
-  return createHash2("sha1").update(transcriptPath).digest("hex").slice(0, 16);
+  return createHash3("sha1").update(transcriptPath).digest("hex").slice(0, 16);
 }
 function extractUserQuery(userBlock) {
   const chunks = [];
@@ -1212,12 +1464,14 @@ function createParser6(source, seenKeys, dbPath, summariesByConversationId) {
                 };
                 summariesByConversationId[conversationId] = summary;
               }
-            } catch {
+            } catch (error) {
+              if (error instanceof ResourceBudgetError) throw error;
               summary = void 0;
             }
           }
         }
-        const transcript = await readFile6(source.path, "utf-8");
+        const transcript = await readSessionFile(source.path);
+        if (transcript === null) return;
         const parsed = parseTranscript(transcript);
         if (!parsed.recognized) {
           process.stderr.write(`exe-watcher: skipped ${basename7(source.path)}: unrecognized cursor-agent transcript format
@@ -1226,7 +1480,7 @@ function createParser6(source, seenKeys, dbPath, summariesByConversationId) {
         }
         let timestamp = summary?.updatedAt ?? null;
         if (!timestamp) {
-          const fileStat = await stat9(source.path);
+          const fileStat = await stat11(source.path);
           timestamp = fileStat.mtime.toISOString();
         }
         const model = resolveModel3(summary?.model ?? null);
@@ -1290,18 +1544,18 @@ function createCursorAgentProvider(baseDirOverride) {
     },
     async discoverSessions() {
       if (!existsSync2(projectsDir)) return [];
-      const projectEntries = await readdir7(projectsDir, { withFileTypes: true });
+      const projectEntries = await readdir9(projectsDir, { withFileTypes: true });
       const sources = [];
       for (const entry of projectEntries) {
         if (!entry.isDirectory()) continue;
         const projectId = prettifyProjectId(entry.name);
-        const transcriptDir = join14(projectsDir, entry.name, "agent-transcripts");
+        const transcriptDir = join17(projectsDir, entry.name, "agent-transcripts");
         if (!existsSync2(transcriptDir)) continue;
-        const transcriptEntries = await readdir7(transcriptDir, { withFileTypes: true });
+        const transcriptEntries = await readdir9(transcriptDir, { withFileTypes: true });
         for (const transcript of transcriptEntries) {
           if (!transcript.isFile()) continue;
           if (!transcript.name.endsWith(".txt")) continue;
-          const transcriptPath = join14(transcriptDir, transcript.name);
+          const transcriptPath = join17(transcriptDir, transcript.name);
           sources.push({
             path: transcriptPath,
             project: projectId,
@@ -1320,6 +1574,8 @@ var CURSOR_AGENT_DEFAULT_MODEL, CHARS_PER_TOKEN, MAX_USER_TEXT_LENGTH, DIGITS_ON
 var init_cursor_agent = __esm({
   "src/providers/cursor-agent.ts"() {
     "use strict";
+    init_resource_budget();
+    init_fs_utils();
     init_models();
     init_sqlite();
     CURSOR_AGENT_DEFAULT_MODEL = "claude-sonnet-4-5";
@@ -1358,17 +1614,87 @@ var init_cursor_agent = __esm({
 });
 
 // src/cli.ts
-import { existsSync as existsSync7, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { join as join23 } from "path";
+init_cache_dir();
+
+// src/file-lock.ts
+import { mkdir, open, readFile, stat, unlink } from "fs/promises";
+import { dirname } from "path";
+async function acquireFileLock(path, timeoutMs = 15e3) {
+  await mkdir(dirname(path), { recursive: true });
+  const token = `${process.pid}:${Date.now()}:${Math.random()}`;
+  const started = Date.now();
+  while (true) {
+    try {
+      const handle = await open(path, "wx", 384);
+      await handle.writeFile(token);
+      await handle.close();
+      return async () => {
+        if (await readFile(path, "utf8").catch(() => "") === token) await unlink(path).catch(() => {
+        });
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    const reaperPath = `${path}.reaper`;
+    const reaper = await open(reaperPath, "wx", 384).catch(() => null);
+    if (reaper) {
+      try {
+        await reaper.writeFile(token);
+        const owner = await readFile(path, "utf8").catch(() => "");
+        const pid = Number(owner.split(":")[0]);
+        let dead = false;
+        if (pid > 0) {
+          try {
+            process.kill(pid, 0);
+          } catch (e) {
+            dead = e.code === "ESRCH";
+          }
+        } else {
+          const s = await stat(path).catch(() => null);
+          dead = !!s && Date.now() - s.mtimeMs > 5e3;
+        }
+        if (dead) await unlink(path).catch(() => {
+        });
+      } finally {
+        await reaper.close();
+        await unlink(reaperPath).catch(() => {
+        });
+      }
+    } else {
+      const owner = await readFile(reaperPath, "utf8").catch(() => "");
+      const pid = Number(owner.split(":")[0]);
+      let dead = false;
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+        } catch (e) {
+          dead = e.code === "ESRCH";
+        }
+      } else {
+        const s = await stat(reaperPath).catch(() => null);
+        dead = !!s && Date.now() - s.mtimeMs > 5e3;
+      }
+      if (dead && await readFile(reaperPath, "utf8").catch(() => "") === owner) await unlink(reaperPath).catch(() => {
+      });
+    }
+    if (Date.now() - started >= timeoutMs) throw new Error("Another Watcher scan is still running. Keeping the last successful refresh.");
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
+  }
+}
+
+// src/cli.ts
+init_resource_budget();
+import { existsSync as existsSync7, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
+import { join as join25 } from "path";
 import { homedir as homedir14 } from "os";
 import { Command } from "commander";
 
 // src/menubar-installer.ts
 import { spawn } from "child_process";
 import { createWriteStream } from "fs";
-import { cp, mkdir, mkdtemp, rename, rm, stat } from "fs/promises";
-import { homedir, platform, tmpdir } from "os";
-import { basename, join } from "path";
+import { cp, mkdir as mkdir2, mkdtemp, rename, rm, stat as stat2 } from "fs/promises";
+import { homedir as homedir2, platform, tmpdir } from "os";
+import { basename, join as join2 } from "path";
 import { pipeline } from "stream/promises";
 import { Readable } from "stream";
 var RELEASE_API_LATEST = "https://api.github.com/repos/AskExe/exe-watcher/releases/latest";
@@ -1382,11 +1708,11 @@ var DEFAULT_APP_EXIT_TIMEOUT_MS = 5e3;
 var DEFAULT_APP_LAUNCH_TIMEOUT_MS = 5e3;
 var POLL_INTERVAL_MS = 150;
 function userApplicationsDir() {
-  return join(homedir(), "Applications");
+  return join2(homedir2(), "Applications");
 }
 async function exists(path) {
   try {
-    await stat(path);
+    await stat2(path);
     return true;
   } catch {
     return false;
@@ -1567,7 +1893,7 @@ async function killRunningApp() {
 async function installMenubarApp(options = {}) {
   await ensureSupportedPlatform();
   const appsDir = userApplicationsDir();
-  const targetPath = join(appsDir, APP_BUNDLE_NAME);
+  const targetPath = join2(appsDir, APP_BUNDLE_NAME);
   const alreadyInstalled = await exists(targetPath);
   if (alreadyInstalled && !options.force) {
     if (!await isAppRunning()) {
@@ -1577,21 +1903,21 @@ async function installMenubarApp(options = {}) {
   }
   console.log(options.version ? `Looking up Exe Watcher Menubar release ${options.version}...` : "Looking up the latest Exe Watcher Menubar release...");
   const asset = await fetchLatestReleaseAsset(options.version);
-  const stagingDir = await mkdtemp(join(tmpdir(), "exe-watcher-menubar-"));
+  const stagingDir = await mkdtemp(join2(tmpdir(), "exe-watcher-menubar-"));
   try {
-    const archivePath = join(stagingDir, asset.name);
+    const archivePath = join2(stagingDir, asset.name);
     console.log(`Downloading ${asset.name}...`);
     await downloadToFile(asset.browser_download_url, archivePath);
     console.log("Unpacking...");
     await runCommand("/usr/bin/unzip", ["-q", archivePath, "-d", stagingDir]);
-    const unpackedApp = join(stagingDir, APP_BUNDLE_NAME);
+    const unpackedApp = join2(stagingDir, APP_BUNDLE_NAME);
     if (!await exists(unpackedApp)) {
       throw new Error(`Archive did not contain ${APP_BUNDLE_NAME}.`);
     }
     await runCommand("/usr/bin/xattr", ["-dr", "com.apple.quarantine", unpackedApp]).catch(() => {
     });
-    await mkdir(appsDir, { recursive: true });
-    const backupPath = alreadyInstalled ? join(appsDir, `${basename(APP_BUNDLE_NAME, ".app")}.backup-${Date.now()}.app`) : void 0;
+    await mkdir2(appsDir, { recursive: true });
+    const backupPath = alreadyInstalled ? join2(appsDir, `${basename(APP_BUNDLE_NAME, ".app")}.backup-${Date.now()}.app`) : void 0;
     let targetReplaced = false;
     try {
       if (alreadyInstalled && backupPath) {
@@ -1624,8 +1950,8 @@ async function installMenubarApp(options = {}) {
 }
 
 // src/export.ts
-import { writeFile, mkdir as mkdir4, readdir, stat as stat2, rm as rm2 } from "fs/promises";
-import { dirname, join as join5, resolve } from "path";
+import { writeFile, mkdir as mkdir5, readdir, stat as stat3, rm as rm2 } from "fs/promises";
+import { dirname as dirname2, join as join5, resolve } from "path";
 
 // src/types.ts
 var CATEGORY_LABELS = {
@@ -1639,14 +1965,14 @@ var CATEGORY_LABELS = {
 
 // src/currency.ts
 init_cache_dir();
-import { readFile as readFile2, mkdir as mkdir3, rename as rename3, unlink } from "fs/promises";
-import { open as open2 } from "fs/promises";
+import { readFile as readFile3, mkdir as mkdir4, rename as rename3, unlink as unlink2 } from "fs/promises";
+import { open as open3 } from "fs/promises";
 import { join as join4 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // src/config.ts
-import { readFile, mkdir as mkdir2, rename as rename2 } from "fs/promises";
-import { open } from "fs/promises";
+import { readFile as readFile2, mkdir as mkdir3, rename as rename2 } from "fs/promises";
+import { open as open2 } from "fs/promises";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 import { randomBytes } from "crypto";
@@ -1659,17 +1985,17 @@ function getConfigPath() {
 }
 async function readConfig() {
   try {
-    const raw = await readFile(getConfigPath(), "utf-8");
+    const raw = await readFile2(getConfigPath(), "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 async function saveConfig(config) {
-  await mkdir2(getConfigDir(), { recursive: true });
+  await mkdir3(getConfigDir(), { recursive: true });
   const configPath = getConfigPath();
   const tmpPath = `${configPath}.${randomBytes(8).toString("hex")}.tmp`;
-  const handle = await open(tmpPath, "w", 384);
+  const handle = await open2(tmpPath, "w", 384);
   try {
     await handle.writeFile(JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8" });
     await handle.sync();
@@ -1742,7 +2068,7 @@ async function fetchRate(code) {
 }
 async function loadCachedRate(code) {
   try {
-    const raw = await readFile2(getRateCachePath(), "utf-8");
+    const raw = await readFile3(getRateCachePath(), "utf-8");
     const cached = JSON.parse(raw);
     if (typeof cached.code !== "string" || cached.code !== code) return null;
     if (typeof cached.timestamp !== "number" || !Number.isFinite(cached.timestamp)) return null;
@@ -1754,10 +2080,10 @@ async function loadCachedRate(code) {
   }
 }
 async function cacheRate(code, rate) {
-  await mkdir3(getCacheDir(), { recursive: true });
+  await mkdir4(getCacheDir(), { recursive: true });
   const finalPath = getRateCachePath();
   const tmpPath = `${finalPath}.${randomBytes2(8).toString("hex")}.tmp`;
-  const handle = await open2(tmpPath, "w", 384);
+  const handle = await open3(tmpPath, "w", 384);
   try {
     await handle.writeFile(JSON.stringify({ timestamp: Date.now(), code, rate }), { encoding: "utf-8" });
     await handle.sync();
@@ -1768,7 +2094,7 @@ async function cacheRate(code, rate) {
     await rename3(tmpPath, finalPath);
   } catch (err) {
     try {
-      await unlink(tmpPath);
+      await unlink2(tmpPath);
     } catch {
     }
     throw err;
@@ -2274,7 +2600,7 @@ function buildReadme(periods) {
 }
 var EXPORT_MARKER_FILE = ".exe-watcher-export";
 async function isExeWatcherExportFolder(path) {
-  const markerStat = await stat2(join5(path, EXPORT_MARKER_FILE)).catch(() => null);
+  const markerStat = await stat3(join5(path, EXPORT_MARKER_FILE)).catch(() => null);
   return markerStat?.isFile() ?? false;
 }
 async function clearExeWatcherExportFolder(path) {
@@ -2290,7 +2616,7 @@ async function exportCsv(periods, outputPath) {
   if (folder.toLowerCase().endsWith(".csv")) {
     folder = folder.slice(0, -4);
   }
-  const existingStat = await stat2(folder).catch(() => null);
+  const existingStat = await stat3(folder).catch(() => null);
   if (existingStat?.isFile()) {
     throw new Error(`Refusing to overwrite existing file at ${folder}. Pass a directory path instead.`);
   }
@@ -2302,7 +2628,7 @@ async function exportCsv(periods, outputPath) {
     }
     await clearExeWatcherExportFolder(folder);
   }
-  await mkdir4(folder, { recursive: true });
+  await mkdir5(folder, { recursive: true });
   await writeFile(join5(folder, EXPORT_MARKER_FILE), "", "utf-8");
   const dailyRows = periods.flatMap((p) => buildDailyRows(p.projects, p.label));
   const activityRows = periods.flatMap((p) => buildActivityRows(p.projects, p.label));
@@ -2339,7 +2665,7 @@ async function exportJson(periods, outputPath) {
     shellCommands: buildBashRows(thirtyDayProjects)
   };
   const target = resolve(outputPath.toLowerCase().endsWith(".json") ? outputPath : `${outputPath}.json`);
-  await mkdir4(dirname(target), { recursive: true });
+  await mkdir5(dirname2(target), { recursive: true });
   await writeFile(target, JSON.stringify(data, null, 2), "utf-8");
   return target;
 }
@@ -2348,113 +2674,480 @@ async function exportJson(periods, outputPath) {
 init_models();
 
 // src/parser.ts
-import { readdir as readdir8, stat as stat11 } from "fs/promises";
-import { basename as basename8, join as join16 } from "path";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 
-// src/fs-utils.ts
-import { readFile as readFile4, stat as stat3 } from "fs/promises";
-import { createReadStream, openSync, fstatSync, readSync, closeSync, constants } from "fs";
-import { createInterface } from "readline";
-var MAX_SESSION_FILE_BYTES = 128 * 1024 * 1024;
-var STREAM_THRESHOLD_BYTES = 8 * 1024 * 1024;
-function verbose() {
-  return process.env.EXE_WATCHER_VERBOSE === "1";
-}
-function warn(msg) {
-  if (verbose()) process.stderr.write(`exe-watcher: ${msg}
-`);
-}
-async function readViaStream(filePath) {
-  const chunks = [];
-  const stream = createReadStream(filePath, { encoding: "utf-8" });
-  const rl = createInterface({ input: stream, crlfDelay: Infinity });
-  for await (const line of rl) chunks.push(line);
-  return chunks.join("\n");
-}
-async function readSessionFile(filePath) {
-  let size;
-  try {
-    size = (await stat3(filePath)).size;
-  } catch (err) {
-    warn(`stat failed for ${filePath}: ${err.code ?? "unknown"}`);
-    return null;
-  }
-  if (size > MAX_SESSION_FILE_BYTES) {
-    warn(`skipped oversize file ${filePath} (${size} bytes > cap ${MAX_SESSION_FILE_BYTES})`);
-    return null;
-  }
-  try {
-    if (size >= STREAM_THRESHOLD_BYTES) return await readViaStream(filePath);
-    return await readFile4(filePath, "utf-8");
-  } catch (err) {
-    warn(`read failed for ${filePath}: ${err.code ?? "unknown"}`);
-    return null;
-  }
-}
-function readSessionFileSync(filePath) {
-  const O_NOFOLLOW = constants["O_NOFOLLOW"] ?? 0;
-  let fd;
-  try {
-    fd = openSync(filePath, constants.O_RDONLY | O_NOFOLLOW);
-  } catch (err) {
-    const code = err.code ?? "unknown";
-    if (code === "ELOOP") {
-      warn(`skipped symlink ${filePath}`);
-      return null;
-    }
-    warn(`open failed for ${filePath}: ${code}`);
-    return null;
-  }
-  try {
-    const size = fstatSync(fd).size;
-    if (size > MAX_SESSION_FILE_BYTES) {
-      warn(`skipped oversize file ${filePath} (${size} bytes > cap ${MAX_SESSION_FILE_BYTES})`);
-      return null;
+// src/compare-stats.ts
+import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { join as join7 } from "path";
+var PLANNING_TOOLS = /* @__PURE__ */ new Set(["TaskCreate", "TaskUpdate", "TodoWrite", "EnterPlanMode", "ExitPlanMode"]);
+function aggregateModelStats(projects) {
+  const byModel = /* @__PURE__ */ new Map();
+  const ensure = (model) => {
+    let s = byModel.get(model);
+    if (!s) {
+      s = { model, calls: 0, cost: 0, outputTokens: 0, inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTurns: 0, editTurns: 0, oneShotTurns: 0, retries: 0, selfCorrections: 0, editCost: 0, firstSeen: "", lastSeen: "" };
+      byModel.set(model, s);
     }
-    const buf = Buffer.allocUnsafe(size);
-    let offset = 0;
-    while (offset < size) {
-      const bytesRead = readSync(fd, buf, offset, size - offset, offset);
-      if (bytesRead === 0) break;
-      offset += bytesRead;
+    return s;
+  };
+  for (const project of projects) {
+    for (const session of project.sessions) {
+      if (session.reportSummary) {
+        for (const row of Object.values(session.reportSummary.models)) mergeCounters(ensure(row.model), row);
+        continue;
+      }
+      for (const turn of session.turns) {
+        if (turn.assistantCalls.length === 0) continue;
+        const primaryModel = turn.assistantCalls[0].model;
+        if (primaryModel === "<synthetic>") continue;
+        const ms = ensure(primaryModel);
+        ms.totalTurns++;
+        if (turn.hasEdits) {
+          ms.editTurns++;
+          if (turn.retries === 0) ms.oneShotTurns++;
+          for (const c of turn.assistantCalls) {
+            if (c.model !== "<synthetic>") ms.editCost += c.costUSD;
+          }
+        }
+        ms.retries += turn.retries;
+        for (const call of turn.assistantCalls) {
+          if (call.model === "<synthetic>") continue;
+          const cs = call.model === primaryModel ? ms : ensure(call.model);
+          cs.calls++;
+          cs.cost += call.costUSD;
+          cs.outputTokens += call.usage.outputTokens;
+          cs.inputTokens += call.usage.inputTokens;
+          cs.cacheReadTokens += call.usage.cacheReadInputTokens;
+          cs.cacheWriteTokens += call.usage.cacheCreationInputTokens;
+          if (!cs.firstSeen || call.timestamp < cs.firstSeen) cs.firstSeen = call.timestamp;
+          if (!cs.lastSeen || call.timestamp > cs.lastSeen) cs.lastSeen = call.timestamp;
+        }
+      }
     }
-    return buf.toString("utf-8", 0, offset);
-  } catch (err) {
-    warn(`read failed for ${filePath}: ${err.code ?? "unknown"}`);
-    return null;
-  } finally {
-    closeSync(fd);
   }
+  return [...byModel.values()].sort((a, b) => b.cost - a.cost);
 }
-async function* readSessionLines(filePath, startByte) {
-  let size;
-  try {
-    size = (await stat3(filePath)).size;
-  } catch (err) {
-    warn(`stat failed for ${filePath}: ${err.code ?? "unknown"}`);
-    return;
-  }
-  if (size > MAX_SESSION_FILE_BYTES) {
-    warn(`skipped oversize file ${filePath} (${size} bytes > cap ${MAX_SESSION_FILE_BYTES})`);
-    return;
-  }
-  const stream = createReadStream(filePath, { encoding: "utf-8", start: startByte ?? 0 });
-  const rl = createInterface({ input: stream, crlfDelay: Infinity });
-  try {
-    for await (const line of rl) yield line;
-  } catch (err) {
-    warn(`stream read failed for ${filePath}: ${err.code ?? "unknown"}`);
-  } finally {
-    stream.destroy();
-  }
+var METRICS = [
+  {
+    section: "Performance",
+    label: "One-shot rate",
+    formatFn: "percent",
+    higherIsBetter: true,
+    compute: (s) => s.editTurns > 0 ? s.oneShotTurns / s.editTurns * 100 : null
+  },
+  {
+    section: "Performance",
+    label: "Retry rate",
+    formatFn: "decimal",
+    higherIsBetter: false,
+    compute: (s) => s.editTurns > 0 ? s.retries / s.editTurns : null
+  },
+  {
+    section: "Performance",
+    label: "Self-correction",
+    formatFn: "percent",
+    higherIsBetter: false,
+    compute: (s) => s.totalTurns > 0 ? s.selfCorrections / s.totalTurns * 100 : null
+  },
+  {
+    section: "Efficiency",
+    label: "Cost / call",
+    formatFn: "cost",
+    higherIsBetter: false,
+    compute: (s) => s.calls > 0 ? s.cost / s.calls : null
+  },
+  {
+    section: "Efficiency",
+    label: "Cost / edit",
+    formatFn: "cost",
+    higherIsBetter: false,
+    compute: (s) => s.editTurns > 0 ? s.editCost / s.editTurns : null
+  },
+  {
+    section: "Efficiency",
+    label: "Output tok / call",
+    formatFn: "number",
+    higherIsBetter: false,
+    compute: (s) => s.calls > 0 ? Math.round(s.outputTokens / s.calls) : null
+  },
+  {
+    section: "Efficiency",
+    label: "Cache hit rate",
+    formatFn: "percent",
+    higherIsBetter: true,
+    compute: (s) => {
+      const total = s.inputTokens + s.cacheReadTokens + s.cacheWriteTokens;
+      return total > 0 ? s.cacheReadTokens / total * 100 : null;
+    }
+  }
+];
+function pickWinner(valueA, valueB, higherIsBetter) {
+  if (valueA === null || valueB === null) return "none";
+  if (valueA === valueB) return "tie";
+  if (higherIsBetter) return valueA > valueB ? "a" : "b";
+  return valueA < valueB ? "a" : "b";
+}
+function computeComparison(a, b) {
+  return METRICS.map((m) => {
+    const valueA = m.compute(a);
+    const valueB = m.compute(b);
+    return {
+      section: m.section,
+      label: m.label,
+      valueA,
+      valueB,
+      formatFn: m.formatFn,
+      winner: pickWinner(valueA, valueB, m.higherIsBetter)
+    };
+  });
+}
+function computeCategoryComparison(projects, modelA, modelB) {
+  const mapA = /* @__PURE__ */ new Map();
+  const mapB = /* @__PURE__ */ new Map();
+  const ensure = (map, cat) => {
+    let a = map.get(cat);
+    if (!a) {
+      a = { turns: 0, editTurns: 0, oneShotTurns: 0 };
+      map.set(cat, a);
+    }
+    return a;
+  };
+  for (const project of projects) {
+    for (const session of project.sessions) {
+      if (session.reportSummary) {
+        for (const [model, map] of [[modelA, mapA], [modelB, mapB]]) {
+          for (const [category, row] of Object.entries(session.reportSummary.categories[model] ?? {})) mergeCounters(ensure(map, category), row);
+        }
+        continue;
+      }
+      for (const turn of session.turns) {
+        if (turn.assistantCalls.length === 0) continue;
+        const primary = turn.assistantCalls[0].model;
+        if (primary !== modelA && primary !== modelB) continue;
+        const acc = ensure(primary === modelA ? mapA : mapB, turn.category);
+        acc.turns++;
+        if (turn.hasEdits) {
+          acc.editTurns++;
+          if (turn.retries === 0) acc.oneShotTurns++;
+        }
+      }
+    }
+  }
+  const allCats = /* @__PURE__ */ new Set([...mapA.keys(), ...mapB.keys()]);
+  const result = [];
+  for (const category of allCats) {
+    const a = mapA.get(category);
+    const b = mapB.get(category);
+    if ((!a || a.editTurns === 0) && (!b || b.editTurns === 0)) continue;
+    const rateA = a && a.editTurns > 0 ? a.oneShotTurns / a.editTurns * 100 : null;
+    const rateB = b && b.editTurns > 0 ? b.oneShotTurns / b.editTurns * 100 : null;
+    result.push({
+      category,
+      turnsA: a?.turns ?? 0,
+      editTurnsA: a?.editTurns ?? 0,
+      oneShotRateA: rateA,
+      turnsB: b?.turns ?? 0,
+      editTurnsB: b?.editTurns ?? 0,
+      oneShotRateB: rateB,
+      winner: pickWinner(rateA, rateB, true)
+    });
+  }
+  return result.sort((a, b) => b.turnsA + b.turnsB - (a.turnsA + a.turnsB));
+}
+function computeWorkingStyle(projects, modelA, modelB) {
+  const sA = { totalTurns: 0, agentSpawns: 0, planModeUses: 0, totalToolCalls: 0, fastModeCalls: 0 };
+  const sB = { totalTurns: 0, agentSpawns: 0, planModeUses: 0, totalToolCalls: 0, fastModeCalls: 0 };
+  for (const project of projects) {
+    for (const session of project.sessions) {
+      if (session.reportSummary) {
+        if (session.reportSummary.styles[modelA]) mergeCounters(sA, session.reportSummary.styles[modelA]);
+        if (session.reportSummary.styles[modelB]) mergeCounters(sB, session.reportSummary.styles[modelB]);
+        continue;
+      }
+      for (const turn of session.turns) {
+        if (turn.assistantCalls.length === 0) continue;
+        const primary = turn.assistantCalls[0].model;
+        if (primary !== modelA && primary !== modelB) continue;
+        const s = primary === modelA ? sA : sB;
+        s.totalTurns++;
+        const turnTools = turn.assistantCalls.flatMap((c) => c.tools);
+        if (turnTools.some((t) => PLANNING_TOOLS.has(t)) || turn.assistantCalls.some((c) => c.hasPlanMode)) {
+          s.planModeUses++;
+        }
+        for (const call of turn.assistantCalls) {
+          s.totalToolCalls += call.tools.length;
+          if (call.hasAgentSpawn) s.agentSpawns++;
+          if (call.speed === "fast") s.fastModeCalls++;
+        }
+      }
+    }
+  }
+  const pct2 = (num, den) => den > 0 ? num / den * 100 : null;
+  const avg = (num, den) => den > 0 ? num / den : null;
+  return [
+    { label: "Delegation rate", valueA: pct2(sA.agentSpawns, sA.totalTurns), valueB: pct2(sB.agentSpawns, sB.totalTurns), formatFn: "percent" },
+    { label: "Planning rate", valueA: pct2(sA.planModeUses, sA.totalTurns), valueB: pct2(sB.planModeUses, sB.totalTurns), formatFn: "percent" },
+    { label: "Avg tools / turn", valueA: avg(sA.totalToolCalls, sA.totalTurns), valueB: avg(sB.totalToolCalls, sB.totalTurns), formatFn: "decimal" },
+    { label: "Fast mode usage", valueA: pct2(sA.fastModeCalls, sA.totalTurns), valueB: pct2(sB.fastModeCalls, sB.totalTurns), formatFn: "percent" }
+  ];
+}
+var SELF_CORRECTION_PATTERNS = [
+  /\bmy mistake\b/i,
+  /\bmy bad\b/i,
+  /\bmy apolog/i,
+  /\bI apologize\b/i,
+  /\bI was wrong\b/i,
+  /\bI was incorrect\b/i,
+  /\bI made (a |an )?(error|mistake)\b/i,
+  /\bI incorrectly\b/i,
+  /\bI mistakenly\b/i,
+  /\bthat was (incorrect|wrong|an error)\b/i,
+  /\blet me correct that\b/i,
+  /\bI need to correct\b/i,
+  /\byou're right[.,]? I/i,
+  /\bsorry about that\b/i
+];
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((b) => b !== null && typeof b === "object" && b.type === "text" && typeof b.text === "string").map((b) => b.text).join(" ");
+}
+function isCompactFile(name) {
+  return name.includes("compact");
+}
+async function collectJsonlFiles(sessionDir) {
+  const entries = await readdir2(sessionDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".jsonl") && !isCompactFile(entry.name)) {
+      files.push(join7(sessionDir, entry.name));
+    } else if (entry.isDirectory() && entry.name === "subagents") {
+      const subEntries = await readdir2(join7(sessionDir, entry.name), { withFileTypes: true });
+      for (const sub of subEntries) {
+        if (sub.isFile() && sub.name.endsWith(".jsonl") && !isCompactFile(sub.name)) {
+          files.push(join7(sessionDir, entry.name, sub.name));
+        }
+      }
+    }
+  }
+  return files;
+}
+async function scanSelfCorrections(projectDirs) {
+  const counts = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of projectDirs) {
+    let entries;
+    try {
+      entries = await readdir2(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    const allFiles = [];
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".jsonl") && !isCompactFile(entry.name)) {
+        allFiles.push(join7(dir, entry.name));
+      } else if (entry.isDirectory()) {
+        try {
+          const sessionFiles = await collectJsonlFiles(join7(dir, entry.name));
+          allFiles.push(...sessionFiles);
+        } catch {
+          continue;
+        }
+      }
+    }
+    for (const file of allFiles) {
+      let raw;
+      try {
+        raw = await readFile5(file, "utf8");
+      } catch {
+        continue;
+      }
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        const rec = parsed;
+        if (!rec || typeof rec !== "object" || rec["type"] !== "assistant") continue;
+        const ts = rec["timestamp"];
+        const msg = rec["message"];
+        if (msg === null || typeof msg !== "object") continue;
+        const msgRec = msg;
+        const model = msgRec["model"];
+        if (typeof model !== "string" || model === "<synthetic>") continue;
+        const dedupeKey = `${model}:${ts}`;
+        if (seen.has(dedupeKey)) continue;
+        seen.add(dedupeKey);
+        const text = extractText(msgRec["content"]);
+        if (SELF_CORRECTION_PATTERNS.some((p) => p.test(text))) {
+          counts.set(model, (counts.get(model) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  return counts;
+}
+
+// src/report-summary.ts
+var planning = /* @__PURE__ */ new Set(["TaskCreate", "TaskUpdate", "TodoWrite", "EnterPlanMode", "ExitPlanMode"]);
+function compactReportSession(session) {
+  const report = { daily: /* @__PURE__ */ Object.create(null), models: /* @__PURE__ */ Object.create(null), categories: /* @__PURE__ */ Object.create(null), styles: /* @__PURE__ */ Object.create(null) };
+  for (const model of aggregateModelStats([{ project: session.project, projectPath: "", sessions: [session], totalCostUSD: session.totalCostUSD, totalApiCalls: session.apiCalls }])) report.models[model.model] = model;
+  for (const turn of session.turns) {
+    if (turn.timestamp) {
+      const day = dateKey(turn.timestamp);
+      const d = report.daily[day] ??= { cost: 0, calls: 0 };
+      d.cost += turn.assistantCalls.reduce((n, c) => n + c.costUSD, 0);
+      d.calls += turn.assistantCalls.length;
+    }
+    const model = turn.assistantCalls[0]?.model;
+    if (!model) continue;
+    const cats = report.categories[model] ??= /* @__PURE__ */ Object.create(null);
+    const cat = cats[turn.category] ??= { turns: 0, editTurns: 0, oneShotTurns: 0 };
+    cat.turns++;
+    if (turn.hasEdits) {
+      cat.editTurns++;
+      if (!turn.retries) cat.oneShotTurns++;
+    }
+    const style = report.styles[model] ??= { totalTurns: 0, agentSpawns: 0, planModeUses: 0, totalToolCalls: 0, fastModeCalls: 0 };
+    style.totalTurns++;
+    if (turn.assistantCalls.some((c) => c.hasPlanMode || c.tools.some((t) => planning.has(t)))) style.planModeUses++;
+    for (const call of turn.assistantCalls) {
+      style.totalToolCalls += call.tools.length;
+      if (call.hasAgentSpawn) style.agentSpawns++;
+      if (call.speed === "fast") style.fastModeCalls++;
+    }
+  }
+  session.reportSummary = report;
+  session.turns = [];
+  return session;
+}
+function mergeReportSession(target, source) {
+  mergeCounters(target, source);
+}
+function mergeCounters(target, source) {
+  const dst = target;
+  for (const [key, value] of Object.entries(source)) {
+    const old = Object.hasOwn(dst, key) ? dst[key] : void 0;
+    let next = old;
+    if (typeof value === "number") next = (typeof old === "number" ? old : 0) + value;
+    else if (typeof value === "string") {
+      if (key === "firstSeen" || key === "firstTimestamp") next = !old || value && value < String(old) ? value : old;
+      else if (key === "lastSeen" || key === "lastTimestamp") next = !old || value > String(old) ? value : old;
+      else next = old ?? value;
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      next = old && typeof old === "object" ? old : /* @__PURE__ */ Object.create(null);
+      mergeCounters(next, value);
+    }
+    Object.defineProperty(dst, key, { value: next, writable: true, enumerable: true, configurable: true });
+  }
+}
+
+// src/parsed-file-cache.ts
+init_cache_dir();
+init_models();
+init_resource_budget();
+import { createHash as createHash2, randomUUID } from "crypto";
+import { mkdir as mkdir7, readFile as readFile6, stat as stat4, writeFile as writeFile2, rename as rename5, unlink as unlink4, readdir as readdir3 } from "fs/promises";
+import { join as join8 } from "path";
+var VERSION = 1;
+var MAX_ENTRY = 16 * 1024 * 1024;
+var MAX_DISK = 256 * 1024 * 1024;
+var maintainedDir = "";
+async function fingerprint(path) {
+  try {
+    const s = await stat4(path);
+    const wal = await stat4(`${path}-wal`).catch(() => null);
+    return [s.dev, s.ino, s.size, s.mtimeMs, s.ctimeMs, wal?.size, wal?.mtimeMs].join(":");
+  } catch {
+    return null;
+  }
+}
+async function cachedFileParse(path, kind, parse, warnings) {
+  const dir = join8(getCacheDir(), "parsed-files");
+  const key = createHash2("sha256").update(`${VERSION}:${kind}:${path}:${getPricingFingerprint()}`).digest("hex");
+  const cachePath = join8(dir, `${key}.json`);
+  const fingerprintPath = kind === "opencode" ? path.slice(0, path.lastIndexOf(":")) : path;
+  const before = await fingerprint(fingerprintPath);
+  if (before) {
+    try {
+      const s = await stat4(cachePath);
+      if (s.size <= MAX_ENTRY) {
+        chargeRead(s.size);
+        const saved = JSON.parse(await readFile6(cachePath, "utf8"));
+        if (saved.v === VERSION && saved.fingerprint === before && Array.isArray(saved.data)) {
+          if (Array.isArray(saved.warnings)) warnings?.push(...saved.warnings.filter((w) => typeof w === "string"));
+          return saved.data;
+        }
+      }
+    } catch (err) {
+      if (err instanceof ResourceBudgetError) throw err;
+    }
+  }
+  const data = await parse();
+  if (!before || await fingerprint(fingerprintPath) !== before) return data;
+  const payload = JSON.stringify({ v: VERSION, fingerprint: before, data, warnings });
+  if (Buffer.byteLength(payload) > MAX_ENTRY) return data;
+  await mkdir7(dir, { recursive: true });
+  const release = await acquireFileLock(join8(dir, "writes.lock"));
+  try {
+    const quotaPath = join8(dir, "quota");
+    if (maintainedDir !== dir) {
+      const files = await readdir3(dir);
+      const rows = [];
+      for (const name of files) {
+        if (!name.endsWith(".json") && !name.endsWith(".tmp")) continue;
+        const p = join8(dir, name), s = await stat4(p).catch(() => null);
+        if (s) rows.push({ path: p, size: s.size, mtime: s.mtimeMs });
+      }
+      let total = rows.reduce((n, r) => n + r.size, 0);
+      for (const row of rows.sort((a, b) => a.mtime - b.mtime)) {
+        if (total <= MAX_DISK) break;
+        await unlink4(row.path).catch(() => {
+        });
+        total -= row.size;
+      }
+      await writeFile2(quotaPath, String(total), { mode: 384 });
+      maintainedDir = dir;
+    }
+    if (await readFile6(cachePath, "utf8").catch(() => "") !== payload) {
+      const total = Number(await readFile6(quotaPath, "utf8").catch(() => String(MAX_DISK)));
+      const oldSize = (await stat4(cachePath).catch(() => null))?.size ?? 0;
+      const nextSize = total - oldSize + Buffer.byteLength(payload);
+      if (!Number.isFinite(nextSize) || nextSize > MAX_DISK) return data;
+      const tmp = `${cachePath}.${randomUUID()}.tmp`;
+      try {
+        await writeFile2(quotaPath, String(nextSize), { mode: 384 });
+        await writeFile2(tmp, payload, { mode: 384 });
+        await rename5(tmp, cachePath);
+      } finally {
+        await unlink4(tmp).catch(() => {
+        });
+      }
+    }
+  } finally {
+    await release();
+  }
+  return data;
 }
 
 // src/parser.ts
+init_resource_budget();
+init_fs_utils();
 init_models();
+import { readdir as readdir10, stat as stat13 } from "fs/promises";
+import { basename as basename8, join as join19 } from "path";
+
+// src/providers/index.ts
+init_resource_budget();
 
 // src/providers/claude.ts
-import { readdir as readdir2, stat as stat4 } from "fs/promises";
-import { basename as basename2, join as join7 } from "path";
+import { readdir as readdir4, stat as stat5 } from "fs/promises";
+import { basename as basename2, join as join9 } from "path";
 import { homedir as homedir4 } from "os";
 var shortNames = {
   "claude-opus-4-7": "Opus 4.7",
@@ -2471,31 +3164,31 @@ var shortNames = {
   "claude-3-5-haiku": "Haiku 3.5"
 };
 function getClaudeDir() {
-  return process.env["CLAUDE_CONFIG_DIR"] || join7(homedir4(), ".claude");
+  return process.env["CLAUDE_CONFIG_DIR"] || join9(homedir4(), ".claude");
 }
 function getProjectsDir() {
-  return join7(getClaudeDir(), "projects");
+  return join9(getClaudeDir(), "projects");
 }
 function getDesktopSessionsDir() {
-  if (process.platform === "darwin") return join7(homedir4(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
-  if (process.platform === "win32") return join7(homedir4(), "AppData", "Roaming", "Claude", "local-agent-mode-sessions");
-  return join7(homedir4(), ".config", "Claude", "local-agent-mode-sessions");
+  if (process.platform === "darwin") return join9(homedir4(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+  if (process.platform === "win32") return join9(homedir4(), "AppData", "Roaming", "Claude", "local-agent-mode-sessions");
+  return join9(homedir4(), ".config", "Claude", "local-agent-mode-sessions");
 }
 async function findDesktopProjectDirs(base) {
   const results = [];
   async function walk(dir, depth) {
     if (depth > 8) return;
-    const entries = await readdir2(dir).catch(() => []);
+    const entries = await readdir4(dir).catch(() => []);
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join7(dir, entry);
-      const s = await stat4(full).catch(() => null);
+      const full = join9(dir, entry);
+      const s = await stat5(full).catch(() => null);
       if (!s?.isDirectory()) continue;
       if (entry === "projects") {
-        const projectDirs = await readdir2(full).catch(() => []);
+        const projectDirs = await readdir4(full).catch(() => []);
         for (const pd of projectDirs) {
-          const pdFull = join7(full, pd);
-          const pdStat = await stat4(pdFull).catch(() => null);
+          const pdFull = join9(full, pd);
+          const pdStat = await stat5(pdFull).catch(() => null);
           if (pdStat?.isDirectory()) results.push(pdFull);
         }
       } else {
@@ -2523,10 +3216,10 @@ var claude = {
     const sources = [];
     const projectsDir = getProjectsDir();
     try {
-      const entries = await readdir2(projectsDir);
+      const entries = await readdir4(projectsDir);
       for (const dirName of entries) {
-        const dirPath = join7(projectsDir, dirName);
-        const dirStat = await stat4(dirPath).catch(() => null);
+        const dirPath = join9(projectsDir, dirName);
+        const dirStat = await stat5(dirPath).catch(() => null);
         if (dirStat?.isDirectory()) {
           sources.push({ path: dirPath, project: dirName, provider: "claude" });
         }
@@ -2548,9 +3241,131 @@ var claude = {
 };
 
 // src/providers/codex.ts
-import { readdir as readdir3, stat as stat5 } from "fs/promises";
-import { basename as basename3, join as join8 } from "path";
+import { readdir as readdir5, stat as stat7 } from "fs/promises";
+import { basename as basename3, join as join11 } from "path";
 import { homedir as homedir5 } from "os";
+
+// src/discovery-cache.ts
+init_cache_dir();
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir8, readFile as readFile7, rename as rename6, stat as stat6, unlink as unlink5, writeFile as writeFile3 } from "fs/promises";
+import { join as join10 } from "path";
+init_resource_budget();
+var VERSION2 = 1;
+var MANIFEST = "discovery-index.json";
+var MAX_MANIFEST_BYTES = 16 * 1024 * 1024;
+var MAX_ENTRIES = 2e4;
+var MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var TOUCH_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var loaded = null;
+var loadedFrom = "";
+var dirty = false;
+function manifestPath() {
+  return join10(getCacheDir(), MANIFEST);
+}
+function fingerprintOf(s) {
+  return [s.dev, s.ino, s.size, s.mtimeMs, s.ctimeMs].join(":");
+}
+function emptyManifest() {
+  return { v: VERSION2, e: /* @__PURE__ */ Object.create(null) };
+}
+function sanitize(raw) {
+  if (!raw || typeof raw !== "object") return emptyManifest();
+  const parsed = raw;
+  if (parsed.v !== VERSION2 || !parsed.e || typeof parsed.e !== "object") return emptyManifest();
+  const out = emptyManifest();
+  for (const [key, value] of Object.entries(parsed.e)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (!value || typeof value !== "object") continue;
+    const entry = value;
+    if (typeof entry.f !== "string" || typeof entry.t !== "number") continue;
+    out.e[key] = { f: entry.f, r: entry.r ?? null, t: entry.t };
+  }
+  return out;
+}
+async function load() {
+  const path = manifestPath();
+  if (loaded && loadedFrom === path) return loaded;
+  loaded = emptyManifest();
+  loadedFrom = path;
+  dirty = false;
+  try {
+    const s = await stat6(path);
+    if (s.size > MAX_MANIFEST_BYTES) return loaded;
+    chargeRead(s.size);
+    loaded = sanitize(JSON.parse(await readFile7(path, "utf8")));
+  } catch (err) {
+    if (err instanceof ResourceBudgetError) throw err;
+  }
+  return loaded;
+}
+function evict(manifest) {
+  const cutoff = Date.now() - MAX_AGE_MS;
+  for (const [key, entry] of Object.entries(manifest.e)) {
+    if (entry.t < cutoff) delete manifest.e[key];
+  }
+  const keys = Object.keys(manifest.e);
+  if (keys.length <= MAX_ENTRIES) return;
+  keys.sort((a, b) => manifest.e[a].t - manifest.e[b].t);
+  for (const key of keys.slice(0, keys.length - MAX_ENTRIES)) delete manifest.e[key];
+}
+async function cachedDiscoveryHeader(kind, path, stats, compute) {
+  const manifest = await load();
+  const key = `${kind}\0${path}`;
+  const fingerprint2 = fingerprintOf(stats);
+  const hit = manifest.e[key];
+  if (hit && hit.f === fingerprint2) {
+    const now = Date.now();
+    if (now - hit.t > TOUCH_INTERVAL_MS) {
+      hit.t = now;
+      dirty = true;
+    }
+    return hit.r;
+  }
+  const value = await compute();
+  const after = await stat6(path).catch(() => null);
+  if (!after || fingerprintOf(after) !== fingerprint2) return value;
+  manifest.e[key] = { f: fingerprint2, r: value ?? null, t: Date.now() };
+  dirty = true;
+  return value;
+}
+async function flushDiscoveryCache() {
+  if (!dirty || !loaded) return;
+  const mine = loaded;
+  dirty = false;
+  const path = manifestPath();
+  const dir = getCacheDir();
+  try {
+    await mkdir8(dir, { recursive: true });
+    const release = await acquireFileLock(join10(dir, "discovery-index.lock"));
+    try {
+      const onDisk = await readFile7(path, "utf8").then((raw) => sanitize(JSON.parse(raw))).catch(() => emptyManifest());
+      for (const [key, entry] of Object.entries(mine.e)) {
+        const other = onDisk.e[key];
+        if (!other || other.t <= entry.t) onDisk.e[key] = entry;
+      }
+      evict(onDisk);
+      const payload = JSON.stringify(onDisk);
+      if (Buffer.byteLength(payload) > MAX_MANIFEST_BYTES) return;
+      const tmp = `${path}.${randomUUID2()}.tmp`;
+      try {
+        await writeFile3(tmp, payload, { mode: 384 });
+        await rename6(tmp, path);
+      } finally {
+        await unlink5(tmp).catch(() => {
+        });
+      }
+      loaded = onDisk;
+    } finally {
+      await release();
+    }
+  } catch {
+    dirty = true;
+  }
+}
+
+// src/providers/codex.ts
+init_fs_utils();
 init_models();
 var modelDisplayNames = {
   "gpt-5.5": "GPT-5.5",
@@ -2575,15 +3390,13 @@ var toolNameMap = {
   read_dir: "Glob"
 };
 function getCodexDir(override) {
-  return override ?? process.env["CODEX_HOME"] ?? join8(homedir5(), ".codex");
+  return override ?? process.env["CODEX_HOME"] ?? join11(homedir5(), ".codex");
 }
 function sanitizeProject(cwd) {
   return cwd.replace(/^\//, "").replace(/\//g, "-");
 }
 async function readFirstLine(filePath) {
-  const content = await readSessionFile(filePath);
-  if (content === null) return null;
-  const line = content.split("\n")[0];
+  const line = await readSessionFirstLine(filePath);
   if (!line?.trim()) return null;
   try {
     return JSON.parse(line);
@@ -2591,42 +3404,41 @@ async function readFirstLine(filePath) {
     return null;
   }
 }
-async function isValidCodexSession(filePath) {
+async function readCodexHeader(filePath) {
   const entry = await readFirstLine(filePath);
-  if (!entry) return { valid: false };
-  const valid = entry.type === "session_meta" && typeof entry.payload?.originator === "string" && entry.payload.originator.toLowerCase().startsWith("codex");
-  return { valid, meta: valid ? entry : void 0 };
+  const valid = entry?.type === "session_meta" && typeof entry.payload?.originator === "string" && entry.payload.originator.toLowerCase().startsWith("codex");
+  if (!valid) return null;
+  return { project: sanitizeProject(entry.payload?.cwd ?? "unknown") };
 }
 async function discoverSessionsInDir(codexDir) {
-  const sessionsDir = join8(codexDir, "sessions");
+  const sessionsDir = join11(codexDir, "sessions");
   const sources = [];
   let years;
   try {
-    years = await readdir3(sessionsDir);
+    years = await readdir5(sessionsDir);
   } catch {
     return sources;
   }
   for (const year of years) {
     if (!/^\d{4}$/.test(year)) continue;
-    const yearDir = join8(sessionsDir, year);
-    const months = await readdir3(yearDir).catch(() => []);
+    const yearDir = join11(sessionsDir, year);
+    const months = await readdir5(yearDir).catch(() => []);
     for (const month of months) {
       if (!/^\d{2}$/.test(month)) continue;
-      const monthDir = join8(yearDir, month);
-      const days = await readdir3(monthDir).catch(() => []);
+      const monthDir = join11(yearDir, month);
+      const days = await readdir5(monthDir).catch(() => []);
       for (const day of days) {
         if (!/^\d{2}$/.test(day)) continue;
-        const dayDir = join8(monthDir, day);
-        const files = await readdir3(dayDir).catch(() => []);
+        const dayDir = join11(monthDir, day);
+        const files = await readdir5(dayDir).catch(() => []);
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = join8(dayDir, file);
-          const s = await stat5(filePath).catch(() => null);
+          const filePath = join11(dayDir, file);
+          const s = await stat7(filePath).catch(() => null);
           if (!s?.isFile()) continue;
-          const { valid, meta } = await isValidCodexSession(filePath);
-          if (!valid || !meta) continue;
-          const cwd = meta.payload?.cwd ?? "unknown";
-          sources.push({ path: filePath, project: sanitizeProject(cwd), provider: "codex" });
+          const header = await cachedDiscoveryHeader("codex", filePath, s, () => readCodexHeader(filePath));
+          if (!header) continue;
+          sources.push({ path: filePath, project: header.project, provider: "codex" });
         }
       }
     }
@@ -2641,10 +3453,6 @@ function createParser(source, seenKeys) {
   return {
     warnings: parserWarnings,
     async *parse() {
-      const content = await readSessionFile(source.path);
-      if (content === null) return;
-      const lines = content.split("\n").filter((l) => l.trim());
-      if (lines.length === 0) return;
       let hasSessionMeta = false;
       let hasTokenCounts = false;
       let sessionModel;
@@ -2656,7 +3464,10 @@ function createParser(source, seenKeys) {
       let prevReasoning = 0;
       let pendingTools = [];
       let pendingUserMessage = "";
-      for (const line of lines) {
+      let lineCount = 0;
+      for await (const line of readSessionLines(source.path)) {
+        if (!line.trim()) continue;
+        lineCount++;
         let entry;
         try {
           entry = JSON.parse(line);
@@ -2760,10 +3571,10 @@ function createParser(source, seenKeys) {
           pendingUserMessage = "";
         }
       }
-      if (lines.length > 5 && !hasSessionMeta) {
+      if (lineCount > 5 && !hasSessionMeta) {
         parserWarnings.push(`Codex session file format may have changed \u2014 missing session_meta (${basename3(source.path)})`);
       }
-      if (lines.length > 5 && hasSessionMeta && !hasTokenCounts) {
+      if (lineCount > 5 && hasSessionMeta && !hasTokenCounts) {
         parserWarnings.push(`Codex session file format may have changed \u2014 no token_count events found (${basename3(source.path)})`);
       }
     }
@@ -2784,7 +3595,11 @@ function createCodexProvider(codexDir) {
       return toolNameMap[rawTool] ?? rawTool;
     },
     async discoverSessions() {
-      return discoverSessionsInDir(dir);
+      try {
+        return await discoverSessionsInDir(dir);
+      } finally {
+        await flushDiscoveryCache();
+      }
     },
     createSessionParser(source, seenKeys) {
       return createParser(source, seenKeys);
@@ -2794,10 +3609,11 @@ function createCodexProvider(codexDir) {
 var codex = createCodexProvider();
 
 // src/providers/copilot.ts
-import { readdir as readdir4, stat as stat6 } from "fs/promises";
-import { basename as basename4, dirname as dirname2, join as join9 } from "path";
-import { homedir as homedir6 } from "os";
+init_fs_utils();
 init_models();
+import { readdir as readdir6, stat as stat8 } from "fs/promises";
+import { basename as basename4, dirname as dirname3, join as join12 } from "path";
+import { homedir as homedir6 } from "os";
 var modelDisplayNames2 = {
   "gpt-4.1-nano": "GPT-4.1 Nano",
   "gpt-4.1-mini": "GPT-4.1 Mini",
@@ -2829,7 +3645,7 @@ var toolNameMap2 = {
 };
 var modelDisplayEntries2 = Object.entries(modelDisplayNames2).sort((a, b) => b[0].length - a[0].length);
 function getCopilotSessionStateDir(override) {
-  return override ?? join9(homedir6(), ".copilot", "session-state");
+  return override ?? join12(homedir6(), ".copilot", "session-state");
 }
 function parseCwd(yaml) {
   const match = yaml.match(/^cwd:\s*(.+)$/m);
@@ -2840,13 +3656,13 @@ function parseCwd(yaml) {
 function createParser2(source, seenKeys) {
   return {
     async *parse() {
-      const content = await readSessionFile(source.path);
-      if (content === null) return;
-      const sessionId = basename4(dirname2(source.path));
-      const lines = content.split("\n").filter((l) => l.trim());
+      const sessionId = basename4(dirname3(source.path));
       let currentModel = "";
       let pendingUserMessage = "";
-      for (const line of lines) {
+      let lineCount = 0;
+      for await (const line of readSessionLines(source.path)) {
+        if (!line.trim()) continue;
+        lineCount++;
         let event;
         try {
           event = JSON.parse(line);
@@ -2899,16 +3715,16 @@ async function discoverSessionsInDir2(sessionStateDir) {
   const sources = [];
   let sessionDirs;
   try {
-    sessionDirs = await readdir4(sessionStateDir);
+    sessionDirs = await readdir6(sessionStateDir);
   } catch {
     return sources;
   }
   for (const sessionId of sessionDirs) {
-    const eventsPath = join9(sessionStateDir, sessionId, "events.jsonl");
-    const s = await stat6(eventsPath).catch(() => null);
+    const eventsPath = join12(sessionStateDir, sessionId, "events.jsonl");
+    const s = await stat8(eventsPath).catch(() => null);
     if (!s?.isFile()) continue;
     let project = sessionId;
-    const yaml = await readSessionFile(join9(sessionStateDir, sessionId, "workspace.yaml"));
+    const yaml = await readSessionFile(join12(sessionStateDir, sessionId, "workspace.yaml"));
     if (yaml !== null) {
       const cwd = parseCwd(yaml);
       if (cwd) project = basename4(cwd);
@@ -2942,11 +3758,12 @@ function createCopilotProvider(sessionStateDir) {
 var copilot = createCopilotProvider();
 
 // src/providers/pi.ts
-import { readdir as readdir5, stat as stat7 } from "fs/promises";
-import { basename as basename6, join as join10 } from "path";
-import { homedir as homedir7 } from "os";
+init_fs_utils();
 init_models();
 init_bash_utils();
+import { readdir as readdir7, stat as stat9 } from "fs/promises";
+import { basename as basename6, join as join13 } from "path";
+import { homedir as homedir7 } from "os";
 var modelDisplayNames3 = {
   "gpt-5.4": "GPT-5.4",
   "gpt-5.4-mini": "GPT-5.4 Mini",
@@ -2970,15 +3787,13 @@ var toolNameMap3 = {
 };
 var modelDisplayEntries3 = Object.entries(modelDisplayNames3).sort((a, b) => b[0].length - a[0].length);
 function getPiSessionsDir(override) {
-  return override ?? join10(homedir7(), ".pi", "agent", "sessions");
+  return override ?? join13(homedir7(), ".pi", "agent", "sessions");
 }
 function getOmpSessionsDir(override) {
-  return override ?? join10(homedir7(), ".omp", "agent", "sessions");
+  return override ?? join13(homedir7(), ".omp", "agent", "sessions");
 }
 async function readFirstEntry(filePath) {
-  const content = await readSessionFile(filePath);
-  if (content === null) return null;
-  const line = content.split("\n")[0];
+  const line = await readSessionFirstLine(filePath);
   if (!line?.trim()) return null;
   try {
     return JSON.parse(line);
@@ -2990,24 +3805,24 @@ async function discoverSessionsInDir3(sessionsDir, providerName) {
   const sources = [];
   let projectDirs;
   try {
-    projectDirs = await readdir5(sessionsDir);
+    projectDirs = await readdir7(sessionsDir);
   } catch {
     return sources;
   }
   for (const dirName of projectDirs) {
-    const dirPath = join10(sessionsDir, dirName);
-    const dirStat = await stat7(dirPath).catch(() => null);
+    const dirPath = join13(sessionsDir, dirName);
+    const dirStat = await stat9(dirPath).catch(() => null);
     if (!dirStat?.isDirectory()) continue;
     let files;
     try {
-      files = await readdir5(dirPath);
+      files = await readdir7(dirPath);
     } catch {
       continue;
     }
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = join10(dirPath, file);
-      const fileStat = await stat7(filePath).catch(() => null);
+      const filePath = join13(dirPath, file);
+      const fileStat = await stat9(filePath).catch(() => null);
       if (!fileStat?.isFile()) continue;
       const first = await readFirstEntry(filePath);
       if (!first || first.type !== "session") continue;
@@ -3020,12 +3835,12 @@ async function discoverSessionsInDir3(sessionsDir, providerName) {
 function createParser3(source, seenKeys) {
   return {
     async *parse() {
-      const content = await readSessionFile(source.path);
-      if (content === null) return;
-      const lines = content.split("\n").filter((l) => l.trim());
       let sessionId = basename6(source.path, ".jsonl");
       let pendingUserMessage = "";
-      for (const [lineIdx, line] of lines.entries()) {
+      let lineIdx = -1;
+      for await (const line of readSessionLines(source.path)) {
+        if (!line.trim()) continue;
+        lineIdx++;
         let entry;
         try {
           entry = JSON.parse(line);
@@ -3184,40 +3999,22 @@ var _lastDiscoveryWarnings = [];
 function getDiscoveryWarnings() {
   return _lastDiscoveryWarnings;
 }
-var PROVIDER_TIMEOUT_MS = 5e3;
-function withTimeout(promise, ms, label) {
-  return Promise.race([
-    promise.then((result) => ({ result, warning: null })),
-    new Promise(
-      (resolve2) => setTimeout(() => resolve2({ result: null, warning: `Provider "${label}" timed out after ${ms}ms \u2014 skipped` }), ms)
-    )
-  ]);
-}
 async function discoverAllSessions(providerFilter) {
   _lastDiscoveryWarnings = [];
   const allProviders = await getAllProviders();
   const filtered = providerFilter && providerFilter !== "all" ? allProviders.filter((p) => p.name === providerFilter) : allProviders;
-  const results = await Promise.all(
-    filtered.map(async (provider) => {
-      try {
-        const { result, warning } = await withTimeout(
-          provider.discoverSessions(),
-          PROVIDER_TIMEOUT_MS,
-          provider.name
-        );
-        if (warning) {
-          _lastDiscoveryWarnings.push(warning);
-          return [];
-        }
-        return result ?? [];
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        _lastDiscoveryWarnings.push(`Provider "${provider.name}" discovery failed: ${msg}`);
-        return [];
-      }
-    })
-  );
-  return results.flat();
+  const results = [];
+  for (const provider of filtered) {
+    chargeRead(0);
+    try {
+      results.push(...await provider.discoverSessions());
+    } catch (err) {
+      if (err instanceof ResourceBudgetError) throw err;
+      const msg = err instanceof Error ? err.message : String(err);
+      _lastDiscoveryWarnings.push(`Provider "${provider.name}" discovery failed: ${msg}`);
+    }
+  }
+  return results;
 }
 async function getProvider(name) {
   if (name === "cursor") {
@@ -3242,11 +4039,35 @@ var BUILD_PATTERNS = /\b(npm\s+run\s+build|npm\s+publish|pip\s+install|docker|de
 var INSTALL_PATTERNS = /\b(npm\s+install|pip\s+install|brew\s+install|apt\s+install|cargo\s+add)\b/i;
 var DEBUG_KEYWORDS = /\b(fix|bug|error|broken|failing|crash|issue|debug|traceback|exception|stack\s*trace|not\s+working|wrong|unexpected|status\s+code|404|500|401|403)\b/i;
 var FEATURE_KEYWORDS = /\b(add|create|implement|new|build|feature|introduce|set\s*up|scaffold|generate|make\s+(?:a|me|the)|write\s+(?:a|me|the))\b/i;
+var REFACTOR_KEYWORDS = /\b(refactor|clean\s*up|rename|reorganize|simplify|extract|restructure|move|migrate|split)\b/i;
 var BRAINSTORM_KEYWORDS = /\b(brainstorm|idea|what\s+if|explore|think\s+about|approach|strategy|design|consider|how\s+should|what\s+would|opinion|suggest|recommend)\b/i;
 var RESEARCH_KEYWORDS = /\b(research|investigate|look\s+into|find\s+out|check|search|analyze|review|understand|explain|how\s+does|what\s+is|show\s+me|list|compare)\b/i;
 var FILE_PATTERNS = /\.(py|js|ts|tsx|jsx|json|yaml|yml|toml|sql|sh|go|rs|java|rb|php|css|html|md|csv|xml)\b/i;
 var SCRIPT_PATTERNS = /\b(run\s+\S+\.\w+|execute|scrip?t|curl|api\s+\S+|endpoint|request\s+url|fetch\s+\S+|query|database|db\s+\S+)\b/i;
 var URL_PATTERN = /https?:\/\/\S+/i;
+var MESSAGE_PATTERNS = [
+  TEST_PATTERNS,
+  GIT_PATTERNS,
+  BUILD_PATTERNS,
+  INSTALL_PATTERNS,
+  DEBUG_KEYWORDS,
+  FEATURE_KEYWORDS,
+  REFACTOR_KEYWORDS,
+  BRAINSTORM_KEYWORDS,
+  RESEARCH_KEYWORDS,
+  FILE_PATTERNS,
+  SCRIPT_PATTERNS,
+  URL_PATTERN
+];
+function compactUserMessage(text, signals) {
+  return {
+    userMessage: Buffer.from(text.slice(0, 512)).toString("utf8"),
+    userMessageSignals: signals ?? MESSAGE_PATTERNS.reduce((mask, pattern, index) => mask | (pattern.test(text) ? 1 << index : 0), 0)
+  };
+}
+function messageMatches(turn, pattern) {
+  return turn.userMessageSignals === void 0 ? pattern.test(turn.userMessage) : (turn.userMessageSignals & 1 << MESSAGE_PATTERNS.indexOf(pattern)) !== 0;
+}
 var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "FileEditTool", "FileWriteTool", "NotebookEdit", "cursor:edit"]);
 var READ_TOOLS = /* @__PURE__ */ new Set(["Read", "Grep", "Glob", "FileReadTool", "GrepTool", "GlobTool"]);
 var BASH_TOOLS = /* @__PURE__ */ new Set(["Bash", "BashTool", "PowerShellTool"]);
@@ -3289,11 +4110,10 @@ function classifyByToolPattern(turn) {
   const hasMcp = hasMcpTools(tools);
   const hasSkill = hasSkillTool(tools);
   if (hasBash && !hasEdits) {
-    const userMsg = turn.userMessage;
-    if (TEST_PATTERNS.test(userMsg)) return "testing";
-    if (GIT_PATTERNS.test(userMsg)) return "devops";
-    if (BUILD_PATTERNS.test(userMsg)) return "devops";
-    if (INSTALL_PATTERNS.test(userMsg)) return "devops";
+    if (messageMatches(turn, TEST_PATTERNS)) return "testing";
+    if (messageMatches(turn, GIT_PATTERNS)) return "devops";
+    if (messageMatches(turn, BUILD_PATTERNS)) return "devops";
+    if (messageMatches(turn, INSTALL_PATTERNS)) return "devops";
   }
   if (hasEdits) return "building";
   if (hasBash && hasReads) return "research";
@@ -3304,25 +4124,25 @@ function classifyByToolPattern(turn) {
   if (hasSkill) return "building";
   return null;
 }
-function refineByKeywords(category, userMessage) {
+function refineByKeywords(category, turn) {
   if (category === "building") {
-    if (DEBUG_KEYWORDS.test(userMessage)) return "debugging";
+    if (messageMatches(turn, DEBUG_KEYWORDS)) return "debugging";
     return "building";
   }
   if (category === "research") {
-    if (DEBUG_KEYWORDS.test(userMessage)) return "debugging";
+    if (messageMatches(turn, DEBUG_KEYWORDS)) return "debugging";
     return "research";
   }
   return category;
 }
-function classifyConversation(userMessage) {
-  if (BRAINSTORM_KEYWORDS.test(userMessage)) return "research";
-  if (RESEARCH_KEYWORDS.test(userMessage)) return "research";
-  if (DEBUG_KEYWORDS.test(userMessage)) return "debugging";
-  if (FEATURE_KEYWORDS.test(userMessage)) return "building";
-  if (FILE_PATTERNS.test(userMessage)) return "building";
-  if (SCRIPT_PATTERNS.test(userMessage)) return "building";
-  if (URL_PATTERN.test(userMessage)) return "research";
+function classifyConversation(turn) {
+  if (messageMatches(turn, BRAINSTORM_KEYWORDS)) return "research";
+  if (messageMatches(turn, RESEARCH_KEYWORDS)) return "research";
+  if (messageMatches(turn, DEBUG_KEYWORDS)) return "debugging";
+  if (messageMatches(turn, FEATURE_KEYWORDS)) return "building";
+  if (messageMatches(turn, FILE_PATTERNS)) return "building";
+  if (messageMatches(turn, SCRIPT_PATTERNS)) return "building";
+  if (messageMatches(turn, URL_PATTERN)) return "research";
   return "research";
 }
 function countRetries(turn) {
@@ -3350,13 +4170,13 @@ function classifyTurn(turn) {
   const tools = getAllTools(turn);
   let category;
   if (tools.length === 0) {
-    category = classifyConversation(turn.userMessage);
+    category = classifyConversation(turn);
   } else {
     const toolCategory = classifyByToolPattern(turn);
     if (toolCategory) {
-      category = refineByKeywords(toolCategory, turn.userMessage);
+      category = refineByKeywords(toolCategory, turn);
     } else {
-      category = classifyConversation(turn.userMessage);
+      category = classifyConversation(turn);
     }
   }
   return { ...turn, category, retries: countRetries(turn), hasEdits: turnHasEdits(turn) };
@@ -3364,10 +4184,10 @@ function classifyTurn(turn) {
 
 // src/session-index.ts
 init_cache_dir();
-import { stat as stat10 } from "fs/promises";
+import { stat as stat12 } from "fs/promises";
 import { existsSync as existsSync3, unlinkSync } from "fs";
-import { readFile as readFile7, mkdir as mkdir7, rename as rename6, unlink as unlink3, open as open5 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile10, mkdir as mkdir10, rename as rename8, unlink as unlink6, open as open7 } from "fs/promises";
+import { join as join18 } from "path";
 import { randomBytes as randomBytes5 } from "crypto";
 var SESSION_INDEX_VERSION = 1;
 var INDEX_FILENAME = "session-index.json";
@@ -3376,12 +4196,12 @@ function emptyIndex() {
   return { v: SESSION_INDEX_VERSION, e: {} };
 }
 function indexPath() {
-  return join15(getCacheDir(), INDEX_FILENAME);
+  return join18(getCacheDir(), INDEX_FILENAME);
 }
 async function loadSessionIndex() {
   if (currentIndex) return currentIndex;
   try {
-    const raw = await readFile7(indexPath(), "utf-8");
+    const raw = await readFile10(indexPath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.v !== SESSION_INDEX_VERSION) {
       currentIndex = emptyIndex();
@@ -3396,11 +4216,11 @@ async function loadSessionIndex() {
 }
 async function saveSessionIndex(index) {
   const dir = getCacheDir();
-  if (!existsSync3(dir)) await mkdir7(dir, { recursive: true });
+  if (!existsSync3(dir)) await mkdir10(dir, { recursive: true });
   const finalPath = indexPath();
   const tempPath = `${finalPath}.${randomBytes5(8).toString("hex")}.tmp`;
   const payload = JSON.stringify(index);
-  const handle = await open5(tempPath, "w", 384);
+  const handle = await open7(tempPath, "w", 384);
   try {
     await handle.writeFile(payload, { encoding: "utf-8" });
     await handle.sync();
@@ -3408,10 +4228,10 @@ async function saveSessionIndex(index) {
     await handle.close();
   }
   try {
-    await rename6(tempPath, finalPath);
+    await rename8(tempPath, finalPath);
   } catch (err) {
     try {
-      await unlink3(tempPath);
+      await unlink6(tempPath);
     } catch {
     }
     throw err;
@@ -3423,7 +4243,7 @@ async function checkSessionFile(filePath, index, dateRange) {
   if (!entry) return "parse";
   let fileStat;
   try {
-    fileStat = await stat10(filePath);
+    fileStat = await stat12(filePath);
   } catch {
     return "parse";
   }
@@ -3434,7 +4254,9 @@ async function checkSessionFile(filePath, index, dateRange) {
 function recordParseResult(filePath, index, sizeBytes, mtimeMs, hasApiCalls) {
   const prev = index.e[filePath];
   const h = hasApiCalls ? 1 : prev?.h === 1 ? 1 : 0;
+  if (prev?.s === sizeBytes && prev?.m === mtimeMs && prev?.h === h) return false;
   index.e[filePath] = { s: sizeBytes, m: mtimeMs, h };
+  return true;
 }
 function pruneIndex(index, knownPaths) {
   let pruned = 0;
@@ -3449,6 +4271,7 @@ function pruneIndex(index, knownPaths) {
 
 // src/parser.ts
 init_bash_utils();
+var reportMode = new AsyncLocalStorage2();
 var _parseWarnings = [];
 function getParseWarnings() {
   return _parseWarnings;
@@ -3532,25 +4355,34 @@ function parseApiCall(entry) {
     deduplicationKey: msg.id ?? `claude:${entry.timestamp}`
   };
 }
-function groupIntoTurns(entries, seenMsgIds) {
+async function parseTurns(filePath) {
+  const seenMsgIds = /* @__PURE__ */ new Set();
   const turns = [];
   let currentUserMessage = "";
+  let currentUserSignals = 0;
   let currentCalls = [];
   let currentTimestamp = "";
   let currentSessionId = "";
-  for (const entry of entries) {
+  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
           });
         }
-        currentUserMessage = text;
+        const compact = compactUserMessage(text);
+        currentUserMessage = compact.userMessage;
+        currentUserSignals = compact.userMessageSignals;
         currentCalls = [];
         currentTimestamp = entry.timestamp ?? "";
         currentSessionId = entry.sessionId ?? "";
@@ -3560,12 +4392,17 @@ function groupIntoTurns(entries, seenMsgIds) {
       if (msgId && seenMsgIds.has(msgId)) continue;
       if (msgId) seenMsgIds.add(msgId);
       const call = parseApiCall(entry);
-      if (call) currentCalls.push(call);
+      if (call) {
+        if (!msgId) call.deduplicationKey = `${filePath}:${lineNumber}`;
+        chargeRecord();
+        currentCalls.push(call);
+      }
     }
   }
   if (currentCalls.length > 0) {
     turns.push({
       userMessage: currentUserMessage,
+      userMessageSignals: currentUserSignals,
       assistantCalls: currentCalls,
       timestamp: currentTimestamp,
       sessionId: currentSessionId
@@ -3637,7 +4474,7 @@ function buildSessionSummary(sessionId, project, turns) {
       if (!lastTs || call.timestamp > lastTs) lastTs = call.timestamp;
     }
   }
-  return {
+  const summary = {
     sessionId,
     project,
     firstTimestamp: firstTs || turns[0]?.timestamp || "",
@@ -3655,26 +4492,28 @@ function buildSessionSummary(sessionId, project, turns) {
     bashBreakdown,
     categoryBreakdown
   };
+  return reportMode.getStore() ? compactReportSession(summary) : summary;
 }
 async function parseSessionFile(filePath, project, seenMsgIds, dateRange) {
   if (dateRange) {
     try {
-      const s = await stat11(filePath);
+      const s = await stat13(filePath);
       if (s.mtimeMs < dateRange.start.getTime()) return null;
     } catch {
     }
   }
-  const entries = [];
-  let hasLines = false;
-  for await (const line of readSessionLines(filePath)) {
-    hasLines = true;
-    const entry = parseJsonlLine(line);
-    if (entry) entries.push(entry);
-  }
-  if (!hasLines) return null;
-  if (entries.length === 0) return null;
+  const rawTurns = await cachedFileParse(filePath, "claude-turns", () => parseTurns(filePath));
   const sessionId = basename8(filePath, ".jsonl");
-  let turns = groupIntoTurns(entries, seenMsgIds);
+  let turns = [];
+  for (const turn of rawTurns) {
+    const calls = turn.assistantCalls.filter((call) => {
+      chargeRecord();
+      if (seenMsgIds.has(call.deduplicationKey)) return false;
+      seenMsgIds.add(call.deduplicationKey);
+      return true;
+    });
+    if (calls.length) turns.push({ ...turn, ...compactUserMessage(turn.userMessage, turn.userMessageSignals), assistantCalls: calls });
+  }
   if (dateRange) {
     turns = turns.filter((turn) => {
       if (turn.assistantCalls.length === 0) return false;
@@ -3688,15 +4527,15 @@ async function parseSessionFile(filePath, project, seenMsgIds, dateRange) {
   const classified = turns.map(classifyTurn);
   return buildSessionSummary(sessionId, project, classified);
 }
-async function collectJsonlFiles(dirPath) {
-  const files = await readdir8(dirPath).catch(() => []);
-  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).map((f) => join16(dirPath, f));
+async function collectJsonlFiles2(dirPath) {
+  const files = await readdir10(dirPath).catch(() => []);
+  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).map((f) => join19(dirPath, f));
   for (const entry of files) {
     if (entry.endsWith(".jsonl")) continue;
-    const subagentsPath = join16(dirPath, entry, "subagents");
-    const subFiles = await readdir8(subagentsPath).catch(() => []);
+    const subagentsPath = join19(dirPath, entry, "subagents");
+    const subFiles = await readdir10(subagentsPath).catch(() => []);
     for (const sf of subFiles) {
-      if (sf.endsWith(".jsonl")) jsonlFiles.push(join16(subagentsPath, sf));
+      if (sf.endsWith(".jsonl")) jsonlFiles.push(join19(subagentsPath, sf));
     }
   }
   return jsonlFiles;
@@ -3707,14 +4546,14 @@ async function scanProjectDirs(dirs, seenMsgIds, dateRange) {
   let indexDirty = false;
   const allJsonlPaths = /* @__PURE__ */ new Set();
   for (const { path: dirPath, name: dirName } of dirs) {
-    const jsonlFiles = await collectJsonlFiles(dirPath);
+    const jsonlFiles = await collectJsonlFiles2(dirPath);
     for (const f of jsonlFiles) allJsonlPaths.add(f);
     for (const filePath of jsonlFiles) {
       const action = await checkSessionFile(filePath, sessionIndex, dateRange);
       if (action === "skip") continue;
       let preStat = null;
       try {
-        const s = await stat11(filePath);
+        const s = await stat13(filePath);
         preStat = { size: s.size, mtimeMs: s.mtimeMs };
       } catch {
       }
@@ -3722,10 +4561,9 @@ async function scanProjectDirs(dirs, seenMsgIds, dateRange) {
       const hasApiCalls = session !== null && session.apiCalls > 0;
       if (preStat && (hasApiCalls || !dateRange)) {
         try {
-          const postStat = await stat11(filePath);
+          const postStat = await stat13(filePath);
           if (postStat.size === preStat.size && postStat.mtimeMs === preStat.mtimeMs) {
-            recordParseResult(filePath, sessionIndex, preStat.size, preStat.mtimeMs, hasApiCalls);
-            indexDirty = true;
+            indexDirty = recordParseResult(filePath, sessionIndex, preStat.size, preStat.mtimeMs, hasApiCalls) || indexDirty;
           }
         } catch {
         }
@@ -3777,7 +4615,7 @@ function providerCallToTurn(call) {
     deduplicationKey: call.deduplicationKey
   };
   return {
-    userMessage: call.userMessage,
+    ...compactUserMessage(call.userMessage, call.userMessageSignals),
     assistantCalls: [apiCall],
     timestamp: call.timestamp,
     sessionId: call.sessionId
@@ -3787,19 +4625,36 @@ async function parseProviderSources(providerName, sources, seenKeys, dateRange)
   const provider = await getProvider(providerName);
   if (!provider) return [];
   const sessionMap = /* @__PURE__ */ new Map();
+  const compactSessions = /* @__PURE__ */ new Map();
   for (const source of sources) {
     if (dateRange) {
       try {
-        const s = await stat11(source.path);
-        if (s.mtimeMs < dateRange.start.getTime()) continue;
+        const s = await stat13(source.path);
+        const wal = await stat13(`${source.path}-wal`).catch(() => null);
+        if (Math.max(s.mtimeMs, wal?.mtimeMs ?? 0) < dateRange.start.getTime()) continue;
       } catch {
       }
     }
-    const parser = provider.createSessionParser(
-      { path: source.path, project: source.project, provider: providerName },
-      seenKeys
-    );
-    for await (const call of parser.parse()) {
+    const warnings = [];
+    const calls = await cachedFileParse(source.path, providerName, async () => {
+      const parser = provider.createSessionParser(
+        { path: source.path, project: source.project, provider: providerName },
+        /* @__PURE__ */ new Set()
+      );
+      const result = [];
+      for await (const call of parser.parse()) {
+        chargeRecord();
+        result.push({ ...call, ...compactUserMessage(call.userMessage, call.userMessageSignals) });
+      }
+      if (parser.warnings?.length) warnings.push(...parser.warnings);
+      return result;
+    }, warnings);
+    _parseWarnings.push(...warnings);
+    const touched = /* @__PURE__ */ new Set();
+    for (const call of calls) {
+      chargeRecord();
+      if (seenKeys.has(call.deduplicationKey)) continue;
+      seenKeys.add(call.deduplicationKey);
       if (dateRange) {
         if (!call.timestamp) continue;
         const ts = new Date(call.timestamp);
@@ -3808,6 +4663,7 @@ async function parseProviderSources(providerName, sources, seenKeys, dateRange)
       const turn = providerCallToTurn(call);
       const classified = classifyTurn(turn);
       const key = `${providerName}:${call.sessionId}:${source.project}`;
+      touched.add(key);
       const existing = sessionMap.get(key);
       if (existing) {
         existing.turns.push(classified);
@@ -3815,11 +4671,23 @@ async function parseProviderSources(providerName, sources, seenKeys, dateRange)
         sessionMap.set(key, { project: source.project, turns: [classified] });
       }
     }
-    if (parser.warnings && parser.warnings.length > 0) {
-      _parseWarnings.push(...parser.warnings);
+    if (reportMode.getStore()) {
+      for (const key of touched) {
+        const entry = sessionMap.get(key);
+        const summary = buildSessionSummary(key.split(":")[1] ?? key, entry.project, entry.turns);
+        const previous = compactSessions.get(key);
+        if (previous) mergeReportSession(previous, summary);
+        else compactSessions.set(key, summary);
+        sessionMap.delete(key);
+      }
     }
   }
   const projectMap = /* @__PURE__ */ new Map();
+  for (const summary of compactSessions.values()) {
+    const existing = projectMap.get(summary.project) ?? [];
+    existing.push(summary);
+    projectMap.set(summary.project, existing);
+  }
   for (const [key, { project, turns }] of sessionMap) {
     const sessionId = key.split(":")[1] ?? key;
     const session = buildSessionSummary(sessionId, project, turns);
@@ -3842,7 +4710,7 @@ async function parseProviderSources(providerName, sources, seenKeys, dateRange)
   return projects;
 }
 var CACHE_TTL_MS3 = 6e4;
-var MAX_CACHE_ENTRIES = 10;
+var MAX_CACHE_ENTRIES = 1;
 var sessionCache = /* @__PURE__ */ new Map();
 var inFlightSourceContexts = /* @__PURE__ */ new Map();
 var SOURCE_CONTEXT_TTL_MS = 5e3;
@@ -3881,8 +4749,8 @@ async function getSourceContext(providerFilter) {
   }
   const promise = (async () => {
     const sources = await discoverAllSessions(providerFilter);
-    const fingerprint = buildCacheFingerprint(sources);
-    return { sources, fingerprint };
+    const fingerprint2 = buildCacheFingerprint(sources);
+    return { sources, fingerprint: fingerprint2 };
   })();
   inFlightSourceContexts.set(key, promise);
   try {
@@ -3924,13 +4792,17 @@ function filterProjectsByName(projects, include, exclude) {
   }
   return result;
 }
-async function parseAllSessions(dateRange, providerFilter) {
+async function parseAllSessions(dateRange, providerFilter, summaryOnly = false, signal) {
+  return reportMode.run(summaryOnly, () => withScanBudget(() => parseAllSessionsWithinBudget(dateRange, providerFilter), summaryOnly ? 2e6 : 2e5, signal, (summaryOnly ? 8 : 1) * 1024 ** 3));
+}
+async function parseAllSessionsWithinBudget(dateRange, providerFilter) {
   _parseWarnings = [];
   const sourceContext = await getSourceContext(providerFilter);
   const allSources = sourceContext.sources;
-  const key = cacheKey(dateRange, providerFilter, sourceContext.fingerprint);
+  const key = `${reportMode.getStore() ? "summary" : "full"}:${cacheKey(dateRange, providerFilter, sourceContext.fingerprint)}`;
   const cached = sessionCache.get(key);
   if (cached && Date.now() - cached.ts < CACHE_TTL_MS3) return cached.data;
+  sessionCache.clear();
   const seenMsgIds = /* @__PURE__ */ new Set();
   const seenKeys = /* @__PURE__ */ new Set();
   const claudeSources = allSources.filter((s) => s.provider === "claude");
@@ -3963,6 +4835,9 @@ async function parseAllSessions(dateRange, providerFilter) {
   cachePut(key, result);
   return result;
 }
+function getDiscoveredProviderNames() {
+  return [...new Set([...resolvedSourceContexts.values()].flatMap((c) => c.result.sources.map((s) => s.provider)))];
+}
 
 // src/format.ts
 import chalk from "chalk";
@@ -4009,14 +4884,14 @@ function renderStatusBar(projects) {
 }
 
 // src/menubar-json.ts
-import { readdirSync, readFileSync as readFileSync2 } from "fs";
-import { join as join17, dirname as dirname3 } from "path";
+import { readdirSync, readFileSync } from "fs";
+import { join as join20, dirname as dirname4 } from "path";
 init_models();
 import { fileURLToPath } from "url";
 function getCliVersion() {
   try {
-    const pkgPath = join17(dirname3(fileURLToPath(import.meta.url)), "..", "package.json");
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const pkgPath = join20(dirname4(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";
@@ -4168,18 +5043,18 @@ function buildMenubarPayload(current, providers, optimize, dailyHistory, agentSt
 
 // src/daily-cache.ts
 init_cache_dir();
-import { createHash as createHash3, randomBytes as randomBytes6 } from "crypto";
+import { createHash as createHash4, randomBytes as randomBytes6 } from "crypto";
 import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir8, open as open6, readFile as readFile8, rename as rename7, unlink as unlink4 } from "fs/promises";
-import { join as join18 } from "path";
+import { mkdir as mkdir11, open as open8, readFile as readFile11, rename as rename9, unlink as unlink7 } from "fs/promises";
+import { join as join21 } from "path";
 var DAILY_CACHE_VERSION = 6;
 var DEFAULT_DAILY_CACHE_SCOPE = "global";
 var DAILY_CACHE_FILENAME = "daily-cache.json";
 function getCachePath3(scopeKey) {
   if (scopeKey === DEFAULT_DAILY_CACHE_SCOPE) {
-    return join18(getCacheDir(), DAILY_CACHE_FILENAME);
+    return join21(getCacheDir(), DAILY_CACHE_FILENAME);
   }
-  return join18(getCacheDir(), `daily-cache-${scopeKey}.json`);
+  return join21(getCacheDir(), `daily-cache-${scopeKey}.json`);
 }
 function emptyCache(scopeKey) {
   return { version: DAILY_CACHE_VERSION, scopeKey, lastComputedDate: null, days: [] };
@@ -4194,7 +5069,7 @@ function buildDailyCacheScopeKey(include, exclude) {
     return DEFAULT_DAILY_CACHE_SCOPE;
   }
   const raw = JSON.stringify({ include: normalizedInclude, exclude: normalizedExclude });
-  return `scope-${createHash3("sha1").update(raw).digest("hex").slice(0, 12)}`;
+  return `scope-${createHash4("sha1").update(raw).digest("hex").slice(0, 12)}`;
 }
 function isValidCache(parsed) {
   if (!parsed || typeof parsed !== "object") return false;
@@ -4208,7 +5083,7 @@ async function loadDailyCache(scopeKey = DEFAULT_DAILY_CACHE_SCOPE) {
   const path = getCachePath3(scopeKey);
   if (!existsSync4(path)) return emptyCache(scopeKey);
   try {
-    const raw = await readFile8(path, "utf-8");
+    const raw = await readFile11(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCache(parsed)) return emptyCache(scopeKey);
     if (parsed.scopeKey !== scopeKey) return emptyCache(scopeKey);
@@ -4219,12 +5094,13 @@ async function loadDailyCache(scopeKey = DEFAULT_DAILY_CACHE_SCOPE) {
 }
 async function saveDailyCache(cache) {
   const dir = getCacheDir();
-  if (!existsSync4(dir)) await mkdir8(dir, { recursive: true });
+  if (!existsSync4(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`;
   const payload = JSON.stringify({ ...cache, scopeKey });
-  const handle = await open6(tempPath, "w", 384);
+  if (await readFile11(finalPath, "utf8").catch(() => "") === payload) return;
+  const handle = await open8(tempPath, "w", 384);
   try {
     await handle.writeFile(payload, { encoding: "utf-8" });
     await handle.sync();
@@ -4232,10 +5108,10 @@ async function saveDailyCache(cache) {
     await handle.close();
   }
   try {
-    await rename7(tempPath, finalPath);
+    await rename9(tempPath, finalPath);
   } catch (err) {
     try {
-      await unlink4(tempPath);
+      await unlink7(tempPath);
     } catch {
     }
     throw err;
@@ -4253,7 +5129,10 @@ function addNewDays(cache, incoming, newestDate, options = {}) {
     version: DAILY_CACHE_VERSION,
     scopeKey: cache.scopeKey || DEFAULT_DAILY_CACHE_SCOPE,
     lastComputedDate: nextLast,
-    days: merged
+    days: merged,
+    revalidatedAt: cache.revalidatedAt,
+    backfill: cache.backfill,
+    partialDates: cache.partialDates
   };
 }
 function getDaysInRange(cache, start, end) {
@@ -4266,17 +5145,62 @@ function withDailyCacheLock(fn) {
   return next;
 }
 
+// src/latest-load.ts
+var LatestLoad = class {
+  tail = Promise.resolve();
+  generation = 0;
+  controller;
+  pending = 0;
+  get busy() {
+    return this.pending > 0;
+  }
+  cancel() {
+    this.generation++;
+    this.controller?.abort();
+  }
+  async run(load2) {
+    const generation = ++this.generation;
+    this.controller?.abort();
+    const previous = this.tail;
+    this.pending++;
+    const next = (async () => {
+      await previous.catch(() => {
+      });
+      if (generation !== this.generation) return void 0;
+      const controller = new AbortController();
+      this.controller = controller;
+      try {
+        const result = await load2(controller.signal);
+        return generation === this.generation ? result : void 0;
+      } catch (error) {
+        if (generation !== this.generation) return void 0;
+        throw error;
+      } finally {
+        if (this.controller === controller) this.controller = void 0;
+      }
+    })();
+    this.tail = next;
+    try {
+      return await next;
+    } finally {
+      this.pending--;
+    }
+  }
+};
+
 // src/dashboard.tsx
+init_resource_budget();
 import { homedir as homedir13 } from "os";
 import { useState as useState2, useCallback, useEffect as useEffect2, useRef as useRef2 } from "react";
 import { render as render2, Box as Box2, Text as Text2, useInput as useInput2, useApp as useApp2, useWindowSize } from "ink";
 init_models();
 
 // src/optimize.ts
+init_fs_utils();
 import chalk2 from "chalk";
-import { readdir as readdir9, stat as stat12 } from "fs/promises";
+import { readdir as readdir11, stat as stat14 } from "fs/promises";
 import { existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { basename as basename9, join as join19 } from "path";
+import { basename as basename9, join as join22 } from "path";
 import { homedir as homedir11 } from "os";
 var ORANGE = "#F59E0B";
 var DIM = "#666666";
@@ -4351,22 +5275,22 @@ var SHELL_PROFILES = [".zshrc", ".bashrc", ".bash_profile", ".profile"];
 var TOP_ITEMS_PREVIEW = 3;
 var GHOST_NAMES_PREVIEW = 5;
 var GHOST_CLEANUP_COMMANDS_LIMIT = 10;
-var FILE_READ_CONCURRENCY = 16;
+var FILE_READ_CONCURRENCY = 1;
 var RESULT_CACHE_TTL_MS = 6e4;
 var RECENT_WINDOW_HOURS = 48;
 var RECENT_WINDOW_MS = RECENT_WINDOW_HOURS * 60 * 60 * 1e3;
 var DEFAULT_TREND_PERIOD_DAYS = 30;
 var DEFAULT_TREND_PERIOD_MS = DEFAULT_TREND_PERIOD_DAYS * 24 * 60 * 60 * 1e3;
 var IMPROVING_THRESHOLD = 0.5;
-async function collectJsonlFiles2(dirPath) {
-  const files = await readdir9(dirPath).catch(() => []);
-  const result = files.filter((f) => f.endsWith(".jsonl")).map((f) => join19(dirPath, f));
+async function collectJsonlFiles3(dirPath) {
+  const files = await readdir11(dirPath).catch(() => []);
+  const result = files.filter((f) => f.endsWith(".jsonl")).map((f) => join22(dirPath, f));
   for (const entry of files) {
     if (entry.endsWith(".jsonl")) continue;
-    const subPath = join19(dirPath, entry, "subagents");
-    const subFiles = await readdir9(subPath).catch(() => []);
+    const subPath = join22(dirPath, entry, "subagents");
+    const subFiles = await readdir11(subPath).catch(() => []);
     for (const sf of subFiles) {
-      if (sf.endsWith(".jsonl")) result.push(join19(subPath, sf));
+      if (sf.endsWith(".jsonl")) result.push(join22(subPath, sf));
     }
   }
   return result;
@@ -4374,7 +5298,7 @@ async function collectJsonlFiles2(dirPath) {
 async function isFileStaleForRange(filePath, range) {
   if (!range) return false;
   try {
-    const s = await stat12(filePath);
+    const s = await stat14(filePath);
     return s.mtimeMs < range.start.getTime();
   } catch {
     return false;
@@ -4467,7 +5391,7 @@ async function scanSessions(dateRange) {
   const allUserMessages = [];
   const tasks = [];
   for (const source of sources) {
-    const files = await collectJsonlFiles2(source.path);
+    const files = await collectJsonlFiles3(source.path);
     for (const file of files) {
       if (await isFileStaleForRange(file, dateRange)) continue;
       tasks.push({ file, project: source.project });
@@ -4504,13 +5428,13 @@ function isReadTool(name) {
 function loadMcpConfigs(projectCwds) {
   const servers = /* @__PURE__ */ new Map();
   const configPaths = [
-    join19(homedir11(), ".claude", "settings.json"),
-    join19(homedir11(), ".claude", "settings.local.json")
+    join22(homedir11(), ".claude", "settings.json"),
+    join22(homedir11(), ".claude", "settings.local.json")
   ];
   for (const cwd of projectCwds) {
-    configPaths.push(join19(cwd, ".mcp.json"));
-    configPaths.push(join19(cwd, ".claude", "settings.json"));
-    configPaths.push(join19(cwd, ".claude", "settings.local.json"));
+    configPaths.push(join22(cwd, ".mcp.json"));
+    configPaths.push(join22(cwd, ".claude", "settings.json"));
+    configPaths.push(join22(cwd, ".claude", "settings.local.json"));
   }
   for (const p of configPaths) {
     if (!existsSync5(p)) continue;
@@ -4663,12 +5587,12 @@ function expandImports(filePath, seen, depth) {
   if (content === null) return { totalLines: 0, importedFiles: 0 };
   let totalLines = content.split("\n").length;
   let importedFiles = 0;
-  const dir = join19(filePath, "..");
+  const dir = join22(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 : join19(dir, rawPath);
+    const resolved = rawPath.startsWith("/") ? rawPath : join22(dir, rawPath);
     if (!existsSync5(resolved)) continue;
     const nested = expandImports(resolved, seen, depth + 1);
     totalLines += nested.totalLines;
@@ -4680,7 +5604,7 @@ function detectBloatedClaudeMd(projectCwds) {
   const bloated = [];
   for (const cwd of projectCwds) {
     for (const name of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-      const fullPath = join19(cwd, name);
+      const fullPath = join22(cwd, name);
       if (!existsSync5(fullPath)) continue;
       const { totalLines, importedFiles } = expandImports(fullPath, /* @__PURE__ */ new Set(), 0);
       if (totalLines > CLAUDEMD_HEALTHY_LINES) {
@@ -4811,7 +5735,7 @@ function detectCacheBloat(apiCalls, projects, dateRange) {
 async function listMarkdownFiles(dir) {
   if (!existsSync5(dir)) return [];
   try {
-    const entries = await readdir9(dir);
+    const entries = await readdir11(dir);
     return entries.filter((e) => e.endsWith(".md")).map((e) => e.replace(/\.md$/, ""));
   } catch {
     return [];
@@ -4820,10 +5744,10 @@ async function listMarkdownFiles(dir) {
 async function listSkillDirs(dir) {
   if (!existsSync5(dir)) return [];
   try {
-    const entries = await readdir9(dir);
+    const entries = await readdir11(dir);
     const names = [];
     for (const entry of entries) {
-      if (existsSync5(join19(dir, entry, "SKILL.md"))) names.push(entry);
+      if (existsSync5(join22(dir, entry, "SKILL.md"))) names.push(entry);
     }
     return names;
   } catch {
@@ -4831,7 +5755,7 @@ async function listSkillDirs(dir) {
   }
 }
 async function detectGhostAgents(calls) {
-  const defined = await listMarkdownFiles(join19(homedir11(), ".claude", "agents"));
+  const defined = await listMarkdownFiles(join22(homedir11(), ".claude", "agents"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const call of calls) {
@@ -4856,7 +5780,7 @@ async function detectGhostAgents(calls) {
   };
 }
 async function detectGhostSkills(calls) {
-  const defined = await listSkillDirs(join19(homedir11(), ".claude", "skills"));
+  const defined = await listSkillDirs(join22(homedir11(), ".claude", "skills"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const call of calls) {
@@ -4881,7 +5805,7 @@ async function detectGhostSkills(calls) {
   };
 }
 async function detectGhostCommands(userMessages) {
-  const defined = await listMarkdownFiles(join19(homedir11(), ".claude", "commands"));
+  const defined = await listMarkdownFiles(join22(homedir11(), ".claude", "commands"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const msg of userMessages) {
@@ -4909,7 +5833,7 @@ async function detectGhostCommands(userMessages) {
 }
 function readShellProfileLimit() {
   for (const profile of SHELL_PROFILES) {
-    const path = join19(homedir11(), profile);
+    const path = join22(homedir11(), profile);
     if (!existsSync5(path)) continue;
     const content = readSessionFileSync(path);
     if (content === null) continue;
@@ -4992,8 +5916,8 @@ function computeInputCostRate(projects) {
 var resultCache = /* @__PURE__ */ new Map();
 function cacheKey2(projects, dateRange) {
   const dr = dateRange ? `${dateRange.start.getTime()}-${dateRange.end.getTime()}` : "all";
-  const fingerprint = projects.length + ":" + projects.reduce((s, p) => s + p.totalApiCalls, 0);
-  return `${dr}:${fingerprint}`;
+  const fingerprint2 = projects.length + ":" + projects.reduce((s, p) => s + p.totalApiCalls, 0);
+  return `${dr}:${fingerprint2}`;
 }
 async function scanAndDetect(projects, dateRange, preScanned) {
   if (projects.length === 0) {
@@ -5130,9 +6054,10 @@ async function runOptimize(projects, periodLabel, dateRange, preScanned) {
 }
 
 // src/context-budget.ts
-import { readdir as readdir10 } from "fs/promises";
+init_fs_utils();
+import { readdir as readdir12 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import { join as join20 } from "path";
+import { join as join23 } from "path";
 import { homedir as homedir12 } from "os";
 var CHARS_PER_TOKEN2 = 4;
 var SYSTEM_BASE_TOKENS = 10400;
@@ -5150,416 +6075,113 @@ async function readConfigFile(path) {
   } catch {
     return null;
   }
-}
-async function countMcpTools(projectPath) {
-  const home = homedir12();
-  const configPaths = [
-    join20(home, ".claude", "settings.json"),
-    join20(home, ".claude", "settings.local.json")
-  ];
-  if (projectPath) {
-    configPaths.push(join20(projectPath, ".mcp.json"));
-    configPaths.push(join20(projectPath, ".claude", "settings.json"));
-    configPaths.push(join20(projectPath, ".claude", "settings.local.json"));
-  }
-  const servers = /* @__PURE__ */ new Set();
-  let toolCount = 0;
-  for (const p of configPaths) {
-    const config = await readConfigFile(p);
-    if (!config) continue;
-    const mcpServers = config.mcpServers ?? {};
-    for (const name of Object.keys(mcpServers)) {
-      if (servers.has(name)) continue;
-      servers.add(name);
-      toolCount += 5;
-    }
-  }
-  return toolCount;
-}
-async function countSkills(projectPath) {
-  const dirs = [join20(homedir12(), ".claude", "skills")];
-  if (projectPath) dirs.push(join20(projectPath, ".claude", "skills"));
-  let count = 0;
-  for (const dir of dirs) {
-    if (!existsSync6(dir)) continue;
-    try {
-      const entries = await readdir10(dir);
-      for (const entry of entries) {
-        const skillFile = join20(dir, entry, "SKILL.md");
-        if (existsSync6(skillFile)) count++;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return count;
-}
-async function scanMemoryFiles(projectPath) {
-  const home = homedir12();
-  const files = [];
-  const paths = [
-    { path: join20(home, ".claude", "CLAUDE.md"), name: "~/.claude/CLAUDE.md" }
-  ];
-  if (projectPath) {
-    paths.push({ path: join20(projectPath, "CLAUDE.md"), name: "CLAUDE.md" });
-    paths.push({ path: join20(projectPath, ".claude", "CLAUDE.md"), name: ".claude/CLAUDE.md" });
-    paths.push({ path: join20(projectPath, "CLAUDE.local.md"), name: "CLAUDE.local.md" });
-  }
-  for (const { path, name } of paths) {
-    if (!existsSync6(path)) continue;
-    const content = await readSessionFile(path);
-    if (content === null) continue;
-    files.push({ name, tokens: estimateTokens2(content) });
-  }
-  return files;
-}
-async function estimateContextBudget(projectPath, modelContext = 1e6) {
-  const mcpToolCount = await countMcpTools(projectPath);
-  const skillCount = await countSkills(projectPath);
-  const memoryFiles = await scanMemoryFiles(projectPath);
-  const mcpTokens = mcpToolCount * TOOL_TOKENS_OVERHEAD;
-  const skillTokens = skillCount * SKILL_FRONTMATTER_TOKENS;
-  const memoryTokens = memoryFiles.reduce((s, f) => s + f.tokens, 0);
-  const total = SYSTEM_BASE_TOKENS + mcpTokens + skillTokens + memoryTokens;
-  return {
-    systemBase: SYSTEM_BASE_TOKENS,
-    mcpTools: { count: mcpToolCount, tokens: mcpTokens },
-    skills: { count: skillCount, tokens: skillTokens },
-    memory: { count: memoryFiles.length, tokens: memoryTokens, files: memoryFiles },
-    total,
-    modelContext
-  };
-}
-async function discoverProjectCwd(sessionDir) {
-  let files;
-  try {
-    files = (await readdir10(sessionDir)).filter((f) => f.endsWith(".jsonl"));
-  } catch {
-    return null;
-  }
-  if (files.length === 0) return null;
-  const firstFile = files[0];
-  if (!firstFile) return null;
-  const content = await readSessionFile(join20(sessionDir, firstFile));
-  if (content === null) return null;
-  for (const line of content.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      const entry = JSON.parse(line);
-      if (entry.cwd && typeof entry.cwd === "string") return entry.cwd;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
-// src/compare.tsx
-import React, { useState, useEffect, useRef } from "react";
-import { render, Box, Text, useInput, useApp, useStdout } from "ink";
-
-// src/compare-stats.ts
-import { readdir as readdir11, readFile as readFile9 } from "fs/promises";
-import { join as join21 } from "path";
-var PLANNING_TOOLS = /* @__PURE__ */ new Set(["TaskCreate", "TaskUpdate", "TodoWrite", "EnterPlanMode", "ExitPlanMode"]);
-function aggregateModelStats(projects) {
-  const byModel = /* @__PURE__ */ new Map();
-  const ensure = (model) => {
-    let s = byModel.get(model);
-    if (!s) {
-      s = { model, calls: 0, cost: 0, outputTokens: 0, inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTurns: 0, editTurns: 0, oneShotTurns: 0, retries: 0, selfCorrections: 0, editCost: 0, firstSeen: "", lastSeen: "" };
-      byModel.set(model, s);
-    }
-    return s;
-  };
-  for (const project of projects) {
-    for (const session of project.sessions) {
-      for (const turn of session.turns) {
-        if (turn.assistantCalls.length === 0) continue;
-        const primaryModel = turn.assistantCalls[0].model;
-        if (primaryModel === "<synthetic>") continue;
-        const ms = ensure(primaryModel);
-        ms.totalTurns++;
-        if (turn.hasEdits) {
-          ms.editTurns++;
-          if (turn.retries === 0) ms.oneShotTurns++;
-          for (const c of turn.assistantCalls) {
-            if (c.model !== "<synthetic>") ms.editCost += c.costUSD;
-          }
-        }
-        ms.retries += turn.retries;
-        for (const call of turn.assistantCalls) {
-          if (call.model === "<synthetic>") continue;
-          const cs = call.model === primaryModel ? ms : ensure(call.model);
-          cs.calls++;
-          cs.cost += call.costUSD;
-          cs.outputTokens += call.usage.outputTokens;
-          cs.inputTokens += call.usage.inputTokens;
-          cs.cacheReadTokens += call.usage.cacheReadInputTokens;
-          cs.cacheWriteTokens += call.usage.cacheCreationInputTokens;
-          if (!cs.firstSeen || call.timestamp < cs.firstSeen) cs.firstSeen = call.timestamp;
-          if (!cs.lastSeen || call.timestamp > cs.lastSeen) cs.lastSeen = call.timestamp;
-        }
-      }
-    }
-  }
-  return [...byModel.values()].sort((a, b) => b.cost - a.cost);
-}
-var METRICS = [
-  {
-    section: "Performance",
-    label: "One-shot rate",
-    formatFn: "percent",
-    higherIsBetter: true,
-    compute: (s) => s.editTurns > 0 ? s.oneShotTurns / s.editTurns * 100 : null
-  },
-  {
-    section: "Performance",
-    label: "Retry rate",
-    formatFn: "decimal",
-    higherIsBetter: false,
-    compute: (s) => s.editTurns > 0 ? s.retries / s.editTurns : null
-  },
-  {
-    section: "Performance",
-    label: "Self-correction",
-    formatFn: "percent",
-    higherIsBetter: false,
-    compute: (s) => s.totalTurns > 0 ? s.selfCorrections / s.totalTurns * 100 : null
-  },
-  {
-    section: "Efficiency",
-    label: "Cost / call",
-    formatFn: "cost",
-    higherIsBetter: false,
-    compute: (s) => s.calls > 0 ? s.cost / s.calls : null
-  },
-  {
-    section: "Efficiency",
-    label: "Cost / edit",
-    formatFn: "cost",
-    higherIsBetter: false,
-    compute: (s) => s.editTurns > 0 ? s.editCost / s.editTurns : null
-  },
-  {
-    section: "Efficiency",
-    label: "Output tok / call",
-    formatFn: "number",
-    higherIsBetter: false,
-    compute: (s) => s.calls > 0 ? Math.round(s.outputTokens / s.calls) : null
-  },
-  {
-    section: "Efficiency",
-    label: "Cache hit rate",
-    formatFn: "percent",
-    higherIsBetter: true,
-    compute: (s) => {
-      const total = s.inputTokens + s.cacheReadTokens + s.cacheWriteTokens;
-      return total > 0 ? s.cacheReadTokens / total * 100 : null;
-    }
-  }
-];
-function pickWinner(valueA, valueB, higherIsBetter) {
-  if (valueA === null || valueB === null) return "none";
-  if (valueA === valueB) return "tie";
-  if (higherIsBetter) return valueA > valueB ? "a" : "b";
-  return valueA < valueB ? "a" : "b";
-}
-function computeComparison(a, b) {
-  return METRICS.map((m) => {
-    const valueA = m.compute(a);
-    const valueB = m.compute(b);
-    return {
-      section: m.section,
-      label: m.label,
-      valueA,
-      valueB,
-      formatFn: m.formatFn,
-      winner: pickWinner(valueA, valueB, m.higherIsBetter)
-    };
-  });
-}
-function computeCategoryComparison(projects, modelA, modelB) {
-  const mapA = /* @__PURE__ */ new Map();
-  const mapB = /* @__PURE__ */ new Map();
-  const ensure = (map, cat) => {
-    let a = map.get(cat);
-    if (!a) {
-      a = { turns: 0, editTurns: 0, oneShotTurns: 0 };
-      map.set(cat, a);
-    }
-    return a;
-  };
-  for (const project of projects) {
-    for (const session of project.sessions) {
-      for (const turn of session.turns) {
-        if (turn.assistantCalls.length === 0) continue;
-        const primary = turn.assistantCalls[0].model;
-        if (primary !== modelA && primary !== modelB) continue;
-        const acc = ensure(primary === modelA ? mapA : mapB, turn.category);
-        acc.turns++;
-        if (turn.hasEdits) {
-          acc.editTurns++;
-          if (turn.retries === 0) acc.oneShotTurns++;
-        }
-      }
-    }
-  }
-  const allCats = /* @__PURE__ */ new Set([...mapA.keys(), ...mapB.keys()]);
-  const result = [];
-  for (const category of allCats) {
-    const a = mapA.get(category);
-    const b = mapB.get(category);
-    if ((!a || a.editTurns === 0) && (!b || b.editTurns === 0)) continue;
-    const rateA = a && a.editTurns > 0 ? a.oneShotTurns / a.editTurns * 100 : null;
-    const rateB = b && b.editTurns > 0 ? b.oneShotTurns / b.editTurns * 100 : null;
-    result.push({
-      category,
-      turnsA: a?.turns ?? 0,
-      editTurnsA: a?.editTurns ?? 0,
-      oneShotRateA: rateA,
-      turnsB: b?.turns ?? 0,
-      editTurnsB: b?.editTurns ?? 0,
-      oneShotRateB: rateB,
-      winner: pickWinner(rateA, rateB, true)
-    });
+}
+async function countMcpTools(projectPath) {
+  const home = homedir12();
+  const configPaths = [
+    join23(home, ".claude", "settings.json"),
+    join23(home, ".claude", "settings.local.json")
+  ];
+  if (projectPath) {
+    configPaths.push(join23(projectPath, ".mcp.json"));
+    configPaths.push(join23(projectPath, ".claude", "settings.json"));
+    configPaths.push(join23(projectPath, ".claude", "settings.local.json"));
   }
-  return result.sort((a, b) => b.turnsA + b.turnsB - (a.turnsA + a.turnsB));
+  const servers = /* @__PURE__ */ new Set();
+  let toolCount = 0;
+  for (const p of configPaths) {
+    const config = await readConfigFile(p);
+    if (!config) continue;
+    const mcpServers = config.mcpServers ?? {};
+    for (const name of Object.keys(mcpServers)) {
+      if (servers.has(name)) continue;
+      servers.add(name);
+      toolCount += 5;
+    }
+  }
+  return toolCount;
 }
-function computeWorkingStyle(projects, modelA, modelB) {
-  const sA = { totalTurns: 0, agentSpawns: 0, planModeUses: 0, totalToolCalls: 0, fastModeCalls: 0 };
-  const sB = { totalTurns: 0, agentSpawns: 0, planModeUses: 0, totalToolCalls: 0, fastModeCalls: 0 };
-  for (const project of projects) {
-    for (const session of project.sessions) {
-      for (const turn of session.turns) {
-        if (turn.assistantCalls.length === 0) continue;
-        const primary = turn.assistantCalls[0].model;
-        if (primary !== modelA && primary !== modelB) continue;
-        const s = primary === modelA ? sA : sB;
-        s.totalTurns++;
-        const turnTools = turn.assistantCalls.flatMap((c) => c.tools);
-        if (turnTools.some((t) => PLANNING_TOOLS.has(t)) || turn.assistantCalls.some((c) => c.hasPlanMode)) {
-          s.planModeUses++;
-        }
-        for (const call of turn.assistantCalls) {
-          s.totalToolCalls += call.tools.length;
-          if (call.hasAgentSpawn) s.agentSpawns++;
-          if (call.speed === "fast") s.fastModeCalls++;
-        }
+async function countSkills(projectPath) {
+  const dirs = [join23(homedir12(), ".claude", "skills")];
+  if (projectPath) dirs.push(join23(projectPath, ".claude", "skills"));
+  let count = 0;
+  for (const dir of dirs) {
+    if (!existsSync6(dir)) continue;
+    try {
+      const entries = await readdir12(dir);
+      for (const entry of entries) {
+        const skillFile = join23(dir, entry, "SKILL.md");
+        if (existsSync6(skillFile)) count++;
       }
+    } catch {
+      continue;
     }
   }
-  const pct2 = (num, den) => den > 0 ? num / den * 100 : null;
-  const avg = (num, den) => den > 0 ? num / den : null;
-  return [
-    { label: "Delegation rate", valueA: pct2(sA.agentSpawns, sA.totalTurns), valueB: pct2(sB.agentSpawns, sB.totalTurns), formatFn: "percent" },
-    { label: "Planning rate", valueA: pct2(sA.planModeUses, sA.totalTurns), valueB: pct2(sB.planModeUses, sB.totalTurns), formatFn: "percent" },
-    { label: "Avg tools / turn", valueA: avg(sA.totalToolCalls, sA.totalTurns), valueB: avg(sB.totalToolCalls, sB.totalTurns), formatFn: "decimal" },
-    { label: "Fast mode usage", valueA: pct2(sA.fastModeCalls, sA.totalTurns), valueB: pct2(sB.fastModeCalls, sB.totalTurns), formatFn: "percent" }
-  ];
-}
-var SELF_CORRECTION_PATTERNS = [
-  /\bmy mistake\b/i,
-  /\bmy bad\b/i,
-  /\bmy apolog/i,
-  /\bI apologize\b/i,
-  /\bI was wrong\b/i,
-  /\bI was incorrect\b/i,
-  /\bI made (a |an )?(error|mistake)\b/i,
-  /\bI incorrectly\b/i,
-  /\bI mistakenly\b/i,
-  /\bthat was (incorrect|wrong|an error)\b/i,
-  /\blet me correct that\b/i,
-  /\bI need to correct\b/i,
-  /\byou're right[.,]? I/i,
-  /\bsorry about that\b/i
-];
-function extractText(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content.filter((b) => b !== null && typeof b === "object" && b.type === "text" && typeof b.text === "string").map((b) => b.text).join(" ");
-}
-function isCompactFile(name) {
-  return name.includes("compact");
+  return count;
 }
-async function collectJsonlFiles3(sessionDir) {
-  const entries = await readdir11(sessionDir, { withFileTypes: true });
+async function scanMemoryFiles(projectPath) {
+  const home = homedir12();
   const files = [];
-  for (const entry of entries) {
-    if (entry.isFile() && entry.name.endsWith(".jsonl") && !isCompactFile(entry.name)) {
-      files.push(join21(sessionDir, entry.name));
-    } else if (entry.isDirectory() && entry.name === "subagents") {
-      const subEntries = await readdir11(join21(sessionDir, entry.name), { withFileTypes: true });
-      for (const sub of subEntries) {
-        if (sub.isFile() && sub.name.endsWith(".jsonl") && !isCompactFile(sub.name)) {
-          files.push(join21(sessionDir, entry.name, sub.name));
-        }
-      }
-    }
+  const paths = [
+    { path: join23(home, ".claude", "CLAUDE.md"), name: "~/.claude/CLAUDE.md" }
+  ];
+  if (projectPath) {
+    paths.push({ path: join23(projectPath, "CLAUDE.md"), name: "CLAUDE.md" });
+    paths.push({ path: join23(projectPath, ".claude", "CLAUDE.md"), name: ".claude/CLAUDE.md" });
+    paths.push({ path: join23(projectPath, "CLAUDE.local.md"), name: "CLAUDE.local.md" });
+  }
+  for (const { path, name } of paths) {
+    if (!existsSync6(path)) continue;
+    const content = await readSessionFile(path);
+    if (content === null) continue;
+    files.push({ name, tokens: estimateTokens2(content) });
   }
   return files;
 }
-async function scanSelfCorrections(projectDirs) {
-  const counts = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Set();
-  for (const dir of projectDirs) {
-    let entries;
+async function estimateContextBudget(projectPath, modelContext = 1e6) {
+  const mcpToolCount = await countMcpTools(projectPath);
+  const skillCount = await countSkills(projectPath);
+  const memoryFiles = await scanMemoryFiles(projectPath);
+  const mcpTokens = mcpToolCount * TOOL_TOKENS_OVERHEAD;
+  const skillTokens = skillCount * SKILL_FRONTMATTER_TOKENS;
+  const memoryTokens = memoryFiles.reduce((s, f) => s + f.tokens, 0);
+  const total = SYSTEM_BASE_TOKENS + mcpTokens + skillTokens + memoryTokens;
+  return {
+    systemBase: SYSTEM_BASE_TOKENS,
+    mcpTools: { count: mcpToolCount, tokens: mcpTokens },
+    skills: { count: skillCount, tokens: skillTokens },
+    memory: { count: memoryFiles.length, tokens: memoryTokens, files: memoryFiles },
+    total,
+    modelContext
+  };
+}
+async function discoverProjectCwd(sessionDir) {
+  let files;
+  try {
+    files = (await readdir12(sessionDir)).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return null;
+  }
+  if (files.length === 0) return null;
+  const firstFile = files[0];
+  if (!firstFile) return null;
+  const content = await readSessionFile(join23(sessionDir, firstFile));
+  if (content === null) return null;
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
     try {
-      entries = await readdir11(dir, { withFileTypes: true });
+      const entry = JSON.parse(line);
+      if (entry.cwd && typeof entry.cwd === "string") return entry.cwd;
     } catch {
       continue;
     }
-    const allFiles = [];
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name.endsWith(".jsonl") && !isCompactFile(entry.name)) {
-        allFiles.push(join21(dir, entry.name));
-      } else if (entry.isDirectory()) {
-        try {
-          const sessionFiles = await collectJsonlFiles3(join21(dir, entry.name));
-          allFiles.push(...sessionFiles);
-        } catch {
-          continue;
-        }
-      }
-    }
-    for (const file of allFiles) {
-      let raw;
-      try {
-        raw = await readFile9(file, "utf8");
-      } catch {
-        continue;
-      }
-      for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        let parsed;
-        try {
-          parsed = JSON.parse(trimmed);
-        } catch {
-          continue;
-        }
-        const rec = parsed;
-        if (!rec || typeof rec !== "object" || rec["type"] !== "assistant") continue;
-        const ts = rec["timestamp"];
-        const msg = rec["message"];
-        if (msg === null || typeof msg !== "object") continue;
-        const msgRec = msg;
-        const model = msgRec["model"];
-        if (typeof model !== "string" || model === "<synthetic>") continue;
-        const dedupeKey = `${model}:${ts}`;
-        if (seen.has(dedupeKey)) continue;
-        seen.add(dedupeKey);
-        const text = extractText(msgRec["content"]);
-        if (SELF_CORRECTION_PATTERNS.some((p) => p.test(text))) {
-          counts.set(model, (counts.get(model) ?? 0) + 1);
-        }
-      }
-    }
   }
-  return counts;
+  return null;
 }
 
 // src/compare.tsx
+import React, { useState, useEffect, useRef } from "react";
+import { render, Box, Text, useInput, useApp, useStdout } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
 var ORANGE2 = "#F59E0B";
 var GREEN2 = "#16A34A";
@@ -6140,7 +6762,7 @@ function planDisplayName(id) {
 }
 
 // src/dashboard.tsx
-import { join as join22 } from "path";
+import { join as join24 } from "path";
 import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var PERIODS = ["today", "week", "30days", "month", "all"];
 var PERIOD_LABELS = {
@@ -6389,6 +7011,13 @@ function DailyActivity({ projects, days = 14, pw, bw }) {
   const dailyCalls = {};
   for (const project of projects) {
     for (const session of project.sessions) {
+      if (session.reportSummary) {
+        for (const [day, row] of Object.entries(session.reportSummary.daily)) {
+          dailyCosts[day] = (dailyCosts[day] ?? 0) + row.cost;
+          dailyCalls[day] = (dailyCalls[day] ?? 0) + row.calls;
+        }
+        continue;
+      }
       for (const turn of session.turns) {
         if (!turn.timestamp) continue;
         const day = dateKey(turn.timestamp);
@@ -6790,15 +7419,15 @@ function StatusBar({ width, showProvider, view, findingCount, optimizeAvailable,
     /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " month   " }),
     /* @__PURE__ */ jsx2(Text2, { color: ORANGE3, bold: true, children: "5" }),
     /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " all time" }),
-    !isOptimize && optimizeAvailable && findingCount != null && findingCount > 0 && /* @__PURE__ */ jsxs2(Fragment, { children: [
+    !isOptimize && optimizeAvailable && /* @__PURE__ */ jsxs2(Fragment, { children: [
       /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "   " }),
       /* @__PURE__ */ jsx2(Text2, { color: ORANGE3, bold: true, children: "o" }),
       /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " optimize" }),
-      /* @__PURE__ */ jsxs2(Text2, { color: "#DC2626", children: [
+      findingCount ? /* @__PURE__ */ jsxs2(Text2, { color: "#DC2626", children: [
         " (",
         findingCount,
         ")"
-      ] })
+      ] }) : null
     ] }),
     !isOptimize && compareAvailable && /* @__PURE__ */ jsxs2(Fragment, { children: [
       /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "   " }),
@@ -6852,6 +7481,10 @@ function InteractiveDashboard({ initialPeriod, initialProvider, refreshSeconds,
   const [projects, setProjects] = useState2([]);
   const [initialLoading, setInitialLoading] = useState2(true);
   const [loading, setLoading] = useState2(false);
+  const [loadError2, setLoadError] = useState2(null);
+  const loader = useRef2(new LatestLoad());
+  const retryAt = useRef2(0);
+  const failures = useRef2(0);
   const [activeProvider, setActiveProvider] = useState2(initialProvider);
   const [detectedProviders, setDetectedProviders] = useState2([]);
   const [view, setView] = useState2("dashboard");
@@ -6876,103 +7509,88 @@ function InteractiveDashboard({ initialPeriod, initialProvider, refreshSeconds,
     return () => clearInterval(id);
   }, [initialLoading]);
   useEffect2(() => {
-    let cancelled = false;
-    async function boot() {
-      await loadPricing();
-      if (cancelled) return;
-      const range = getDateRange(initialPeriod);
-      const data = await parseAllSessions(range, initialProvider);
-      if (cancelled) return;
-      const filtered = filterProjectsByName(data, projectFilter, excludeFilter);
-      setProjects(filtered);
-      const usage = await getPlanUsageOrNull();
-      if (cancelled) return;
-      setPlanUsage(usage ?? void 0);
-      setInitialLoading(false);
-    }
-    boot();
-    return () => {
-      cancelled = true;
-    };
-  }, []);
-  useEffect2(() => {
-    let cancelled = false;
-    async function detect() {
-      const found = [];
-      for (const p of await getAllProviders()) {
-        const s = await p.discoverSessions();
-        if (s.length > 0) found.push(p.name);
-      }
-      if (!cancelled) setDetectedProviders(found);
-    }
-    detect();
+    void reloadData(initialPeriod, initialProvider);
     return () => {
-      cancelled = true;
+      loader.current.cancel();
+      if (debounceRef.current) clearTimeout(debounceRef.current);
     };
   }, []);
   useEffect2(() => {
     let cancelled = false;
     async function loadBudgets() {
-      const claudeDir = join22(homedir13(), ".claude", "projects");
+      const claudeDir = join24(homedir13(), ".claude", "projects");
       const budgets = /* @__PURE__ */ new Map();
       for (const project of projects.slice(0, 8)) {
         if (cancelled) return;
-        const cwd = await discoverProjectCwd(join22(claudeDir, project.project));
+        const cwd = await discoverProjectCwd(join24(claudeDir, project.project));
         if (!cwd) continue;
         budgets.set(project.project, await estimateContextBudget(cwd));
       }
       if (!cancelled) setProjectBudgets(budgets);
     }
-    loadBudgets();
+    void loadBudgets().catch(() => {
+    });
     return () => {
       cancelled = true;
     };
   }, [projects]);
   useEffect2(() => {
-    if (!optimizeAvailable) {
+    if (!optimizeAvailable || view !== "optimize" || loading || initialLoading || loadError2) {
       setOptimizeResult(null);
       return;
     }
     let cancelled = false;
+    const controller = new AbortController();
     async function scan() {
       if (projects.length === 0) {
         setOptimizeResult(null);
         return;
       }
-      const result = await scanAndDetect(projects, getDateRange(period));
-      if (!cancelled) setOptimizeResult(result);
+      const result = await loader.current.run((signal) => withScanBudget(() => scanAndDetect(projects, getDateRange(period)), 2e5, AbortSignal.any([signal, controller.signal])));
+      if (!cancelled && result) setOptimizeResult(result);
     }
-    scan();
+    void scan().catch((error) => {
+      if (!cancelled) setLoadError(error instanceof Error ? error.message : String(error));
+    });
     return () => {
       cancelled = true;
+      controller.abort();
     };
-  }, [projects, period, optimizeAvailable]);
+  }, [projects, period, optimizeAvailable, view, loading, initialLoading, loadError2]);
   const reloadData = useCallback(async (p, prov) => {
     const generation = ++reloadGenerationRef.current;
     setLoading(true);
     setOptimizeResult(null);
     try {
-      const range = getDateRange(p);
-      const data = await parseAllSessions(range, prov);
-      if (reloadGenerationRef.current !== generation) return;
-      const filteredProjects = filterProjectsByName(data, projectFilter, excludeFilter);
-      if (reloadGenerationRef.current !== generation) return;
-      setProjects(filteredProjects);
-      const usage = await getPlanUsageOrNull();
-      if (reloadGenerationRef.current !== generation) return;
-      setPlanUsage(usage ?? void 0);
+      setLoadError(null);
+      const result = await loader.current.run(async (signal) => {
+        await loadPricing();
+        const data = await parseAllSessions(getDateRange(p), prov, true, signal);
+        if (signal.aborted) return void 0;
+        return { projects: filterProjectsByName(data, projectFilter, excludeFilter), usage: await getPlanUsageOrNull(), providers: getDiscoveredProviderNames() };
+      });
+      if (!result || reloadGenerationRef.current !== generation) return;
+      setProjects(result.projects);
+      setDetectedProviders(result.providers);
+      setPlanUsage(result.usage ?? void 0);
+      failures.current = 0;
+      retryAt.current = 0;
     } catch (error) {
-      console.error(error);
+      if (reloadGenerationRef.current === generation) {
+        setLoadError(error instanceof Error ? error.message : String(error));
+        retryAt.current = Date.now() + Math.min(3e5, 3e4 * 2 ** Math.min(failures.current++, 4));
+      }
     } finally {
       if (reloadGenerationRef.current === generation) {
         setLoading(false);
+        setInitialLoading(false);
       }
     }
   }, [projectFilter, excludeFilter]);
   useEffect2(() => {
     if (!refreshSeconds || refreshSeconds <= 0) return;
     const id = setInterval(() => {
-      reloadData(period, activeProvider);
+      if (!loader.current.busy && Date.now() >= retryAt.current) void reloadData(period, activeProvider);
     }, refreshSeconds * 1e3);
     return () => clearInterval(id);
   }, [refreshSeconds, period, activeProvider, reloadData]);
@@ -6992,14 +7610,20 @@ function InteractiveDashboard({ initialPeriod, initialProvider, refreshSeconds,
   }, [period, activeProvider, reloadData]);
   useInput2((input, key) => {
     if (input === "q") {
+      loader.current.cancel();
       exit();
       return;
     }
-    if (input === "o" && findingCount > 0 && view === "dashboard" && optimizeAvailable) {
+    if (input === "r") {
+      void reloadData(period, activeProvider);
+      return;
+    }
+    if (input === "o" && view === "dashboard" && optimizeAvailable) {
       setView("optimize");
       return;
     }
     if ((input === "b" || key.escape) && view === "optimize") {
+      setLoadError(null);
       setView("dashboard");
       return;
     }
@@ -7028,6 +7652,15 @@ function InteractiveDashboard({ initialPeriod, initialProvider, refreshSeconds,
   if (initialLoading) {
     return /* @__PURE__ */ jsx2(LoadingScreen, { width: dashWidth, dots: loadingDots });
   }
+  if (loadError2 && !loading) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: dashWidth, children: [
+      /* @__PURE__ */ jsx2(PeriodTabs, { active: period, providerName: activeProvider }),
+      /* @__PURE__ */ jsxs2(Panel, { title: "Report could not refresh", color: ORANGE3, width: dashWidth, children: [
+        /* @__PURE__ */ jsx2(Text2, { children: loadError2 }),
+        /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Press r to retry, 1\u20135 to change period, or q to quit." })
+      ] })
+    ] });
+  }
   if (loading) {
     return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: dashWidth, children: [
       /* @__PURE__ */ jsx2(PeriodTabs, { active: period, providerName: activeProvider, showProvider: view !== "compare" && multipleProviders }),
@@ -7049,7 +7682,7 @@ function InteractiveDashboard({ initialPeriod, initialProvider, refreshSeconds,
   }
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: dashWidth, children: [
     /* @__PURE__ */ jsx2(PeriodTabs, { active: period, providerName: activeProvider, showProvider: multipleProviders && view !== "compare" }),
-    view === "compare" ? /* @__PURE__ */ jsx2(CompareView, { projects, onBack: () => setView("dashboard") }) : view === "optimize" && optimizeResult ? /* @__PURE__ */ jsx2(OptimizeView, { findings: optimizeResult.findings, costRate: optimizeResult.costRate, projects, label: PERIOD_LABELS[period], width: dashWidth, healthScore: optimizeResult.healthScore, healthGrade: optimizeResult.healthGrade }) : /* @__PURE__ */ jsx2(DashboardContent, { projects, period, columns, activeProvider, budgets: projectBudgets, planUsage }),
+    view === "compare" ? /* @__PURE__ */ jsx2(CompareView, { projects, onBack: () => setView("dashboard") }) : view === "optimize" && optimizeResult ? /* @__PURE__ */ jsx2(OptimizeView, { findings: optimizeResult.findings, costRate: optimizeResult.costRate, projects, label: PERIOD_LABELS[period], width: dashWidth, healthScore: optimizeResult.healthScore, healthGrade: optimizeResult.healthGrade }) : view === "optimize" ? /* @__PURE__ */ jsx2(Panel, { title: "Optimization", color: ORANGE3, width: dashWidth, children: /* @__PURE__ */ jsx2(Text2, { children: "Scanning\u2026" }) }) : /* @__PURE__ */ jsx2(DashboardContent, { projects, period, columns, activeProvider, budgets: projectBudgets, planUsage }),
     view !== "compare" && /* @__PURE__ */ jsx2(StatusBar, { width: dashWidth, showProvider: multipleProviders, view, findingCount, optimizeAvailable, compareAvailable })
   ] });
 }
@@ -7071,7 +7704,7 @@ async function renderDashboard(period = "week", provider = "all", refreshSeconds
   } else {
     await loadPricing();
     const range = customRange ?? getDateRange(period);
-    const filteredProjects = filterProjectsByName(await parseAllSessions(range, provider), projectFilter, excludeFilter);
+    const filteredProjects = filterProjectsByName(await parseAllSessions(range, provider, true), projectFilter, excludeFilter);
     const planUsage = await getPlanUsageOrNull();
     const { unmount } = render2(/* @__PURE__ */ jsx2(StaticDashboard, { projects: filteredProjects, period, activeProvider: provider, planUsage: planUsage ?? void 0 }), { patchConsole: false });
     unmount();
@@ -7167,9 +7800,32 @@ function computeProgressiveBackfillStart({
   }
   return gapStart;
 }
+var DEFAULT_BACKFILL_CHUNK_DAYS = 1;
+var MAX_BLOCKED_CHUNK_ATTEMPTS = 2;
+function planBackfillChunks(start, end, chunkDays = DEFAULT_BACKFILL_CHUNK_DAYS) {
+  const size = Math.max(1, Math.floor(chunkDays));
+  const chunks = [];
+  if (start.getTime() > end.getTime()) return chunks;
+  let cursor2 = new Date(start.getFullYear(), start.getMonth(), start.getDate());
+  if (cursor2.getTime() < start.getTime()) cursor2 = new Date(start.getTime());
+  while (cursor2.getTime() <= end.getTime()) {
+    const dayStart = new Date(cursor2.getFullYear(), cursor2.getMonth(), cursor2.getDate());
+    const lastDay = new Date(dayStart.getFullYear(), dayStart.getMonth(), dayStart.getDate() + size - 1);
+    const chunkEnd = new Date(lastDay.getFullYear(), lastDay.getMonth(), lastDay.getDate() + 1).getTime() - 1;
+    chunks.push({ start: new Date(cursor2.getTime()), end: new Date(Math.min(chunkEnd, end.getTime())) });
+    cursor2 = new Date(dayStart.getFullYear(), dayStart.getMonth(), dayStart.getDate() + size);
+  }
+  return chunks;
+}
+function nextBackfillCursor(prev, date) {
+  return prev && prev.blockedDate === date ? { blockedDate: date, attempts: prev.attempts + 1 } : { blockedDate: date, attempts: 1 };
+}
+function shouldSkipBlockedChunk(cursor2, date, maxAttempts = MAX_BLOCKED_CHUNK_ATTEMPTS) {
+  return !!cursor2 && cursor2.blockedDate === date && cursor2.attempts >= maxAttempts;
+}
 
 // src/cli.ts
-import { createInterface as createInterface2 } from "readline";
+import { createInterface } from "readline";
 import { createRequire as createRequire2 } from "module";
 var require2 = createRequire2(import.meta.url);
 var { version } = require2("../package.json");
@@ -7460,10 +8116,53 @@ program.command("status").description("Compact status output (today + week + mon
     const yesterdayStr = toDateString(new Date(todayStart.getTime() - MS_PER_DAY4));
     const isAllProviders = pf === "all";
     const dailyCacheScope = buildDailyCacheScopeKey(opts.project, opts.exclude);
+    const backfillWarnings = [];
+    const runChunkedBackfill = async (cache2, start, end, order) => {
+      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)) {
+          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);
+          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}
+`);
+          continue;
+        }
+        try {
+          const chunkRange = { start: chunk.start, end: chunk.end };
+          const chunkProjects = filterProjectsByName(await parseAllSessions(chunkRange, "all"), opts.project, opts.exclude);
+          const chunkDays = fillMissingDays(chunk.start, chunk.end, aggregateProjectsIntoDays(chunkProjects));
+          c = addNewDays(c, chunkDays, yesterdayStr, { coveredThrough });
+          c.backfill = null;
+          c.revalidatedAt = Date.now();
+          await saveDailyCache(c);
+        } catch (err) {
+          if (!(err instanceof ResourceBudgetError)) throw err;
+          c.backfill = nextBackfillCursor(c.backfill, chunkDate);
+          c.revalidatedAt = Date.now();
+          await saveDailyCache(c);
+          const warn2 = `history backfill paused at ${chunkDate} (attempt ${c.backfill.attempts}): ${err.message}`;
+          backfillWarnings.push(warn2);
+          process.stderr.write(`[exe-watcher] WARNING: ${warn2}
+`);
+          break;
+        }
+      }
+      return c;
+    };
     const cache = await withDailyCacheLock(async () => {
       let c = await loadDailyCache(dailyCacheScope);
       const hadYesterday = c.days.some((d) => d.date >= yesterdayStr);
-      if (hadYesterday) {
+      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 };
@@ -7479,12 +8178,7 @@ program.command("status").description("Compact status output (today + week + mon
       });
       const gapEnd = oldestCachedDate && effectiveGapStart.getTime() < new Date(oldestCachedDate).getTime() ? new Date(new Date(oldestCachedDate).getTime() - MS_PER_DAY4) : yesterdayEnd;
       if (effectiveGapStart.getTime() <= gapEnd.getTime()) {
-        const gapRange = { start: effectiveGapStart, end: gapEnd };
-        const gapProjects = filterProjectsByName(await parseAllSessions(gapRange, "all"), opts.project, opts.exclude);
-        const gapDays = fillMissingDays(gapRange.start, gapRange.end, aggregateProjectsIntoDays(gapProjects));
-        const coveredThrough = gapEnd.getTime() >= yesterdayEnd.getTime() ? yesterdayStr : void 0;
-        c = addNewDays(c, gapDays, yesterdayStr, coveredThrough ? { coveredThrough } : void 0);
-        await saveDailyCache(c);
+        c = await runChunkedBackfill(c, effectiveGapStart, gapEnd, "oldest-first");
       }
       const updatedOldest = c.days.length > 0 ? c.days[0]?.date ?? null : null;
       const neededStart = new Date(todayStart.getTime() - (selectedPeriodHistoryDays - 1) * MS_PER_DAY4);
@@ -7493,11 +8187,7 @@ program.command("status").description("Compact status output (today + week + mon
       if (updatedOldest && clampedNeeded.getTime() < new Date(updatedOldest).getTime()) {
         const backEnd = new Date(new Date(updatedOldest).getTime() - MS_PER_DAY4);
         if (clampedNeeded.getTime() <= backEnd.getTime()) {
-          const backRange = { start: clampedNeeded, end: backEnd };
-          const backProjects = filterProjectsByName(await parseAllSessions(backRange, "all"), opts.project, opts.exclude);
-          const backDays = fillMissingDays(backRange.start, backRange.end, aggregateProjectsIntoDays(backProjects));
-          c = addNewDays(c, backDays, yesterdayStr);
-          await saveDailyCache(c);
+          c = await runChunkedBackfill(c, clampedNeeded, backEnd, "newest-first");
         }
       }
       return c;
@@ -7505,7 +8195,7 @@ program.command("status").description("Compact status output (today + week + mon
     let currentData;
     const scanRange = periodInfo.range;
     const todayRange = { start: todayStart, end: periodInfo.range.end };
-    const warnings = [];
+    const warnings = [...backfillWarnings];
     const parseStart = Date.now();
     let todayProjects;
     let allTodayProjects;
@@ -7629,15 +8319,15 @@ program.command("status").description("Compact status output (today + week + mon
         optimize = await scanAndDetect(todayProjects, scanRange);
       }
     }
-    const exeOsDir = join23(homedir14(), ".exe-os");
+    const exeOsDir = join25(homedir14(), ".exe-os");
     const exeOsDetected = existsSync7(exeOsDir);
     let agentStats = null;
     let statsFileAge = null;
     try {
-      const statsPath = join23(exeOsDir, "agent-stats.json");
+      const statsPath = join25(exeOsDir, "agent-stats.json");
       if (existsSync7(statsPath)) {
         statsFileAge = Math.round((Date.now() - statSync3(statsPath).mtimeMs) / 1e3);
-        const parsed = JSON.parse(readFileSync3(statsPath, "utf-8"));
+        const parsed = JSON.parse(readFileSync2(statsPath, "utf-8"));
         if (parsed && Array.isArray(parsed.agents) && typeof parsed.generated === "string") {
           agentStats = parsed;
         } else {
@@ -7645,6 +8335,7 @@ program.command("status").description("Compact status output (today + week + mon
         }
       }
     } catch (err) {
+      if (err instanceof ResourceBudgetError) throw err;
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`[exe-watcher] agent-stats.json found but failed to parse: ${msg}
 `);
@@ -7982,9 +8673,9 @@ 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 = join23(homedir14(), ".exe-os");
-  const statsPath = join23(exeOsDir, "agent-stats.json");
-  const pidPath = join23(exeOsDir, "exed.pid");
+  const exeOsDir = join25(homedir14(), ".exe-os");
+  const statsPath = join25(exeOsDir, "agent-stats.json");
+  const pidPath = join25(exeOsDir, "exed.pid");
   const dirExists = existsSync7(exeOsDir);
   const statsExists = dirExists && existsSync7(statsPath);
   const pidExists = dirExists && existsSync7(pidPath);
@@ -7996,7 +8687,7 @@ program.command("agent-status").description("Diagnose exe-os agent data pipeline
   } else {
     try {
       const ageSeconds = Math.round((Date.now() - statSync3(statsPath).mtimeMs) / 1e3);
-      const raw = readFileSync3(statsPath, "utf-8");
+      const raw = readFileSync2(statsPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && Array.isArray(parsed.agents) && typeof parsed.generated === "string") {
         const agentCount = parsed.agents.length;
@@ -8009,18 +8700,27 @@ program.command("agent-status").description("Diagnose exe-os agent data pipeline
         lines.push(`agent-stats.json:  \u2717 invalid schema`);
       }
     } catch (err) {
+      if (err instanceof ResourceBudgetError) throw err;
       const msg = err instanceof Error ? err.message : String(err);
       lines.push(`agent-stats.json:  \u2717 parse error: ${msg}`);
     }
   }
   console.log(lines.join("\n"));
 });
+var releaseScan;
+program.hook("preAction", async (_root, command) => {
+  if (command.name() === "status") releaseScan = await acquireFileLock(join25(getCacheDir(), "scan.lock"));
+});
+program.hook("postAction", async () => {
+  await releaseScan?.();
+  releaseScan = void 0;
+});
 if (process.argv.length <= 2 && process.platform === "darwin") {
   const isTTY = process.stdin.isTTY && process.stdout.isTTY;
   if (!isTTY) {
     program.outputHelp();
   } else {
-    const rl = createInterface2({ input: process.stdin, output: process.stdout });
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
     rl.question("\n  No subcommand given. Install the macOS menubar app? (y/N) ", (answer) => {
       rl.close();
       if (answer.trim().toLowerCase() === "y") {
@@ -8039,6 +8739,10 @@ if (process.argv.length <= 2 && process.platform === "darwin") {
     });
   }
 } else {
-  program.parse();
+  program.parseAsync().catch(async (error) => {
+    await releaseScan?.();
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
 }
 //# sourceMappingURL=cli.js.map