exe-watcher 0.2.70 → 0.2.71

package/dist/cli.js

@@ -1,54 +1,451 @@
 #!/usr/bin/env -S node --max-old-space-size=256 --expose-gc
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
-// src/cache-dir.ts
+// vendor/odd-core-analytics/dist/privacy/schema.js
+var require_schema = __commonJS({
+  "vendor/odd-core-analytics/dist/privacy/schema.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ActiveClock = exports.UUID = exports.PLATFORMS = exports.DIAGNOSTICS_DISCLOSURE = exports.USAGE_DISCLOSURE = exports.DEFAULT_FRAMES = exports.ERROR_CATEGORIES = exports.HANSEL_FEATURES = exports.DEFAULT_COLLECTOR = void 0;
+    exports.record = record;
+    exports.sanitizeMetric = sanitizeMetric;
+    exports.sanitizeDiagnostic = sanitizeDiagnostic2;
+    exports.collectorOrigin = collectorOrigin;
+    exports.DEFAULT_COLLECTOR = "https://data.odd.community";
+    exports.HANSEL_FEATURES = ["home", "recordings", "vocabulary", "shortcuts", "dictation"];
+    exports.ERROR_CATEGORIES = ["crash", "unhandled_exception", "render_error", "ipc_error", "ml_error"];
+    exports.DEFAULT_FRAMES = ["app:///main/index.js", "app:///renderer/index.js"];
+    exports.USAGE_DISCLOSURE = "Share active time, recording duration, feature counts and outcomes, app version and platform with our own servers. A random ID unique to this app measures returning installations. Never audio, transcripts, prompts, account details or screen recordings.";
+    exports.DIAGNOSTICS_DISCLOSURE = "Share sanitized error categories, app version and code locations with our own Sentry server. Never error text, account details, recordings or memory dumps.";
+    exports.PLATFORMS = ["macos", "windows", "linux", "ios", "android", "web"];
+    exports.UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    var CLASSES = ["Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError", "URIError", "EvalError", "AggregateError"];
+    function record(input) {
+      return input !== null && typeof input === "object" && !Array.isArray(input) ? input : null;
+    }
+    function sanitizeMetric(input, features = exports.HANSEL_FEATURES) {
+      const v = record(input);
+      if (!v)
+        return null;
+      if (v.event === "active")
+        return { event: "active" };
+      if (v.event === "feature" && typeof v.feature === "string" && features.includes(v.feature))
+        return { event: "feature", feature: v.feature };
+      if (v.event === "result" && typeof v.feature === "string" && features.includes(v.feature) && (v.outcome === "success" || v.outcome === "failure"))
+        return { event: "result", feature: v.feature, outcome: v.outcome };
+      if (v.event === "usage" && Number.isInteger(v.active_ms) && Number(v.active_ms) > 0 && Number(v.active_ms) <= 6e4)
+        return { event: "usage", active_ms: Number(v.active_ms) };
+      if (v.event === "recording" && Number.isInteger(v.recording_ms) && Number(v.recording_ms) > 0 && Number(v.recording_ms) <= 864e5)
+        return { event: "recording", recording_ms: Number(v.recording_ms) };
+      return null;
+    }
+    function sanitizeDiagnostic2(input, allowedFrames = exports.DEFAULT_FRAMES) {
+      const v = record(input);
+      if (!v || v.event !== "error" || !exports.ERROR_CATEGORIES.includes(v.category))
+        return null;
+      const frames = [];
+      if (Array.isArray(v.frames))
+        for (const inputFrame of v.frames.slice(-8)) {
+          const f = record(inputFrame);
+          if (f && typeof f.filename === "string" && allowedFrames.includes(f.filename) && Number.isInteger(f.lineno) && Number(f.lineno) > 0 && Number(f.lineno) <= 1e7 && Number.isInteger(f.colno) && Number(f.colno) >= 0 && Number(f.colno) <= 1e7) {
+            frames.push({ filename: f.filename, lineno: Number(f.lineno), colno: Number(f.colno) });
+          }
+        }
+      return {
+        event: "error",
+        category: v.category,
+        error_class: typeof v.error_class === "string" && CLASSES.includes(v.error_class) ? v.error_class : "Error",
+        version: typeof v.version === "string" && /^\d{1,4}\.\d{1,4}\.\d{1,4}$/.test(v.version) ? v.version : "0.0.0",
+        frames
+      };
+    }
+    function collectorOrigin(input) {
+      const u = new URL(input);
+      if (u.protocol !== "https:" || u.username || u.password || u.pathname !== "/" || u.search || u.hash || /(^|\.)(posthog\.com|posthog\.net|google\.com|googleapis\.com|google-analytics\.com|googletagmanager\.com|firebaseapp\.com|firebaseio\.com)$/.test(u.hostname))
+        throw new Error("Use an operator-controlled HTTPS collector origin");
+      return u.origin;
+    }
+    var ActiveClock = class {
+      constructor() {
+        this.previous = null;
+      }
+      sample(time, focused, idleSeconds, recording = false) {
+        if (!Number.isFinite(time) || !Number.isFinite(idleSeconds) || idleSeconds < 0) {
+          this.reset();
+          return 0;
+        }
+        const active2 = recording || focused && idleSeconds < 60;
+        const previous = this.previous;
+        this.previous = { time, active: active2 };
+        if (!previous || !previous.active || !active2)
+          return 0;
+        const delta = time - previous.time;
+        return delta > 0 && delta <= 15e3 ? Math.floor(delta) : 0;
+      }
+      reset() {
+        this.previous = null;
+      }
+    };
+    exports.ActiveClock = ActiveClock;
+  }
+});
+
+// vendor/odd-core-analytics/dist/privacy/client.js
+var require_client = __commonJS({
+  "vendor/odd-core-analytics/dist/privacy/client.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PrivacyClient = void 0;
+    var schema_1 = require_schema();
+    var WEEK = 7 * 864e5;
+    var empty2 = () => ({ consent: { usage: false, diagnostics: false }, id: "", usage: [], diagnostics: [] });
+    var PrivacyClient2 = class _PrivacyClient {
+      constructor(options) {
+        this.options = options;
+        this.state = empty2();
+        this.serial = Promise.resolve();
+        this.generation = { usage: 0, diagnostics: 0 };
+        this.sending = {};
+        this.options = { ...options };
+        if (!/^[a-z][a-z0-9-]{0,63}$/.test(options.app) || ![options.usageAlias, options.diagnosticsAlias].every((v) => /^[a-zA-Z0-9_-]{1,128}$/.test(v)) || options.features.length > 64 || !options.features.every((v) => /^[a-z][a-z0-9_]{0,63}$/.test(v)))
+          throw new Error("Invalid static app configuration");
+        if (options.appVersion !== void 0 && !/^\d{1,4}\.\d{1,4}\.\d{1,4}$/.test(options.appVersion))
+          throw new Error("Invalid app version");
+        if (options.platform !== void 0 && !schema_1.PLATFORMS.includes(options.platform))
+          throw new Error("Invalid platform");
+        this.features = [...options.features];
+        this.frames = [...options.frames ?? schema_1.DEFAULT_FRAMES];
+        if (this.frames.length > 16 || !this.frames.every((v) => /^app:\/\/\/[a-zA-Z0-9_/-]+\.(js|ts|swift|kt|dart)$/.test(v) && !v.includes("..")))
+          throw new Error("Invalid logical source configuration");
+        this.origin = (0, schema_1.collectorOrigin)(options.collector ?? schema_1.DEFAULT_COLLECTOR);
+        this.key = `odd-privacy-v1:${options.app}`;
+        this.now = options.now ?? Date.now;
+      }
+      static async create(options) {
+        const client = new _PrivacyClient(options);
+        try {
+          const input = (0, schema_1.record)(JSON.parse(await options.storage.getItem(client.key) ?? "null"));
+          if (!input || input.binding !== client.binding())
+            return client;
+          const consent = (0, schema_1.record)(input.consent);
+          client.state.consent.diagnostics = consent?.diagnostics === true;
+          client.state.consent.usage = consent?.usage === true && typeof input.id === "string" && schema_1.UUID.test(input.id);
+          client.state.id = client.state.consent.usage ? input.id : "";
+          for (const kind of ["usage", "diagnostics"]) {
+            if (!client.state.consent[kind] || !Array.isArray(input[kind]))
+              continue;
+            for (const raw of input[kind].slice(-500)) {
+              const row = (0, schema_1.record)(raw);
+              const metric = client.sanitize(kind, row?.metric);
+              if (row && metric && typeof row.uuid === "string" && schema_1.UUID.test(row.uuid) && client.fresh(row.timestamp)) {
+                client.state[kind].push({ uuid: row.uuid, timestamp: new Date(Date.parse(row.timestamp)).toISOString(), metric });
+              }
+            }
+          }
+          await client.persist();
+        } catch {
+          client.state = empty2();
+        }
+        return client;
+      }
+      binding() {
+        return JSON.stringify([this.origin, this.options.app, this.options.usageAlias, this.options.diagnosticsAlias]);
+      }
+      fresh(time) {
+        const value = typeof time === "string" ? Date.parse(time) : NaN;
+        return Number.isFinite(value) && value <= this.now() && this.now() - value < WEEK;
+      }
+      sanitize(kind, input) {
+        return kind === "usage" ? (0, schema_1.sanitizeMetric)(input, this.features) : (0, schema_1.sanitizeDiagnostic)(input, this.frames);
+      }
+      uuid() {
+        const id = this.options.randomUUID();
+        if (typeof id !== "string" || !schema_1.UUID.test(id))
+          throw new Error("A cryptographic UUID provider is required");
+        return id;
+      }
+      run(fn) {
+        const next = this.serial.then(fn);
+        this.serial = next.catch(() => void 0);
+        return next;
+      }
+      async persist() {
+        try {
+          await this.options.storage.setItem(this.key, JSON.stringify({ binding: this.binding(), ...this.state }));
+          return true;
+        } catch {
+          this.state = empty2();
+          this.abort();
+          return false;
+        }
+      }
+      status() {
+        return { ...this.state.consent };
+      }
+      /** Call only after the app presents disclosure and records an explicit user choice. */
+      setConsent(update) {
+        for (const kind of ["usage", "diagnostics"])
+          if (update[kind] === false) {
+            this.generation[kind]++;
+            this.sending[kind]?.abort();
+          }
+        return this.run(async () => {
+          try {
+            for (const kind of ["usage", "diagnostics"])
+              if (typeof update[kind] === "boolean" && this.state.consent[kind] !== update[kind]) {
+                this.generation[kind]++;
+                this.sending[kind]?.abort();
+                this.state.consent[kind] = update[kind];
+                this.state[kind] = [];
+                if (kind === "usage")
+                  this.state.id = update[kind] ? this.uuid() : "";
+              }
+            return await this.persist();
+          } catch {
+            this.state = empty2();
+            this.abort();
+            return false;
+          }
+        });
+      }
+      track(input) {
+        return this.enqueue("usage", input);
+      }
+      report(input) {
+        return this.enqueue("diagnostics", input);
+      }
+      enqueue(kind, input) {
+        const metric = this.sanitize(kind, input);
+        const generation = this.generation[kind];
+        const allowed = this.state.consent[kind];
+        return this.run(async () => {
+          if (!allowed || !this.state.consent[kind] || generation !== this.generation[kind] || !metric)
+            return false;
+          try {
+            this.state[kind] = this.state[kind].filter((row) => this.fresh(row.timestamp)).slice(-499);
+            this.state[kind].push({ uuid: this.uuid(), timestamp: new Date(this.now()).toISOString(), metric });
+            return await this.persist();
+          } catch {
+            return false;
+          }
+        });
+      }
+      /** One bounded batch per channel; schedule retries in the app's lifecycle. */
+      async flush() {
+        await Promise.all([this.flushKind("usage"), this.flushKind("diagnostics")]);
+      }
+      async flushKind(kind) {
+        const requestedGeneration = this.generation[kind];
+        const pending = await this.run(async () => {
+          if (this.sending[kind] || !this.state.consent[kind] || requestedGeneration !== this.generation[kind])
+            return null;
+          const before = this.state[kind].length;
+          this.state[kind] = this.state[kind].filter((row) => this.fresh(row.timestamp));
+          if (before !== this.state[kind].length && !await this.persist())
+            return null;
+          const batch2 = this.state[kind].slice(0, kind === "usage" ? 50 : 10);
+          if (!batch2.length)
+            return null;
+          const controller2 = new AbortController();
+          this.sending[kind] = controller2;
+          return { batch: batch2, controller: controller2, generation: this.generation[kind], id: this.state.id };
+        });
+        if (!pending)
+          return;
+        const { batch, controller, generation, id } = pending;
+        const timer = setTimeout(() => controller.abort(), kind === "usage" ? 5e3 : 1e4);
+        try {
+          if (controller.signal.aborted)
+            return;
+          const response = await (this.options.send ?? fetch)(`${this.origin}/${kind === "usage" ? "batch" : "errors"}/`, {
+            method: "POST",
+            redirect: "error",
+            credentials: "omit",
+            referrerPolicy: "no-referrer",
+            signal: controller.signal,
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              api_key: kind === "usage" ? this.options.usageAlias : this.options.diagnosticsAlias,
+              batch: batch.map((row) => kind === "diagnostics" ? { uuid: row.uuid, timestamp: row.timestamp, diagnostic: row.metric } : {
+                uuid: row.uuid,
+                timestamp: row.timestamp,
+                event: `app_${row.metric.event}`,
+                properties: {
+                  distinct_id: id,
+                  app: this.options.app,
+                  ...row.metric,
+                  ...this.options.appVersion ? { app_version: this.options.appVersion } : {},
+                  ...this.options.platform ? { app_platform: this.options.platform } : {},
+                  $process_person_profile: false,
+                  $geoip_disable: true
+                }
+              })
+            })
+          });
+          if (response.ok)
+            await this.run(async () => {
+              if (generation !== this.generation[kind])
+                return;
+              const sent = new Set(batch.map((row) => row.uuid));
+              this.state[kind] = this.state[kind].filter((row) => !sent.has(row.uuid));
+              await this.persist();
+            });
+          await response.body?.cancel();
+        } catch {
+        } finally {
+          clearTimeout(timer);
+          if (this.sending[kind] === controller)
+            delete this.sending[kind];
+        }
+      }
+      abort() {
+        this.sending.usage?.abort();
+        this.sending.diagnostics?.abort();
+      }
+    };
+    exports.PrivacyClient = PrivacyClient2;
+  }
+});
+
+// vendor/odd-core-analytics/dist/privacy/index.js
+var require_privacy = __commonJS({
+  "vendor/odd-core-analytics/dist/privacy/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_schema(), exports);
+    __exportStar(require_client(), exports);
+  }
+});
+
+// src/config.ts
+import { readFile, mkdir, rename } from "fs/promises";
+import { open } from "fs/promises";
 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 join(xdgCache || join(homedir(), ".cache"), "exe-watcher");
+import { randomBytes } from "crypto";
+function getConfigDir() {
+  const xdgConfig = process.env["XDG_CONFIG_HOME"];
+  return join(xdgConfig || join(homedir(), ".config"), "exe-watcher");
 }
-var init_cache_dir = __esm({
-  "src/cache-dir.ts"() {
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+async function readConfig() {
+  try {
+    const raw = await readFile(getConfigPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(config) {
+  await mkdir(getConfigDir(), { recursive: true });
+  const configPath = getConfigPath();
+  const tmpPath = `${configPath}.${randomBytes(8).toString("hex")}.tmp`;
+  const handle = await open(tmpPath, "w", 384);
+  try {
+    await handle.writeFile(JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8" });
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await rename(tmpPath, configPath);
+}
+async function readPlan() {
+  const config = await readConfig();
+  return config.plan;
+}
+async function savePlan(plan) {
+  const config = await readConfig();
+  config.plan = plan;
+  await saveConfig(config);
+}
+async function clearPlan() {
+  const config = await readConfig();
+  delete config.plan;
+  await saveConfig(config);
+}
+function getConfigFilePath() {
+  return getConfigPath();
+}
+var init_config = __esm({
+  "src/config.ts"() {
     "use strict";
   }
 });
 
 // src/file-lock.ts
-import { mkdir, open, readFile, stat, unlink } from "fs/promises";
+import { mkdir as mkdir2, open as open2, readFile as readFile2, stat, unlink } from "fs/promises";
 import { dirname } from "path";
 async function acquireFileLock(path, timeoutMs = 15e3) {
-  await mkdir(dirname(path), { recursive: true });
+  await mkdir2(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);
+      const handle = await open2(path, "wx", 384);
       await handle.writeFile(token);
       await handle.close();
       return async () => {
-        if (await readFile(path, "utf8").catch(() => "") === token) await unlink(path).catch(() => {
+        if (await readFile2(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);
+    const reaper = await open2(reaperPath, "wx", 384).catch(() => null);
     if (reaper) {
       try {
         await reaper.writeFile(token);
-        const owner = await readFile(path, "utf8").catch(() => "");
+        const owner = await readFile2(path, "utf8").catch(() => "");
         const pid = Number(owner.split(":")[0]);
         let dead = false;
         if (pid > 0) {
@@ -69,7 +466,7 @@ async function acquireFileLock(path, timeoutMs = 15e3) {
         });
       }
     } else {
-      const owner = await readFile(reaperPath, "utf8").catch(() => "");
+      const owner = await readFile2(reaperPath, "utf8").catch(() => "");
       const pid = Number(owner.split(":")[0]);
       let dead = false;
       if (pid > 0) {
@@ -82,7 +479,7 @@ async function acquireFileLock(path, timeoutMs = 15e3) {
         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 (dead && await readFile2(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.");
@@ -95,6 +492,21 @@ var init_file_lock = __esm({
   }
 });
 
+// src/cache-dir.ts
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+function getCacheDir() {
+  const explicit = process.env["EXE_WATCHER_CACHE_DIR"];
+  if (explicit) return explicit;
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  return join3(xdgCache || join3(homedir2(), ".cache"), "exe-watcher");
+}
+var init_cache_dir = __esm({
+  "src/cache-dir.ts"() {
+    "use strict";
+  }
+});
+
 // src/resource-budget.ts
 import { getHeapStatistics } from "v8";
 import { AsyncLocalStorage } from "async_hooks";
@@ -174,66 +586,9 @@ var init_types = __esm({
   }
 });
 
-// src/config.ts
-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";
-function getConfigDir() {
-  const xdgConfig = process.env["XDG_CONFIG_HOME"];
-  return join3(xdgConfig || join3(homedir3(), ".config"), "exe-watcher");
-}
-function getConfigPath() {
-  return join3(getConfigDir(), "config.json");
-}
-async function readConfig() {
-  try {
-    const raw = await readFile2(getConfigPath(), "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-async function saveConfig(config) {
-  await mkdir3(getConfigDir(), { recursive: true });
-  const configPath = getConfigPath();
-  const tmpPath = `${configPath}.${randomBytes(8).toString("hex")}.tmp`;
-  const handle = await open2(tmpPath, "w", 384);
-  try {
-    await handle.writeFile(JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8" });
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  await rename2(tmpPath, configPath);
-}
-async function readPlan() {
-  const config = await readConfig();
-  return config.plan;
-}
-async function savePlan(plan) {
-  const config = await readConfig();
-  config.plan = plan;
-  await saveConfig(config);
-}
-async function clearPlan() {
-  const config = await readConfig();
-  delete config.plan;
-  await saveConfig(config);
-}
-function getConfigFilePath() {
-  return getConfigPath();
-}
-var init_config = __esm({
-  "src/config.ts"() {
-    "use strict";
-  }
-});
-
 // src/compare-stats.ts
-import { readdir, readFile as readFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { readdir, readFile as readFile5 } from "fs/promises";
+import { join as join6 } from "path";
 function aggregateModelStats(projects) {
   const byModel = /* @__PURE__ */ new Map();
   const ensure = (model) => {
@@ -404,12 +759,12 @@ async function collectJsonlFiles(sessionDir) {
   const files = [];
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".jsonl") && !isCompactFile(entry.name)) {
-      files.push(join5(sessionDir, entry.name));
+      files.push(join6(sessionDir, entry.name));
     } else if (entry.isDirectory() && entry.name === "subagents") {
-      const subEntries = await readdir(join5(sessionDir, entry.name), { withFileTypes: true });
+      const subEntries = await readdir(join6(sessionDir, entry.name), { withFileTypes: true });
       for (const sub of subEntries) {
         if (sub.isFile() && sub.name.endsWith(".jsonl") && !isCompactFile(sub.name)) {
-          files.push(join5(sessionDir, entry.name, sub.name));
+          files.push(join6(sessionDir, entry.name, sub.name));
         }
       }
     }
@@ -429,10 +784,10 @@ async function scanSelfCorrections(projectDirs) {
     const allFiles = [];
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".jsonl") && !isCompactFile(entry.name)) {
-        allFiles.push(join5(dir, entry.name));
+        allFiles.push(join6(dir, entry.name));
       } else if (entry.isDirectory()) {
         try {
-          const sessionFiles = await collectJsonlFiles(join5(dir, entry.name));
+          const sessionFiles = await collectJsonlFiles(join6(dir, entry.name));
           allFiles.push(...sessionFiles);
         } catch {
           continue;
@@ -442,7 +797,7 @@ async function scanSelfCorrections(projectDirs) {
     for (const file of allFiles) {
       let raw;
       try {
-        raw = await readFile4(file, "utf8");
+        raw = await readFile5(file, "utf8");
       } catch {
         continue;
       }
@@ -2116,9 +2471,9 @@ var init_verified_pricing = __esm({
 });
 
 // src/models.ts
-import { readFile as readFile5, mkdir as mkdir6, rename as rename4, unlink as unlink3 } from "fs/promises";
+import { readFile as readFile6, mkdir as mkdir7, rename as rename5, unlink as unlink4 } from "fs/promises";
 import { open as open4 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { createHash, randomBytes as randomBytes3 } from "crypto";
 function getPricingWarnings() {
   return _pricingWarnings;
@@ -2134,10 +2489,10 @@ function getPricingMetadata() {
   };
 }
 function getCachePath() {
-  return join7(getCacheDir(), "litellm-pricing.json");
+  return join8(getCacheDir(), "litellm-pricing.json");
 }
 function getLastKnownGoodPath() {
-  return join7(getCacheDir(), "pricing-cache.json");
+  return join8(getCacheDir(), "pricing-cache.json");
 }
 function parseLiteLLMEntry(entry) {
   if (entry.input_cost_per_token === void 0 || entry.output_cost_per_token === void 0) return null;
@@ -2190,7 +2545,7 @@ async function fetchAndCachePricing() {
     for (const [name, costs2] of official.value.models) pricing.set(name, costs2);
   }
   if (!pricing.size) throw new Error("No pricing sources available");
-  await mkdir6(getCacheDir(), { recursive: true });
+  await mkdir7(getCacheDir(), { recursive: true });
   const finalPath = getCachePath();
   const tmpPath = `${finalPath}.${randomBytes3(8).toString("hex")}.tmp`;
   const handle = await open4(tmpPath, "w", 384);
@@ -2206,10 +2561,10 @@ async function fetchAndCachePricing() {
     await handle.close();
   }
   try {
-    await rename4(tmpPath, finalPath);
+    await rename5(tmpPath, finalPath);
   } catch (err) {
     try {
-      await unlink3(tmpPath);
+      await unlink4(tmpPath);
     } catch {
     }
     throw err;
@@ -2229,9 +2584,9 @@ async function fetchAndCachePricing() {
     } finally {
       await lkgHandle.close();
     }
-    await rename4(lkgTmp, lkgPath).catch(() => {
+    await rename5(lkgTmp, lkgPath).catch(() => {
       try {
-        unlink3(lkgTmp);
+        unlink4(lkgTmp);
       } catch {
       }
     });
@@ -2241,7 +2596,7 @@ async function fetchAndCachePricing() {
 }
 async function loadCachedPricing() {
   try {
-    const raw = await readFile5(getCachePath(), "utf-8");
+    const raw = await readFile6(getCachePath(), "utf-8");
     const cached = JSON.parse(raw);
     if (cached.schemaVersion !== PRICING_CACHE_SCHEMA) return null;
     if (Date.now() - cached.timestamp > CACHE_TTL_MS2) return null;
@@ -2253,7 +2608,7 @@ async function loadCachedPricing() {
 }
 async function loadLastKnownGoodPricing() {
   try {
-    const raw = await readFile5(getLastKnownGoodPath(), "utf-8");
+    const raw = await readFile6(getLastKnownGoodPath(), "utf-8");
     const cached = JSON.parse(raw);
     if (cached.schemaVersion !== PRICING_CACHE_SCHEMA) return null;
     _pricingWarnings.push(...cached.warnings ?? []);
@@ -2545,11 +2900,11 @@ var init_models = __esm({
 });
 
 // src/discovery-cache.ts
-import { randomUUID } from "crypto";
-import { mkdir as mkdir7, readFile as readFile6, rename as rename5, stat as stat4, unlink as unlink4, writeFile as writeFile2 } from "fs/promises";
-import { join as join8 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir8, readFile as readFile7, rename as rename6, stat as stat4, unlink as unlink5, writeFile as writeFile3 } from "fs/promises";
+import { join as join9 } from "path";
 function manifestPath() {
-  return join8(getCacheDir(), MANIFEST);
+  return join9(getCacheDir(), MANIFEST);
 }
 function fingerprintOf(s) {
   return [s.dev, s.ino, s.size, s.mtimeMs, s.ctimeMs].join(":");
@@ -2581,7 +2936,7 @@ async function load() {
     const s = await stat4(path);
     if (s.size > MAX_MANIFEST_BYTES) return loaded;
     chargeRead(s.size);
-    loaded = sanitize(JSON.parse(await readFile6(path, "utf8")));
+    loaded = sanitize(JSON.parse(await readFile7(path, "utf8")));
   } catch (err) {
     if (err instanceof ResourceBudgetError) throw err;
   }
@@ -2639,10 +2994,10 @@ async function flushDiscoveryCache() {
   const path = manifestPath();
   const dir = getCacheDir();
   try {
-    await mkdir7(dir, { recursive: true });
-    const release = await acquireFileLock(join8(dir, "discovery-index.lock"));
+    await mkdir8(dir, { recursive: true });
+    const release = await acquireFileLock(join9(dir, "discovery-index.lock"));
     try {
-      const onDisk = await readFile6(path, "utf8").then((raw) => sanitize(JSON.parse(raw))).catch(() => emptyManifest());
+      const onDisk = await readFile7(path, "utf8").then((raw) => sanitize(JSON.parse(raw))).catch(() => emptyManifest());
       for (const [key2, entry] of Object.entries(mine.e)) {
         const other = onDisk.e[key2];
         if (!other || other.t <= entry.t) onDisk.e[key2] = entry;
@@ -2650,12 +3005,12 @@ async function flushDiscoveryCache() {
       evict(onDisk);
       const payload = JSON.stringify(onDisk);
       if (Buffer.byteLength(payload) > MAX_MANIFEST_BYTES) return;
-      const tmp = `${path}.${randomUUID()}.tmp`;
+      const tmp = `${path}.${randomUUID2()}.tmp`;
       try {
-        await writeFile2(tmp, payload, { mode: 384 });
-        await rename5(tmp, path);
+        await writeFile3(tmp, payload, { mode: 384 });
+        await rename6(tmp, path);
       } finally {
-        await unlink4(tmp).catch(() => {
+        await unlink5(tmp).catch(() => {
         });
       }
       loaded = onDisk;
@@ -2771,10 +3126,10 @@ var init_sqlite = __esm({
 import { createHash as createHash2 } from "crypto";
 import { createRequire as createRequire2 } from "module";
 import { chmodSync, existsSync, lstatSync, mkdirSync } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function database() {
   const directory = getCacheDir();
-  const path = join9(directory, "recorded-costs.sqlite");
+  const path = join10(directory, "recorded-costs.sqlite");
   if (opened?.path === path && existsSync(path)) return opened.db;
   opened?.db.close();
   opened = void 0;
@@ -2867,9 +3222,9 @@ var init_recorded_costs = __esm({
 // src/parsed-file-cache.ts
 import { gzip, gunzip } from "zlib";
 import { promisify } from "util";
-import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir8, readFile as readFile7, stat as stat5, writeFile as writeFile3, rename as rename6, unlink as unlink5, readdir as readdir3 } from "fs/promises";
-import { join as join10 } from "path";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir9, readFile as readFile8, stat as stat5, writeFile as writeFile4, rename as rename7, unlink as unlink6, readdir as readdir3 } from "fs/promises";
+import { join as join11 } from "path";
 function encodeEntry(value) {
   let bytes = 0;
   try {
@@ -2892,7 +3247,7 @@ function fileProgress(path, dir, cachePath, before) {
         const size = (await stat5(cachePath)).size;
         if (size > MAX_ENTRY) return;
         chargeRead(size);
-        const saved = JSON.parse((await decompress(await readFile7(cachePath), { maxOutputLength: MAX_ENTRY })).toString("utf8"));
+        const saved = JSON.parse((await decompress(await readFile8(cachePath), { maxOutputLength: MAX_ENTRY })).toString("utf8"));
         if (saved.v !== VERSION2 || saved.fingerprint !== before || !Number.isSafeInteger(saved.offset) || saved.offset <= 0 || saved.offset > Number(before.split(":")[2]) || !valid(saved.state)) return;
         startingOffset = saved.offset;
         return { offset: saved.offset, state: saved.state };
@@ -2917,12 +3272,12 @@ async function fingerprint(path) {
   }
 }
 async function cachedFileParse(path, kind, parse, warnings, range) {
-  const dir = join10(getCacheDir(), "parsed-files");
+  const dir = join11(getCacheDir(), "parsed-files");
   const key2 = createHash3("sha256").update(`${VERSION2}:${kind}:${path}`).digest("hex");
-  const cachePath = join10(dir, `v${VERSION2}-${key2}.json.gz`);
-  const progressPath = join10(dir, `v${VERSION2}-progress-${key2}.json.gz`);
+  const cachePath = join11(dir, `v${VERSION2}-${key2}.json.gz`);
+  const progressPath = join11(dir, `v${VERSION2}-progress-${key2}.json.gz`);
   const legacyKey = createHash3("sha256").update(`3:${kind}:${path}:${getPricingFingerprint()}`).digest("hex");
-  const legacyPath = join10(dir, `v3-${legacyKey}.json.gz`);
+  const legacyPath = join11(dir, `v3-${legacyKey}.json.gz`);
   const fingerprintPath = kind === "opencode" ? path.slice(0, path.lastIndexOf(":")) : path;
   const before = await fingerprint(fingerprintPath);
   const rangeKind = `usage-range:3:${kind}`;
@@ -2950,7 +3305,7 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
         const s = await stat5(candidate);
         if (s.size <= MAX_ENTRY) {
           chargeRead(s.size);
-          const saved = JSON.parse((await decompress(await readFile7(candidate), { maxOutputLength: MAX_ENTRY })).toString("utf8"));
+          const saved = JSON.parse((await decompress(await readFile8(candidate), { maxOutputLength: MAX_ENTRY })).toString("utf8"));
           if ((saved.v === VERSION2 || saved.v === 3) && saved.fingerprint === before && Array.isArray(saved.data)) {
             if (Array.isArray(saved.warnings)) warnings?.push(...saved.warnings.filter((w) => typeof w === "string"));
             await rememberRange(saved.data);
@@ -2984,20 +3339,20 @@ async function cachedFileParse(path, kind, parse, warnings, range) {
   return data;
 }
 async function storeParsedEntry(dir, cachePath, payload, obsolete) {
-  await mkdir8(dir, { recursive: true });
+  await mkdir9(dir, { recursive: true });
   const encoded = await compress(Buffer.from(payload));
-  const release = await acquireFileLock(join10(dir, "writes.lock"));
+  const release = await acquireFileLock(join11(dir, "writes.lock"));
   try {
-    const quotaPath = join10(dir, "quota");
-    const quota = await readFile7(quotaPath, "utf8").catch(() => "");
+    const quotaPath = join11(dir, "quota");
+    const quota = await readFile8(quotaPath, "utf8").catch(() => "");
     let total = /^\d+$/.test(quota) ? Number(quota) : NaN;
     const writeQuota = async (bytes) => {
-      const tmp = `${quotaPath}.${randomUUID2()}.tmp`;
+      const tmp = `${quotaPath}.${randomUUID3()}.tmp`;
       try {
-        await writeFile3(tmp, String(bytes), { mode: 384 });
-        await rename6(tmp, quotaPath);
+        await writeFile4(tmp, String(bytes), { mode: 384 });
+        await rename7(tmp, quotaPath);
       } finally {
-        await unlink5(tmp).catch(() => {
+        await unlink6(tmp).catch(() => {
         });
       }
     };
@@ -3007,23 +3362,23 @@ async function storeParsedEntry(dir, cachePath, payload, obsolete) {
       for (const name of files) {
         if (!name.endsWith(".json") && !name.endsWith(".json.gz") && !name.endsWith(".tmp")) continue;
         if (!name.startsWith(`v${VERSION2}-`) && !name.startsWith("v3-")) {
-          await unlink5(join10(dir, name)).catch(() => {
+          await unlink6(join11(dir, name)).catch(() => {
           });
           continue;
         }
-        const p = join10(dir, name), s = await stat5(p).catch(() => null);
+        const p = join11(dir, name), s = await stat5(p).catch(() => null);
         if (s) rows2.push({ path: p, size: s.size, mtime: s.mtimeMs });
       }
       total = rows2.reduce((n, r) => n + r.size, 0);
       for (const row of rows2.sort((a, b) => a.mtime - b.mtime)) {
         if (total <= MAX_DISK) break;
-        await unlink5(row.path).catch(() => {
+        await unlink6(row.path).catch(() => {
         });
         total -= row.size;
       }
       await writeQuota(total);
     }
-    if (!(await readFile7(cachePath).catch(() => Buffer.alloc(0))).equals(encoded)) {
+    if (!(await readFile8(cachePath).catch(() => Buffer.alloc(0))).equals(encoded)) {
       const oldSize = (await stat5(cachePath).catch(() => null))?.size ?? 0;
       let nextSize = total + encoded.length;
       if (!Number.isFinite(nextSize)) return;
@@ -3031,36 +3386,36 @@ async function storeParsedEntry(dir, cachePath, payload, obsolete) {
         const rows2 = [];
         for (const name of await readdir3(dir)) {
           if (!name.endsWith(".json.gz")) continue;
-          const p = join10(dir, name);
+          const p = join11(dir, name);
           if (p === cachePath) continue;
           const s = await stat5(p).catch(() => null);
           if (s) rows2.push({ path: p, size: s.size, mtime: s.mtimeMs });
         }
         for (const row of rows2.sort((a, b) => a.mtime - b.mtime)) {
           if (nextSize <= MAX_DISK * 0.75) break;
-          await unlink5(row.path).catch(() => {
+          await unlink6(row.path).catch(() => {
           });
           nextSize -= row.size;
         }
         if (nextSize > MAX_DISK) return;
       }
-      const tmp = `${cachePath}.${randomUUID2()}.tmp`;
+      const tmp = `${cachePath}.${randomUUID3()}.tmp`;
       try {
         await writeQuota(nextSize);
-        await writeFile3(tmp, encoded, { mode: 384 });
-        await rename6(tmp, cachePath);
+        await writeFile4(tmp, encoded, { mode: 384 });
+        await rename7(tmp, cachePath);
         mutationCount++;
         if (oldSize) await writeQuota(nextSize - oldSize);
         total = nextSize - oldSize;
       } finally {
-        await unlink5(tmp).catch(() => {
+        await unlink6(tmp).catch(() => {
         });
       }
     }
     if (obsolete) {
       const size = (await stat5(obsolete).catch(() => null))?.size ?? 0;
       if (size) {
-        await unlink5(obsolete);
+        await unlink6(obsolete);
         await writeQuota(Math.max(0, total - size));
       }
     }
@@ -3263,15 +3618,15 @@ var init_fs_utils = __esm({
 
 // src/providers/claude.ts
 import { readdir as readdir4, stat as stat6 } from "fs/promises";
-import { basename as basename2, join as join11, resolve as resolve2 } from "path";
+import { basename as basename2, join as join12, resolve as resolve2 } from "path";
 import { homedir as homedir4 } from "os";
 function getClaudeDir() {
-  return process.env["CLAUDE_CONFIG_DIR"] || join11(homedir4(), ".claude");
+  return process.env["CLAUDE_CONFIG_DIR"] || join12(homedir4(), ".claude");
 }
 function getDesktopSessionsDir() {
-  if (process.platform === "darwin") return join11(homedir4(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
-  if (process.platform === "win32") return join11(homedir4(), "AppData", "Roaming", "Claude", "local-agent-mode-sessions");
-  return join11(homedir4(), ".config", "Claude", "local-agent-mode-sessions");
+  if (process.platform === "darwin") return join12(homedir4(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+  if (process.platform === "win32") return join12(homedir4(), "AppData", "Roaming", "Claude", "local-agent-mode-sessions");
+  return join12(homedir4(), ".config", "Claude", "local-agent-mode-sessions");
 }
 async function findDesktopProjectDirs(base) {
   const results = [];
@@ -3280,13 +3635,13 @@ async function findDesktopProjectDirs(base) {
     const entries = await readdir4(dir).catch(() => []);
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join11(dir, entry);
+      const full = join12(dir, entry);
       const s = await stat6(full).catch(() => null);
       if (!s?.isDirectory()) continue;
       if (entry === "projects") {
         const projectDirs = await readdir4(full).catch(() => []);
         for (const pd of projectDirs) {
-          const pdFull = join11(full, pd);
+          const pdFull = join12(full, pd);
           const pdStat = await stat6(pdFull).catch(() => null);
           if (pdStat?.isDirectory()) results.push(pdFull);
         }
@@ -3340,11 +3695,11 @@ var init_claude = __esm({
         const config = await readConfig();
         const roots = /* @__PURE__ */ new Set([getClaudeDir(), ...config.claudeConfigDirs ?? []]);
         for (const root of roots) {
-          const projectsDir = join11(root.startsWith("~/") ? join11(homedir4(), root.slice(2)) : resolve2(root), "projects");
+          const projectsDir = join12(root.startsWith("~/") ? join12(homedir4(), root.slice(2)) : resolve2(root), "projects");
           try {
             const entries = await readdir4(projectsDir);
             for (const dirName of entries) {
-              const dirPath = join11(projectsDir, dirName);
+              const dirPath = join12(projectsDir, dirName);
               const dirStat = await stat6(dirPath).catch(() => null);
               if (dirStat?.isDirectory()) {
                 sources.push({ path: dirPath, project: dirName, provider: "claude" });
@@ -3371,10 +3726,10 @@ var init_claude = __esm({
 
 // src/providers/codex.ts
 import { readdir as readdir5, stat as stat7 } from "fs/promises";
-import { basename as basename3, join as join12 } from "path";
+import { basename as basename3, join as join13 } from "path";
 import { homedir as homedir5 } from "os";
 function getCodexDir(override) {
-  return override ?? process.env["CODEX_HOME"] ?? join12(homedir5(), ".codex");
+  return override ?? process.env["CODEX_HOME"] ?? join13(homedir5(), ".codex");
 }
 function sanitizeProject(cwd) {
   return cwd.replace(/^\//, "").replace(/\//g, "-");
@@ -3395,12 +3750,12 @@ async function readCodexHeader(filePath) {
   return { project: sanitizeProject(entry.payload?.cwd ?? "unknown") };
 }
 async function discoverSessionsInDir(codexDir) {
-  const sessionsDir = join12(codexDir, "sessions");
+  const sessionsDir = join13(codexDir, "sessions");
   const sources = [];
-  const archivedDir = join12(codexDir, "archived_sessions");
+  const archivedDir = join13(codexDir, "archived_sessions");
   for (const file of await readdir5(archivedDir).catch(() => [])) {
     if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-    const filePath = join12(archivedDir, file);
+    const filePath = join13(archivedDir, file);
     const s = await stat7(filePath).catch(() => null);
     if (!s?.isFile()) continue;
     const header = await cachedDiscoveryHeader("codex", filePath, s, () => readCodexHeader(filePath));
@@ -3414,19 +3769,19 @@ async function discoverSessionsInDir(codexDir) {
   }
   for (const year of years) {
     if (!/^\d{4}$/.test(year)) continue;
-    const yearDir = join12(sessionsDir, year);
+    const yearDir = join13(sessionsDir, year);
     const months = await readdir5(yearDir).catch(() => []);
     for (const month of months) {
       if (!/^\d{2}$/.test(month)) continue;
-      const monthDir = join12(yearDir, month);
+      const monthDir = join13(yearDir, month);
       const days = await readdir5(monthDir).catch(() => []);
       for (const day of days) {
         if (!/^\d{2}$/.test(day)) continue;
-        const dayDir = join12(monthDir, day);
+        const dayDir = join13(monthDir, day);
         const files = await readdir5(dayDir).catch(() => []);
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = join12(dayDir, file);
+          const filePath = join13(dayDir, file);
           const s = await stat7(filePath).catch(() => null);
           if (!s?.isFile()) continue;
           const header = await cachedDiscoveryHeader("codex", filePath, s, () => readCodexHeader(filePath));
@@ -3645,10 +4000,10 @@ var init_codex = __esm({
 
 // src/providers/copilot.ts
 import { readdir as readdir6, stat as stat8 } from "fs/promises";
-import { basename as basename4, dirname as dirname3, join as join13 } from "path";
+import { basename as basename4, dirname as dirname4, join as join14 } from "path";
 import { homedir as homedir6 } from "os";
 function getCopilotSessionStateDir(override) {
-  return override ?? join13(homedir6(), ".copilot", "session-state");
+  return override ?? join14(homedir6(), ".copilot", "session-state");
 }
 function parseCwd(yaml) {
   const match = yaml.match(/^cwd:\s*(.+)$/m);
@@ -3659,7 +4014,7 @@ function parseCwd(yaml) {
 function createParser2(source, seenKeys) {
   return {
     async *parse() {
-      const sessionId = basename4(dirname3(source.path));
+      const sessionId = basename4(dirname4(source.path));
       let currentModel = "";
       let pendingUserMessage = "";
       let lineCount = 0;
@@ -3723,11 +4078,11 @@ async function discoverSessionsInDir2(sessionStateDir) {
     return sources;
   }
   for (const sessionId of sessionDirs) {
-    const eventsPath = join13(sessionStateDir, sessionId, "events.jsonl");
+    const eventsPath = join14(sessionStateDir, sessionId, "events.jsonl");
     const s = await stat8(eventsPath).catch(() => null);
     if (!s?.isFile()) continue;
     let project = sessionId;
-    const yaml = await readSessionFile(join13(sessionStateDir, sessionId, "workspace.yaml"));
+    const yaml = await readSessionFile(join14(sessionStateDir, sessionId, "workspace.yaml"));
     if (yaml !== null) {
       const cwd = parseCwd(yaml);
       if (cwd) project = basename4(cwd);
@@ -3841,13 +4196,13 @@ var init_bash_utils = __esm({
 
 // src/providers/pi.ts
 import { readdir as readdir7, stat as stat9 } from "fs/promises";
-import { basename as basename6, join as join14 } from "path";
+import { basename as basename6, join as join15 } from "path";
 import { homedir as homedir7 } from "os";
 function getPiSessionsDir(override) {
-  return override ?? join14(homedir7(), ".pi", "agent", "sessions");
+  return override ?? join15(homedir7(), ".pi", "agent", "sessions");
 }
 function getOmpSessionsDir(override) {
-  return override ?? join14(homedir7(), ".omp", "agent", "sessions");
+  return override ?? join15(homedir7(), ".omp", "agent", "sessions");
 }
 async function readFirstEntry(filePath) {
   const line = await readSessionFirstLine(filePath);
@@ -3867,7 +4222,7 @@ async function discoverSessionsInDir3(sessionsDir, providerName) {
     return sources;
   }
   for (const dirName of projectDirs) {
-    const dirPath = join14(sessionsDir, dirName);
+    const dirPath = join15(sessionsDir, dirName);
     const dirStat = await stat9(dirPath).catch(() => null);
     if (!dirStat?.isDirectory()) continue;
     let files;
@@ -3878,7 +4233,7 @@ async function discoverSessionsInDir3(sessionsDir, providerName) {
     }
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = join14(dirPath, file);
+      const filePath = join15(dirPath, file);
       const fileStat = await stat9(filePath).catch(() => null);
       if (!fileStat?.isFile()) continue;
       const first = await readFirstEntry(filePath);
@@ -4036,11 +4391,11 @@ var init_pi = __esm({
 
 // src/providers/kimi.ts
 import { createHash as createHash4 } from "crypto";
-import { readdir as readdir8, readFile as readFile8, stat as stat10 } from "fs/promises";
-import { basename as basename7, dirname as dirname4, join as join15 } from "path";
+import { readdir as readdir8, readFile as readFile9, stat as stat10 } from "fs/promises";
+import { basename as basename7, dirname as dirname5, join as join16 } from "path";
 import { homedir as homedir8 } from "os";
 function createKimiProvider(home) {
-  const root = () => home ?? process.env["KIMI_CODE_HOME"] ?? join15(homedir8(), ".kimi-code");
+  const root = () => home ?? process.env["KIMI_CODE_HOME"] ?? join16(homedir8(), ".kimi-code");
   return {
     name: "kimi",
     displayName: "Kimi",
@@ -4048,12 +4403,12 @@ function createKimiProvider(home) {
     toolDisplayName: (tool) => tool,
     async discoverSessions() {
       const projects = /* @__PURE__ */ new Map();
-      const catalog = join15(root(), "workspaces.json");
+      const catalog = join16(root(), "workspaces.json");
       try {
         const size = (await stat10(catalog)).size;
         if (size <= 2 * 1024 * 1024) {
           chargeRead(size);
-          const data = JSON.parse(await readFile8(catalog, "utf8"));
+          const data = JSON.parse(await readFile9(catalog, "utf8"));
           for (const [id, entry] of Object.entries(data.workspaces ?? {})) {
             if (entry && typeof entry === "object" && "root" in entry && typeof entry.root === "string") {
               projects.set(id, basename7(entry.root));
@@ -4070,16 +4425,16 @@ function createKimiProvider(home) {
         const entries = await readdir8(dir, { withFileTypes: true }).catch(() => []);
         for (const entry of entries) {
           if (entry.name.startsWith(".")) continue;
-          const path = join15(dir, entry.name);
+          const path = join16(dir, entry.name);
           if (entry.isDirectory()) await walk(path, project, depth + 1);
           else if (entry.isFile() && entry.name === "wire.jsonl") sources.push({ path, project, provider: "kimi" });
         }
       }
-      const sessions = join15(root(), "sessions");
+      const sessions = join16(root(), "sessions");
       for (const entry of await readdir8(sessions, { withFileTypes: true }).catch(() => [])) {
         if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
         const project = projects.get(entry.name) ?? entry.name.replace(/^wd_/, "").replace(/_[a-f\d]{12}$/, "");
-        await walk(join15(sessions, entry.name), project, 0);
+        await walk(join16(sessions, entry.name), project, 0);
       }
       return sources.sort((a, b) => a.path.localeCompare(b.path));
     },
@@ -4088,8 +4443,8 @@ function createKimiProvider(home) {
       return {
         warnings,
         async *parse() {
-          const sessionDir = source.path.split("/").reverse().find((part) => part.startsWith("session_")) ?? basename7(dirname4(source.path));
-          const agent = basename7(dirname4(source.path));
+          const sessionDir = source.path.split("/").reverse().find((part) => part.startsWith("session_")) ?? basename7(dirname5(source.path));
+          const agent = basename7(dirname5(source.path));
           for await (const line of readSessionLines(source.path)) {
             if (!/"type"\s*:\s*"usage\.record"/.test(line.slice(0, 256))) continue;
             let data;
@@ -4166,12 +4521,12 @@ var init_kimi = __esm({
 });
 
 // src/cursor-cache.ts
-import { readFile as readFile9, mkdir as mkdir9, stat as stat11, rename as rename7 } from "fs/promises";
+import { readFile as readFile10, mkdir as mkdir10, stat as stat11, rename as rename8 } from "fs/promises";
 import { open as open6 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 function getCachePath2() {
-  return join16(getCacheDir(), CACHE_FILE);
+  return join17(getCacheDir(), CACHE_FILE);
 }
 async function getDbFingerprint(dbPath) {
   try {
@@ -4189,7 +4544,7 @@ async function readCachedResults(dbPath) {
     const size = (await stat11(getCachePath2())).size;
     if (size > 16 * 1024 * 1024) return null;
     chargeRead(size);
-    const raw = await readFile9(getCachePath2(), "utf-8");
+    const raw = await readFile10(getCachePath2(), "utf-8");
     const cache = JSON.parse(raw);
     if (cache.fingerprint === fp) {
       return cache.calls;
@@ -4205,7 +4560,7 @@ async function writeCachedResults(dbPath, calls, expected) {
     const fp = await getDbFingerprint(dbPath);
     if (!fp || expected !== void 0 && expected !== fp) return;
     const dir = getCacheDir();
-    await mkdir9(dir, { recursive: true });
+    await mkdir10(dir, { recursive: true });
     const cache = {
       fingerprint: fp,
       calls
@@ -4221,7 +4576,7 @@ async function writeCachedResults(dbPath, calls, expected) {
     } finally {
       await handle.close();
     }
-    await rename7(tmpPath, finalPath);
+    await rename8(tmpPath, finalPath);
   } catch {
   }
 }
@@ -4243,16 +4598,16 @@ __export(cursor_exports, {
   cursor: () => cursor
 });
 import { existsSync as existsSync2 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { homedir as homedir9 } from "os";
 function getCursorDbPath() {
   if (process.platform === "darwin") {
-    return join17(homedir9(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+    return join18(homedir9(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
   }
   if (process.platform === "win32") {
-    return join17(homedir9(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb");
+    return join18(homedir9(), "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb");
   }
-  return join17(homedir9(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+  return join18(homedir9(), ".config", "Cursor", "User", "globalStorage", "state.vscdb");
 }
 function extractLanguages(codeBlocksJson) {
   if (!codeBlocksJson) return [];
@@ -4495,19 +4850,19 @@ __export(opencode_exports, {
   opencode: () => opencode
 });
 import { readdir as readdir9 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { homedir as homedir10 } from "os";
 function sanitize2(dir) {
   return dir.replace(/^\//, "").replace(/\//g, "-");
 }
 function getDataDir(dataDir) {
-  const base = dataDir ?? process.env["XDG_DATA_HOME"] ?? join18(homedir10(), ".local", "share");
-  return join18(base, "opencode");
+  const base = dataDir ?? process.env["XDG_DATA_HOME"] ?? join19(homedir10(), ".local", "share");
+  return join19(base, "opencode");
 }
 async function findDbFiles(dir) {
   try {
     const entries = await readdir9(dir);
-    return entries.filter((f) => f.startsWith("opencode") && f.endsWith(".db")).map((f) => join18(dir, f));
+    return entries.filter((f) => f.startsWith("opencode") && f.endsWith(".db")).map((f) => join19(dir, f));
   } catch (error) {
     if (error instanceof ResourceBudgetError) throw error;
     return [];
@@ -4739,17 +5094,17 @@ __export(cursor_agent_exports, {
 import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync3 } from "fs";
 import { readdir as readdir10, stat as stat12 } from "fs/promises";
-import { join as join19, basename as basename8 } from "path";
+import { join as join20, basename as basename8 } from "path";
 import { homedir as homedir11 } from "os";
 function getCursorAgentBaseDir(baseDirOverride) {
   if (baseDirOverride) return baseDirOverride;
-  return join19(homedir11(), ".cursor");
+  return join20(homedir11(), ".cursor");
 }
 function getProjectsDir(baseDir) {
-  return join19(baseDir, "projects");
+  return join20(baseDir, "projects");
 }
 function getAttributionDbPath(baseDir) {
-  return join19(baseDir, "ai-tracking", "ai-code-tracking.db");
+  return join20(baseDir, "ai-tracking", "ai-code-tracking.db");
 }
 function estimateTokens(charCount) {
   if (charCount <= 0) return 0;
@@ -5008,13 +5363,13 @@ function createCursorAgentProvider(baseDirOverride) {
       for (const entry of projectEntries) {
         if (!entry.isDirectory()) continue;
         const projectId = prettifyProjectId(entry.name);
-        const transcriptDir = join19(projectsDir, entry.name, "agent-transcripts");
+        const transcriptDir = join20(projectsDir, entry.name, "agent-transcripts");
         if (!existsSync3(transcriptDir)) continue;
         const transcriptEntries = await readdir10(transcriptDir, { withFileTypes: true });
         for (const transcript of transcriptEntries) {
           if (!transcript.isFile()) continue;
           if (!transcript.name.endsWith(".txt")) continue;
-          const transcriptPath = join19(transcriptDir, transcript.name);
+          const transcriptPath = join20(transcriptDir, transcript.name);
           sources.push({
             path: transcriptPath,
             project: projectId,
@@ -5329,19 +5684,19 @@ var init_classifier = __esm({
 // src/session-index.ts
 import { stat as stat13 } from "fs/promises";
 import { existsSync as existsSync4, unlinkSync } from "fs";
-import { readFile as readFile11, mkdir as mkdir10, rename as rename8, unlink as unlink6, open as open7 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile12, mkdir as mkdir11, rename as rename9, unlink as unlink7, open as open7 } from "fs/promises";
+import { join as join21 } from "path";
 import { randomBytes as randomBytes5 } from "crypto";
 function emptyIndex() {
   return { v: SESSION_INDEX_VERSION, e: {} };
 }
 function indexPath() {
-  return join20(getCacheDir(), INDEX_FILENAME);
+  return join21(getCacheDir(), INDEX_FILENAME);
 }
 async function loadSessionIndex() {
   if (currentIndex) return currentIndex;
   try {
-    const raw = await readFile11(indexPath(), "utf-8");
+    const raw = await readFile12(indexPath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.v !== SESSION_INDEX_VERSION) {
       currentIndex = emptyIndex();
@@ -5356,7 +5711,7 @@ async function loadSessionIndex() {
 }
 async function saveSessionIndex(index) {
   const dir = getCacheDir();
-  if (!existsSync4(dir)) await mkdir10(dir, { recursive: true });
+  if (!existsSync4(dir)) await mkdir11(dir, { recursive: true });
   const finalPath = indexPath();
   const tempPath = `${finalPath}.${randomBytes5(8).toString("hex")}.tmp`;
   const payload = JSON.stringify(index);
@@ -5368,10 +5723,10 @@ async function saveSessionIndex(index) {
     await handle.close();
   }
   try {
-    await rename8(tempPath, finalPath);
+    await rename9(tempPath, finalPath);
   } catch (err) {
     try {
-      await unlink6(tempPath);
+      await unlink7(tempPath);
     } catch {
     }
     throw err;
@@ -5438,7 +5793,7 @@ __export(parser_exports, {
 });
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import { readdir as readdir11, stat as stat14 } from "fs/promises";
-import { basename as basename9, join as join21 } from "path";
+import { basename as basename9, join as join22 } from "path";
 function getParseWarnings() {
   return _parseWarnings;
 }
@@ -5752,13 +6107,13 @@ async function parseSessionFile(filePath, project, seenMsgIds, dateRange) {
 }
 async function collectJsonlFiles2(dirPath) {
   const files = await readdir11(dirPath).catch(() => []);
-  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).map((f) => join21(dirPath, f));
+  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).map((f) => join22(dirPath, f));
   for (const entry of files) {
     if (entry.endsWith(".jsonl")) continue;
-    const subagentsPath = join21(dirPath, entry, "subagents");
+    const subagentsPath = join22(dirPath, entry, "subagents");
     const subFiles = await readdir11(subagentsPath).catch(() => []);
     for (const sf of subFiles) {
-      if (sf.endsWith(".jsonl")) jsonlFiles.push(join21(subagentsPath, sf));
+      if (sf.endsWith(".jsonl")) jsonlFiles.push(join22(subagentsPath, sf));
     }
   }
   return jsonlFiles;
@@ -6120,21 +6475,199 @@ var init_parser = __esm({
   }
 });
 
+// src/telemetry.ts
+var import_privacy = __toESM(require_privacy(), 1);
+init_config();
+init_file_lock();
+import { randomUUID } from "crypto";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, unlink as unlink2, writeFile, chmod } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+var ALIAS = "public-watcher-cli-v1";
+var BASIC_NOTICE = "Watcher shares basic app activity (daily activity, foreground time, feature outcomes, app version and platform) with Odd\u2019s own servers. A random installation ID measures returning installations. Your content stays private. Turn off anytime: exe-watcher telemetry --usage off. Details: https://github.com/AskExe/exe-watcher#optional-analytics-and-error-reporting";
+var FEATURES = /* @__PURE__ */ new Set(["status", "report", "optimize", "compare", "export", "menubar", "plan", "currency", "agent-status"]);
+function resolveTelemetry(config = {}, env = process.env) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) return { usageEnabled: false, diagnosticsEnabled: false };
+  const disabled = config.enabled === false || env["EXE_WATCHER_TELEMETRY"] === "0" || env["DO_NOT_TRACK"] === "1" || Boolean(env["EXE_WATCHER_PARENT_PID"]);
+  return { usageEnabled: !disabled && (config.usageEnabled === void 0 || config.usageEnabled === true), diagnosticsEnabled: !disabled && config.diagnosticsEnabled === true };
+}
+function safeError(error, version2 = "0.0.0") {
+  return (0, import_privacy.sanitizeDiagnostic)({ event: "error", category: "unhandled_exception", error_class: error instanceof Error ? error.name : "Error", version: version2, frames: [] }, []);
+}
+var silent = () => ({ async capture(_event, _command, _success = true) {
+}, async error(_error) {
+}, async shutdown() {
+}, abort() {
+} });
+async function createTelemetry(config, version2, foreground = Boolean(process.stdin.isTTY)) {
+  if (process.env["EXE_WATCHER_PARENT_PID"]) return silent();
+  const initial = resolveTelemetry(config);
+  if (initial.usageEnabled && config?.usageEnabled === void 0 && config?.basicNoticeVersion !== 1 && config?.diagnosticsEnabled !== true) return silent();
+  const root = dirname2(getConfigFilePath()), directory = join2(root, "telemetry-cli"), file = join2(directory, "state.json");
+  if (!initial.usageEnabled && !initial.diagnosticsEnabled) {
+    try {
+      await readFile3(file);
+    } catch {
+      return silent();
+    }
+  }
+  let release;
+  try {
+    await mkdir3(directory, { recursive: true, mode: 448 });
+    await chmod(directory, 448);
+    release = await acquireFileLock(join2(directory, "owner.lock"), 0);
+    let firstId = false;
+    let installation;
+    if (initial.usageEnabled) {
+      const path = join2(root, "telemetry-id");
+      try {
+        await writeFile(path, randomUUID(), { flag: "wx", mode: 384 });
+      } catch (e) {
+        if (e.code !== "EEXIST") throw e;
+      }
+      const candidate = (await readFile3(path, "utf8")).trim();
+      if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(candidate)) installation = candidate;
+    } else if (config?.usageEnabled !== true) await unlink2(join2(root, "telemetry-id")).catch(() => {
+    });
+    const client = await import_privacy.PrivacyClient.create({
+      app: "watcher",
+      usageAlias: ALIAS,
+      diagnosticsAlias: ALIAS,
+      appVersion: /^\d{1,4}\.\d{1,4}\.\d{1,4}$/.test(version2) ? version2 : "0.0.0",
+      platform: process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : process.platform === "linux" ? "linux" : void 0,
+      features: [...FEATURES].map((name) => `cli_${name.replaceAll("-", "_")}`),
+      frames: [],
+      randomUUID: () => {
+        if (firstId) {
+          firstId = false;
+          return installation ?? randomUUID();
+        }
+        ;
+        return randomUUID();
+      },
+      storage: {
+        async getItem() {
+          try {
+            const data = await readFile3(file, "utf8");
+            return data.length <= 524288 ? data : null;
+          } catch {
+            return null;
+          }
+        },
+        async setItem(_key, value) {
+          const temp = `${file}.${randomUUID()}.tmp`;
+          try {
+            await writeFile(temp, value, { mode: 384, flag: "wx" });
+            await rename2(temp, file);
+          } finally {
+            await unlink2(temp).catch(() => {
+            });
+          }
+        }
+      },
+      send: (url, options) => fetch(url, { ...options, signal: AbortSignal.any([options.signal, AbortSignal.timeout(1500)]) })
+    });
+    const epochs = { usage: config?.usageEpoch ?? "initial", diagnostics: config?.diagnosticsEpoch ?? "initial" };
+    let prior = {};
+    try {
+      prior = JSON.parse(await readFile3(join2(directory, "consent.json"), "utf8"));
+    } catch {
+    }
+    if (prior.usage !== epochs.usage) await client.setConsent({ usage: false });
+    if (prior.diagnostics !== epochs.diagnostics) await client.setConsent({ diagnostics: false });
+    firstId = initial.usageEnabled && !client.status().usage;
+    await client.setConsent({ usage: initial.usageEnabled, diagnostics: initial.diagnosticsEnabled });
+    firstId = false;
+    const epochTemp = join2(directory, `${randomUUID()}.tmp`);
+    try {
+      await writeFile(epochTemp, JSON.stringify(epochs), { mode: 384, flag: "wx" });
+      await rename2(epochTemp, join2(directory, "consent.json"));
+    } finally {
+      await unlink2(epochTemp).catch(() => {
+      });
+    }
+    const syncConsent = async () => {
+      let current = { usageEnabled: false, diagnosticsEnabled: false };
+      let saved = {};
+      try {
+        saved = JSON.parse(await readFile3(getConfigFilePath(), "utf8")).telemetry ?? {};
+        current = resolveTelemetry(saved);
+      } catch (error) {
+        if (error.code === "ENOENT") current = resolveTelemetry(void 0);
+      }
+      if ((saved.usageEpoch ?? "initial") !== epochs.usage) current.usageEnabled = false;
+      if ((saved.diagnosticsEpoch ?? "initial") !== epochs.diagnostics) current.diagnosticsEnabled = false;
+      const status = client.status();
+      const usage = initial.usageEnabled && current.usageEnabled, diagnostics = initial.diagnosticsEnabled && current.diagnosticsEnabled;
+      if (status.usage !== usage || status.diagnostics !== diagnostics) await client.setConsent({ usage, diagnostics });
+    };
+    let marked = false, stopped = false;
+    return {
+      async capture(event, command, success = true) {
+        try {
+          await syncConsent();
+          if (!foreground || !FEATURES.has(command)) return;
+          const feature = `cli_${command.replaceAll("-", "_")}`;
+          if (event === "command_started") {
+            if (!marked) {
+              await client.track({ event: "active" });
+              marked = true;
+            }
+            await client.track({ event: "feature", feature });
+          } else if (event === "command_finished" && marked) {
+            await client.track({ event: "result", feature, outcome: success ? "success" : "failure" });
+          }
+        } catch {
+        }
+      },
+      async error(error) {
+        try {
+          await syncConsent();
+          await client.report(safeError(error, version2));
+        } catch {
+        }
+      },
+      async shutdown() {
+        if (stopped) return;
+        stopped = true;
+        const revocation = setInterval(() => {
+          void syncConsent().catch(() => {
+          });
+        }, 100);
+        try {
+          await syncConsent();
+          await client.flush();
+        } finally {
+          clearInterval(revocation);
+          client.abort();
+          await release?.();
+        }
+      },
+      abort() {
+        client.abort();
+      }
+    };
+  } catch {
+    await release?.().catch(() => {
+    });
+    return silent();
+  }
+}
+
 // src/cli.ts
 init_cache_dir();
 init_file_lock();
 init_resource_budget();
 import { existsSync as existsSync8, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
-import { join as join32 } from "path";
+import { dirname as dirname8, join as join33 } from "path";
 import { homedir as homedir17 } from "os";
 import { Command } from "commander";
 
 // src/menubar-installer.ts
 import { spawn } from "child_process";
 import { createWriteStream } from "fs";
-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 { cp, mkdir as mkdir4, mkdtemp, rename as rename3, rm, stat as stat2 } from "fs/promises";
+import { homedir as homedir3, platform, tmpdir } from "os";
+import { basename, join as join4 } 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";
@@ -6148,7 +6681,7 @@ var DEFAULT_APP_EXIT_TIMEOUT_MS = 5e3;
 var DEFAULT_APP_LAUNCH_TIMEOUT_MS = 5e3;
 var POLL_INTERVAL_MS = 150;
 function userApplicationsDir() {
-  return join2(homedir2(), "Applications");
+  return join4(homedir3(), "Applications");
 }
 async function exists(path) {
   try {
@@ -6294,7 +6827,7 @@ async function signalPids(signal, pids) {
 }
 async function movePath(source, dest) {
   try {
-    await rename(source, dest);
+    await rename3(source, dest);
   } catch (err) {
     if (err.code === "EXDEV") {
       await cp(source, dest, { recursive: true });
@@ -6333,7 +6866,7 @@ async function killRunningApp() {
 async function installMenubarApp(options = {}) {
   await ensureSupportedPlatform();
   const appsDir = userApplicationsDir();
-  const targetPath = join2(appsDir, APP_BUNDLE_NAME);
+  const targetPath = join4(appsDir, APP_BUNDLE_NAME);
   const alreadyInstalled = await exists(targetPath);
   if (alreadyInstalled && !options.force) {
     if (!await isAppRunning()) {
@@ -6343,21 +6876,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(join2(tmpdir(), "exe-watcher-menubar-"));
+  const stagingDir = await mkdtemp(join4(tmpdir(), "exe-watcher-menubar-"));
   try {
-    const archivePath = join2(stagingDir, asset.name);
+    const archivePath = join4(stagingDir, asset.name);
     console.log(`Downloading ${asset.name}...`);
     await downloadToFile(asset.browser_download_url, archivePath);
     console.log("Unpacking...");
     await runCommand("/usr/bin/ditto", ["-x", "-k", archivePath, stagingDir]);
-    const unpackedApp = join2(stagingDir, APP_BUNDLE_NAME);
+    const unpackedApp = join4(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 mkdir2(appsDir, { recursive: true });
-    const backupPath = alreadyInstalled ? join2(appsDir, `${basename(APP_BUNDLE_NAME, ".app")}.backup-${Date.now()}.app`) : void 0;
+    await mkdir4(appsDir, { recursive: true });
+    const backupPath = alreadyInstalled ? join4(appsDir, `${basename(APP_BUNDLE_NAME, ".app")}.backup-${Date.now()}.app`) : void 0;
     let targetReplaced = false;
     try {
       if (alreadyInstalled && backupPath) {
@@ -6391,15 +6924,15 @@ async function installMenubarApp(options = {}) {
 
 // src/export.ts
 init_types();
-import { writeFile, mkdir as mkdir5, readdir as readdir2, stat as stat3, rm as rm2 } from "fs/promises";
-import { dirname as dirname2, join as join6, resolve } from "path";
+import { writeFile as writeFile2, mkdir as mkdir6, readdir as readdir2, stat as stat3, rm as rm2 } from "fs/promises";
+import { dirname as dirname3, join as join7, resolve } from "path";
 
 // src/currency.ts
 init_cache_dir();
 init_config();
-import { readFile as readFile3, mkdir as mkdir4, rename as rename3, unlink as unlink2 } from "fs/promises";
+import { readFile as readFile4, mkdir as mkdir5, rename as rename4, unlink as unlink3 } from "fs/promises";
 import { open as open3 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var FRANKFURTER_URL = "https://api.frankfurter.app/latest?from=USD&to=";
@@ -6432,7 +6965,7 @@ function getFractionDigits(code) {
   }).resolvedOptions().maximumFractionDigits ?? 2;
 }
 function getRateCachePath() {
-  return join4(getCacheDir(), "exchange-rate.json");
+  return join5(getCacheDir(), "exchange-rate.json");
 }
 async function fetchRate(code) {
   const response = await fetch(`${FRANKFURTER_URL}${code}`, {
@@ -6446,7 +6979,7 @@ async function fetchRate(code) {
 }
 async function loadCachedRate(code) {
   try {
-    const raw = await readFile3(getRateCachePath(), "utf-8");
+    const raw = await readFile4(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;
@@ -6458,7 +6991,7 @@ async function loadCachedRate(code) {
   }
 }
 async function cacheRate(code, rate) {
-  await mkdir4(getCacheDir(), { recursive: true });
+  await mkdir5(getCacheDir(), { recursive: true });
   const finalPath = getRateCachePath();
   const tmpPath = `${finalPath}.${randomBytes2(8).toString("hex")}.tmp`;
   const handle = await open3(tmpPath, "w", 384);
@@ -6469,10 +7002,10 @@ async function cacheRate(code, rate) {
     await handle.close();
   }
   try {
-    await rename3(tmpPath, finalPath);
+    await rename4(tmpPath, finalPath);
   } catch (err) {
     try {
-      await unlink2(tmpPath);
+      await unlink3(tmpPath);
     } catch {
     }
     throw err;
@@ -6736,13 +7269,13 @@ function buildReadme(periods) {
 }
 var EXPORT_MARKER_FILE = ".exe-watcher-export";
 async function isExeWatcherExportFolder(path) {
-  const markerStat = await stat3(join6(path, EXPORT_MARKER_FILE)).catch(() => null);
+  const markerStat = await stat3(join7(path, EXPORT_MARKER_FILE)).catch(() => null);
   return markerStat?.isFile() ?? false;
 }
 async function clearExeWatcherExportFolder(path) {
   const entries = await readdir2(path);
   for (const entry of entries) {
-    await rm2(join6(path, entry), { recursive: true, force: true });
+    await rm2(join7(path, entry), { recursive: true, force: true });
   }
 }
 async function exportCsv(periods, outputPath) {
@@ -6764,20 +7297,20 @@ async function exportCsv(periods, outputPath) {
     }
     await clearExeWatcherExportFolder(folder);
   }
-  await mkdir5(folder, { recursive: true });
-  await writeFile(join6(folder, EXPORT_MARKER_FILE), "", "utf-8");
+  await mkdir6(folder, { recursive: true });
+  await writeFile2(join7(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));
   const modelRows = periods.flatMap((p) => buildModelRows(p.projects, p.label));
-  await writeFile(join6(folder, "README.txt"), buildReadme(periods), "utf-8");
-  await writeFile(join6(folder, "summary.csv"), rowsToCsv(buildSummaryRows(periods)), "utf-8");
-  await writeFile(join6(folder, "daily.csv"), rowsToCsv(dailyRows), "utf-8");
-  await writeFile(join6(folder, "activity.csv"), rowsToCsv(activityRows), "utf-8");
-  await writeFile(join6(folder, "models.csv"), rowsToCsv(modelRows), "utf-8");
-  await writeFile(join6(folder, "projects.csv"), rowsToCsv(buildProjectRows(thirtyDayProjects)), "utf-8");
-  await writeFile(join6(folder, "sessions.csv"), rowsToCsv(buildSessionRows(thirtyDayProjects)), "utf-8");
-  await writeFile(join6(folder, "tools.csv"), rowsToCsv(buildToolRows(thirtyDayProjects)), "utf-8");
-  await writeFile(join6(folder, "shell-commands.csv"), rowsToCsv(buildBashRows(thirtyDayProjects)), "utf-8");
+  await writeFile2(join7(folder, "README.txt"), buildReadme(periods), "utf-8");
+  await writeFile2(join7(folder, "summary.csv"), rowsToCsv(buildSummaryRows(periods)), "utf-8");
+  await writeFile2(join7(folder, "daily.csv"), rowsToCsv(dailyRows), "utf-8");
+  await writeFile2(join7(folder, "activity.csv"), rowsToCsv(activityRows), "utf-8");
+  await writeFile2(join7(folder, "models.csv"), rowsToCsv(modelRows), "utf-8");
+  await writeFile2(join7(folder, "projects.csv"), rowsToCsv(buildProjectRows(thirtyDayProjects)), "utf-8");
+  await writeFile2(join7(folder, "sessions.csv"), rowsToCsv(buildSessionRows(thirtyDayProjects)), "utf-8");
+  await writeFile2(join7(folder, "tools.csv"), rowsToCsv(buildToolRows(thirtyDayProjects)), "utf-8");
+  await writeFile2(join7(folder, "shell-commands.csv"), rowsToCsv(buildBashRows(thirtyDayProjects)), "utf-8");
   return folder;
 }
 async function exportJson(periods, outputPath) {
@@ -6801,8 +7334,8 @@ async function exportJson(periods, outputPath) {
     shellCommands: buildBashRows(thirtyDayProjects)
   };
   const target = resolve(outputPath.toLowerCase().endsWith(".json") ? outputPath : `${outputPath}.json`);
-  await mkdir5(dirname2(target), { recursive: true });
-  await writeFile(target, JSON.stringify(data, null, 2), "utf-8");
+  await mkdir6(dirname3(target), { recursive: true });
+  await writeFile2(target, JSON.stringify(data, null, 2), "utf-8");
   return target;
 }
 
@@ -6856,12 +7389,12 @@ function renderStatusBar(projects) {
 
 // src/menubar-json.ts
 import { readdirSync, readFileSync } from "fs";
-import { join as join22, dirname as dirname5 } from "path";
+import { join as join23, dirname as dirname6 } from "path";
 init_models();
 import { fileURLToPath } from "url";
 function getCliVersion() {
   try {
-    const pkgPath = join22(dirname5(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkgPath = join23(dirname6(fileURLToPath(import.meta.url)), "..", "package.json");
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -7026,16 +7559,16 @@ init_cache_dir();
 init_models();
 import { createHash as createHash6, randomBytes as randomBytes6 } from "crypto";
 import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir11, open as open8, readFile as readFile12, rename as rename9, unlink as unlink7 } from "fs/promises";
-import { join as join23 } from "path";
+import { mkdir as mkdir12, open as open8, readFile as readFile13, rename as rename10, unlink as unlink8 } from "fs/promises";
+import { join as join24 } from "path";
 var DAILY_CACHE_VERSION = 9;
 var DEFAULT_DAILY_CACHE_SCOPE = "global";
 var DAILY_CACHE_FILENAME = "daily-cache.json";
 function getCachePath3(scopeKey) {
   if (scopeKey === DEFAULT_DAILY_CACHE_SCOPE) {
-    return join23(getCacheDir(), DAILY_CACHE_FILENAME);
+    return join24(getCacheDir(), DAILY_CACHE_FILENAME);
   }
-  return join23(getCacheDir(), `daily-cache-${scopeKey}.json`);
+  return join24(getCacheDir(), `daily-cache-${scopeKey}.json`);
 }
 function emptyCache(scopeKey) {
   return { version: DAILY_CACHE_VERSION, scopeKey, lastComputedDate: null, days: [] };
@@ -7071,7 +7604,7 @@ async function loadDailyCache(scopeKey = DEFAULT_DAILY_CACHE_SCOPE) {
   const path = getCachePath3(scopeKey);
   if (!existsSync5(path)) return emptyCache(scopeKey);
   try {
-    const raw = await readFile12(path, "utf-8");
+    const raw = await readFile13(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCache(parsed)) return emptyCache(scopeKey);
     if (parsed.scopeKey !== scopeKey) return emptyCache(scopeKey);
@@ -7099,12 +7632,12 @@ async function loadDailyCache(scopeKey = DEFAULT_DAILY_CACHE_SCOPE) {
 }
 async function saveDailyCache(cache) {
   const dir = getCacheDir();
-  if (!existsSync5(dir)) await mkdir11(dir, { recursive: true });
+  if (!existsSync5(dir)) await mkdir12(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, pricingFingerprint: getPricingFingerprint() });
-  if (await readFile12(finalPath, "utf8").catch(() => "") === payload) return;
+  if (await readFile13(finalPath, "utf8").catch(() => "") === payload) return;
   const handle = await open8(tempPath, "w", 384);
   try {
     await handle.writeFile(payload, { encoding: "utf-8" });
@@ -7113,10 +7646,10 @@ async function saveDailyCache(cache) {
     await handle.close();
   }
   try {
-    await rename9(tempPath, finalPath);
+    await rename10(tempPath, finalPath);
   } catch (err) {
     try {
-      await unlink7(tempPath);
+      await unlink8(tempPath);
     } catch {
     }
     throw err;
@@ -7159,17 +7692,17 @@ init_types();
 // src/claude-recovery.ts
 init_cache_dir();
 init_models();
-import { readFile as readFile13, stat as stat16, mkdir as mkdir12, writeFile as writeFile4, rename as rename10, unlink as unlink8 } from "fs/promises";
-import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile14, stat as stat16, mkdir as mkdir13, writeFile as writeFile5, rename as rename11, unlink as unlink9 } from "fs/promises";
+import { createHash as createHash7, randomUUID as randomUUID4 } from "crypto";
 import { homedir as homedir12 } from "os";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 
 // src/history-start.ts
 init_discovery_cache();
 init_fs_utils();
 init_parser();
 import { readdir as readdir12, stat as stat15 } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function parseHistoryStartDate(value) {
   if (!value || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
   const [year, month, day] = value.split("-").map(Number);
@@ -7189,7 +7722,7 @@ async function resolveHistoryStart(configured, cachedDates, now = /* @__PURE__ *
   for (const source of sources) {
     const sourceStat = await stat15(source.path).catch(() => null);
     if (!sourceStat) continue;
-    const paths = sourceStat.isDirectory() ? (await readdir12(source.path)).filter((name) => name.endsWith(".jsonl")).map((name) => join24(source.path, name)) : source.path.endsWith(".jsonl") ? [source.path] : [];
+    const paths = sourceStat.isDirectory() ? (await readdir12(source.path)).filter((name) => name.endsWith(".jsonl")).map((name) => join25(source.path, name)) : source.path.endsWith(".jsonl") ? [source.path] : [];
     for (const path of paths) {
       const fileStat = await stat15(path).catch(() => null);
       if (!fileStat) continue;
@@ -7240,13 +7773,13 @@ function applyClaudeRecovery(data, recovery) {
   }
 }
 async function readClaudeUsageSnapshot() {
-  const root = process.env["CLAUDE_CONFIG_DIR"] || join25(homedir12(), ".claude");
-  const path = join25(root, "stats-cache.json");
-  const savedPath = join25(getCacheDir(), `claude-lifetime-${createHash7("sha256").update(root).digest("hex").slice(0, 16)}.json`);
+  const root = process.env["CLAUDE_CONFIG_DIR"] || join26(homedir12(), ".claude");
+  const path = join26(root, "stats-cache.json");
+  const savedPath = join26(getCacheDir(), `claude-lifetime-${createHash7("sha256").update(root).digest("hex").slice(0, 16)}.json`);
   const read = async (file) => {
     try {
       if ((await stat16(file)).size > 2 * 1024 ** 2) return null;
-      const data = JSON.parse(await readFile13(file, "utf8"));
+      const data = JSON.parse(await readFile14(file, "utf8"));
       if (!data || typeof data.firstSessionDate !== "string" || !parseHistoryStartDate(data.lastComputedDate) || !data.modelUsage || typeof data.modelUsage !== "object") return null;
       if (!Number.isFinite(new Date(data.firstSessionDate).getTime())) return null;
       if (parseHistoryStartDate(data.lastComputedDate).getTime() > Date.now()) return null;
@@ -7270,15 +7803,15 @@ async function readClaudeUsageSnapshot() {
     }
   }
   const payload = JSON.stringify(combined);
-  if (await readFile13(savedPath, "utf8").catch(() => "") !== payload) {
-    await mkdir12(getCacheDir(), { recursive: true });
-    const tmp = `${savedPath}.${randomUUID3()}.tmp`;
+  if (await readFile14(savedPath, "utf8").catch(() => "") !== payload) {
+    await mkdir13(getCacheDir(), { recursive: true });
+    const tmp = `${savedPath}.${randomUUID4()}.tmp`;
     try {
-      await writeFile4(tmp, payload, { mode: 384 });
-      await rename10(tmp, savedPath);
+      await writeFile5(tmp, payload, { mode: 384 });
+      await rename11(tmp, savedPath);
     } catch {
     } finally {
-      await unlink8(tmp).catch(() => {
+      await unlink9(tmp).catch(() => {
       });
     }
   }
@@ -7411,7 +7944,7 @@ init_providers();
 import chalk2 from "chalk";
 import { readdir as readdir13, stat as stat17 } from "fs/promises";
 import { existsSync as existsSync6, statSync as statSync2 } from "fs";
-import { basename as basename10, join as join26 } from "path";
+import { basename as basename10, join as join27 } from "path";
 import { homedir as homedir13 } from "os";
 var ORANGE = "#F59E0B";
 var DIM = "#666666";
@@ -7494,13 +8027,13 @@ var DEFAULT_TREND_PERIOD_MS = DEFAULT_TREND_PERIOD_DAYS * 24 * 60 * 60 * 1e3;
 var IMPROVING_THRESHOLD = 0.5;
 async function collectJsonlFiles3(dirPath) {
   const files = await readdir13(dirPath).catch(() => []);
-  const result = files.filter((f) => f.endsWith(".jsonl")).map((f) => join26(dirPath, f));
+  const result = files.filter((f) => f.endsWith(".jsonl")).map((f) => join27(dirPath, f));
   for (const entry of files) {
     if (entry.endsWith(".jsonl")) continue;
-    const subPath = join26(dirPath, entry, "subagents");
+    const subPath = join27(dirPath, entry, "subagents");
     const subFiles = await readdir13(subPath).catch(() => []);
     for (const sf of subFiles) {
-      if (sf.endsWith(".jsonl")) result.push(join26(subPath, sf));
+      if (sf.endsWith(".jsonl")) result.push(join27(subPath, sf));
     }
   }
   return result;
@@ -7690,13 +8223,13 @@ function isReadTool(name) {
 function loadMcpConfigs(projectCwds) {
   const servers = /* @__PURE__ */ new Map();
   const configPaths = [
-    join26(homedir13(), ".claude", "settings.json"),
-    join26(homedir13(), ".claude", "settings.local.json")
+    join27(homedir13(), ".claude", "settings.json"),
+    join27(homedir13(), ".claude", "settings.local.json")
   ];
   for (const cwd of projectCwds) {
-    configPaths.push(join26(cwd, ".mcp.json"));
-    configPaths.push(join26(cwd, ".claude", "settings.json"));
-    configPaths.push(join26(cwd, ".claude", "settings.local.json"));
+    configPaths.push(join27(cwd, ".mcp.json"));
+    configPaths.push(join27(cwd, ".claude", "settings.json"));
+    configPaths.push(join27(cwd, ".claude", "settings.local.json"));
   }
   for (const p of configPaths) {
     if (!existsSync6(p)) continue;
@@ -7849,12 +8382,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 = join26(filePath, "..");
+  const dir = join27(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 : join26(dir, rawPath);
+    const resolved = rawPath.startsWith("/") ? rawPath : join27(dir, rawPath);
     if (!existsSync6(resolved)) continue;
     const nested = expandImports(resolved, seen, depth + 1);
     totalLines += nested.totalLines;
@@ -7866,7 +8399,7 @@ function detectBloatedClaudeMd(projectCwds) {
   const bloated = [];
   for (const cwd of projectCwds) {
     for (const name of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-      const fullPath = join26(cwd, name);
+      const fullPath = join27(cwd, name);
       if (!existsSync6(fullPath)) continue;
       const { totalLines, importedFiles } = expandImports(fullPath, /* @__PURE__ */ new Set(), 0);
       if (totalLines > CLAUDEMD_HEALTHY_LINES) {
@@ -8009,7 +8542,7 @@ async function listSkillDirs(dir) {
     const entries = await readdir13(dir);
     const names = [];
     for (const entry of entries) {
-      if (existsSync6(join26(dir, entry, "SKILL.md"))) names.push(entry);
+      if (existsSync6(join27(dir, entry, "SKILL.md"))) names.push(entry);
     }
     return names;
   } catch {
@@ -8017,7 +8550,7 @@ async function listSkillDirs(dir) {
   }
 }
 async function detectGhostAgents(calls) {
-  const defined = await listMarkdownFiles(join26(homedir13(), ".claude", "agents"));
+  const defined = await listMarkdownFiles(join27(homedir13(), ".claude", "agents"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const call of calls) {
@@ -8042,7 +8575,7 @@ async function detectGhostAgents(calls) {
   };
 }
 async function detectGhostSkills(calls) {
-  const defined = await listSkillDirs(join26(homedir13(), ".claude", "skills"));
+  const defined = await listSkillDirs(join27(homedir13(), ".claude", "skills"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const call of calls) {
@@ -8067,7 +8600,7 @@ async function detectGhostSkills(calls) {
   };
 }
 async function detectGhostCommands(userMessages) {
-  const defined = await listMarkdownFiles(join26(homedir13(), ".claude", "commands"));
+  const defined = await listMarkdownFiles(join27(homedir13(), ".claude", "commands"));
   if (defined.length === 0) return null;
   const invoked = /* @__PURE__ */ new Set();
   for (const msg of userMessages) {
@@ -8095,7 +8628,7 @@ async function detectGhostCommands(userMessages) {
 }
 function readShellProfileLimit() {
   for (const profile of SHELL_PROFILES) {
-    const path = join26(homedir13(), profile);
+    const path = join27(homedir13(), profile);
     if (!existsSync6(path)) continue;
     const content = readSessionFileSync(path);
     if (content === null) continue;
@@ -8316,10 +8849,10 @@ async function runOptimize(projects, periodLabel, dateRange, preScanned) {
 
 // src/optimize-share.ts
 import { spawn as spawn2 } from "child_process";
-import { randomUUID as randomUUID4 } from "crypto";
-import { stat as stat18, writeFile as writeFile5 } from "fs/promises";
+import { randomUUID as randomUUID5 } from "crypto";
+import { stat as stat18, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { join as join27, resolve as resolve3 } from "path";
+import { join as join28, resolve as resolve3 } from "path";
 function codeBlock(content, language) {
   const longest = (content.match(/`+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);
   const fence = "`".repeat(Math.max(3, longest + 1));
@@ -8413,11 +8946,11 @@ async function copyOptimizeMarkdown(markdown) {
   throw new Error("Could not copy. Press e to save a Markdown file instead.");
 }
 async function saveOptimizeMarkdown(markdown, directory) {
-  const downloads = join27(homedir14(), "Downloads");
+  const downloads = join28(homedir14(), "Downloads");
   const folder = directory ?? ((await stat18(downloads).catch(() => null))?.isDirectory() ? downloads : process.cwd());
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const path = resolve3(folder, `exe-watcher-optimizer-${stamp}-${randomUUID4().slice(0, 8)}.md`);
-  await writeFile5(path, markdown, { encoding: "utf8", mode: 384, flag: "wx" });
+  const path = resolve3(folder, `exe-watcher-optimizer-${stamp}-${randomUUID5().slice(0, 8)}.md`);
+  await writeFile6(path, markdown, { encoding: "utf8", mode: 384, flag: "wx" });
   return path;
 }
 
@@ -8425,7 +8958,7 @@ async function saveOptimizeMarkdown(markdown, directory) {
 init_fs_utils();
 import { readdir as readdir14 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { homedir as homedir15 } from "os";
 var CHARS_PER_TOKEN2 = 4;
 var SYSTEM_BASE_TOKENS = 10400;
@@ -8447,13 +8980,13 @@ async function readConfigFile(path) {
 async function countMcpTools(projectPath) {
   const home = homedir15();
   const configPaths = [
-    join28(home, ".claude", "settings.json"),
-    join28(home, ".claude", "settings.local.json")
+    join29(home, ".claude", "settings.json"),
+    join29(home, ".claude", "settings.local.json")
   ];
   if (projectPath) {
-    configPaths.push(join28(projectPath, ".mcp.json"));
-    configPaths.push(join28(projectPath, ".claude", "settings.json"));
-    configPaths.push(join28(projectPath, ".claude", "settings.local.json"));
+    configPaths.push(join29(projectPath, ".mcp.json"));
+    configPaths.push(join29(projectPath, ".claude", "settings.json"));
+    configPaths.push(join29(projectPath, ".claude", "settings.local.json"));
   }
   const servers = /* @__PURE__ */ new Set();
   let toolCount = 0;
@@ -8470,15 +9003,15 @@ async function countMcpTools(projectPath) {
   return toolCount;
 }
 async function countSkills(projectPath) {
-  const dirs = [join28(homedir15(), ".claude", "skills")];
-  if (projectPath) dirs.push(join28(projectPath, ".claude", "skills"));
+  const dirs = [join29(homedir15(), ".claude", "skills")];
+  if (projectPath) dirs.push(join29(projectPath, ".claude", "skills"));
   let count = 0;
   for (const dir of dirs) {
     if (!existsSync7(dir)) continue;
     try {
       const entries = await readdir14(dir);
       for (const entry of entries) {
-        const skillFile = join28(dir, entry, "SKILL.md");
+        const skillFile = join29(dir, entry, "SKILL.md");
         if (existsSync7(skillFile)) count++;
       }
     } catch {
@@ -8491,12 +9024,12 @@ async function scanMemoryFiles(projectPath) {
   const home = homedir15();
   const files = [];
   const paths = [
-    { path: join28(home, ".claude", "CLAUDE.md"), name: "~/.claude/CLAUDE.md" }
+    { path: join29(home, ".claude", "CLAUDE.md"), name: "~/.claude/CLAUDE.md" }
   ];
   if (projectPath) {
-    paths.push({ path: join28(projectPath, "CLAUDE.md"), name: "CLAUDE.md" });
-    paths.push({ path: join28(projectPath, ".claude", "CLAUDE.md"), name: ".claude/CLAUDE.md" });
-    paths.push({ path: join28(projectPath, "CLAUDE.local.md"), name: "CLAUDE.local.md" });
+    paths.push({ path: join29(projectPath, "CLAUDE.md"), name: "CLAUDE.md" });
+    paths.push({ path: join29(projectPath, ".claude", "CLAUDE.md"), name: ".claude/CLAUDE.md" });
+    paths.push({ path: join29(projectPath, "CLAUDE.local.md"), name: "CLAUDE.local.md" });
   }
   for (const { path, name } of paths) {
     if (!existsSync7(path)) continue;
@@ -8533,7 +9066,7 @@ async function discoverProjectCwd(sessionDir) {
   if (files.length === 0) return null;
   const firstFile = files[0];
   if (!firstFile) return null;
-  const content = await readSessionFile(join28(sessionDir, firstFile));
+  const content = await readSessionFile(join29(sessionDir, firstFile));
   if (content === null) return null;
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -9227,15 +9760,15 @@ function owlFrame(tick) {
 }
 
 // src/dashboard.tsx
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 
 // src/time-index.ts
 init_cache_dir();
 init_file_lock();
 init_resource_budget();
-import { createHash as createHash9, randomUUID as randomUUID5 } from "crypto";
-import { mkdir as mkdir13, open as open9, readFile as readFile14, rename as rename11, stat as stat19, unlink as unlink9, readdir as readdir15 } from "fs/promises";
-import { basename as basename11, dirname as dirname6, join as join30 } from "path";
+import { createHash as createHash9, randomUUID as randomUUID6 } from "crypto";
+import { mkdir as mkdir14, open as open9, readFile as readFile15, rename as rename12, stat as stat19, unlink as unlink10, readdir as readdir15 } from "fs/promises";
+import { basename as basename11, dirname as dirname7, join as join31 } from "path";
 import { gzip as gzip2, gunzip as gunzip2 } from "zlib";
 import { promisify as promisify2 } from "util";
 
@@ -9245,12 +9778,12 @@ import { createHash as createHash8 } from "crypto";
 // src/personal-activity.ts
 init_cache_dir();
 import { openSync as openSync2, readSync as readSync2, closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var ACTIVITY_LIMIT = 4 * 1024 ** 2;
 function readActivityHistory() {
   let fd;
   try {
-    fd = openSync2(join29(getCacheDir(), "personal-activity-v1.json"), constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+    fd = openSync2(join30(getCacheDir(), "personal-activity-v1.json"), constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
     const stat20 = fstatSync2(fd);
     if (!stat20.isFile() || stat20.size > ACTIVITY_LIMIT) return void 0;
     const buffer = Buffer.alloc(stat20.size);
@@ -9679,12 +10212,12 @@ var MAX_DISK2 = 16 * 1024 ** 2;
 var MAX_FILES = 2e4;
 var BLOCK = 2 * 1024 ** 2;
 var adapterVersion = (provider) => provider === "opencode" ? 2 : 1;
-var indexPath2 = () => join30(getCacheDir(), "time-index-v1.json.gz");
+var indexPath2 = () => join31(getCacheDir(), "time-index-v1.json.gz");
 var empty = () => ({ version: 1, files: /* @__PURE__ */ Object.create(null), updatedAt: (/* @__PURE__ */ new Date()).toISOString(), warnings: [] });
 async function readTimeIndex() {
   try {
     if ((await stat19(indexPath2())).size > MAX_DISK2) throw new Error("Timing index exceeds its disk limit");
-    const value = JSON.parse((await decompress2(await readFile14(indexPath2()), { maxOutputLength: MAX_INDEX })).toString("utf8"));
+    const value = JSON.parse((await decompress2(await readFile15(indexPath2()), { maxOutputLength: MAX_INDEX })).toString("utf8"));
     if (value.version !== 1 || !value.files || typeof value.files !== "object" || Array.isArray(value.files) || Object.keys(value.files).length > MAX_FILES || !Array.isArray(value.warnings) || !value.warnings.every((x) => typeof x === "string") || typeof value.updatedAt !== "string") throw new Error("Invalid timing index");
     for (const row of Object.values(value.files)) {
       const interval2 = (x) => Array.isArray(x) && x.length >= 3 && typeof x[0] === "number" && Number.isFinite(x[0]) && typeof x[1] === "number" && Number.isFinite(x[1]) && (x[2] === 0 || x[2] === 1) && (x[3] === void 0 || typeof x[3] === "string");
@@ -9703,8 +10236,8 @@ async function save(index) {
   if (Buffer.byteLength(data) > MAX_INDEX) throw new Error("Timing index reached its 32 MiB memory/disk snapshot limit; use a narrower history range.");
   const encoded = await compress2(Buffer.from(data));
   if (encoded.length > MAX_DISK2) throw new Error("Timing index reached its 16 MiB compressed disk limit.");
-  const path = indexPath2(), temp = `${path}.${randomUUID5()}.tmp`;
-  await mkdir13(getCacheDir(), { recursive: true });
+  const path = indexPath2(), temp = `${path}.${randomUUID6()}.tmp`;
+  await mkdir14(getCacheDir(), { recursive: true });
   try {
     const handle = await open9(temp, "wx", 384);
     try {
@@ -9713,9 +10246,9 @@ async function save(index) {
     } finally {
       await handle.close();
     }
-    await rename11(temp, path);
+    await rename12(temp, path);
   } finally {
-    await unlink9(temp).catch(() => {
+    await unlink10(temp).catch(() => {
     });
   }
 }
@@ -9742,11 +10275,11 @@ async function expandSources(sources, warnings) {
       continue;
     }
     for (const entry of await readdir15(source.path, { withFileTypes: true }).catch(() => [])) {
-      if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push({ ...source, path: join30(source.path, entry.name) });
+      if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push({ ...source, path: join31(source.path, entry.name) });
       else if (entry.isDirectory()) {
-        const folder = join30(source.path, entry.name, "subagents");
+        const folder = join31(source.path, entry.name, "subagents");
         for (const agent of await readdir15(folder, { withFileTypes: true }).catch(() => [])) {
-          if (agent.isFile() && agent.name.endsWith(".jsonl")) out.push({ ...source, path: join30(folder, agent.name) });
+          if (agent.isFile() && agent.name.endsWith(".jsonl")) out.push({ ...source, path: join31(folder, agent.name) });
         }
       }
     }
@@ -9766,9 +10299,9 @@ async function anchor(path, offset) {
   }
 }
 function fresh(source, identity, size, mtime, ctime) {
-  const child = source.path.includes("/subagents/") || basename11(source.path).startsWith("agent-") || source.provider === "kimi" && basename11(dirname6(source.path)) !== "main";
-  const kimiSession = source.path.split("/").find((part) => part.startsWith("session_")) ?? basename11(dirname6(dirname6(source.path)));
-  const agent = source.provider === "copilot" ? basename11(dirname6(source.path)) : source.provider === "kimi" ? `${kimiSession}/${basename11(dirname6(source.path))}` : `${child ? basename11(dirname6(dirname6(source.path))) + "/" : ""}${basename11(source.path, ".jsonl")}`;
+  const child = source.path.includes("/subagents/") || basename11(source.path).startsWith("agent-") || source.provider === "kimi" && basename11(dirname7(source.path)) !== "main";
+  const kimiSession = source.path.split("/").find((part) => part.startsWith("session_")) ?? basename11(dirname7(dirname7(source.path)));
+  const agent = source.provider === "copilot" ? basename11(dirname7(source.path)) : source.provider === "kimi" ? `${kimiSession}/${basename11(dirname7(source.path))}` : `${child ? basename11(dirname7(dirname7(source.path))) + "/" : ""}${basename11(source.path, ".jsonl")}`;
   return {
     provider: source.provider,
     project: source.project,
@@ -9843,7 +10376,7 @@ async function refreshTimeIndex(options = {}) {
   let current;
   let release;
   try {
-    release = await acquireFileLock(join30(getCacheDir(), "time-index.lock"), 100);
+    release = await acquireFileLock(join31(getCacheDir(), "time-index.lock"), 100);
   } catch {
     current = await readTimeIndex();
     current.warnings.push("Another timing update is running; showing the saved timing snapshot.");
@@ -10808,11 +11341,11 @@ function InteractiveDashboard({ initialPeriod, initialProvider, refreshSeconds,
   useEffect2(() => {
     let cancelled = false;
     async function loadBudgets() {
-      const claudeDir = join31(homedir16(), ".claude", "projects");
+      const claudeDir = join32(homedir16(), ".claude", "projects");
       const budgets = /* @__PURE__ */ new Map();
       for (const project of projects.slice(0, 8)) {
         if (cancelled) return;
-        const cwd = await discoverProjectCwd(join31(claudeDir, project.project));
+        const cwd = await discoverProjectCwd(join32(claudeDir, project.project));
         if (!cwd) continue;
         budgets.set(project.project, await estimateContextBudget(cwd));
       }
@@ -11479,9 +12012,32 @@ async function runJsonReport(period, provider, project, exclude) {
   }
   console.log(JSON.stringify({ ...report, pricing: getPricingMetadata() }, null, 2));
 }
+var telemetry;
+var telemetryCommand = "unknown";
 var program = new Command().name("exe-watcher").description("See where your AI coding tokens go - by task, tool, model, and project").version(version).option("--verbose", "print warnings to stderr on read failures and skipped files");
 program.hook("preAction", async (thisCommand, command) => {
   const config = await readConfig();
+  if (command.name() !== "telemetry" && process.stdin.isTTY && resolveTelemetry(config.telemetry).usageEnabled && config.telemetry?.basicNoticeVersion !== 1) {
+    const noticePath = join33(dirname8(getConfigFilePath()), "basic-analytics-notice-v1");
+    if (!existsSync8(noticePath)) console.error(`
+${BASIC_NOTICE}
+`);
+    config.telemetry = { ...config.telemetry, basicNoticeVersion: 1 };
+    try {
+      const fs = await import("fs/promises");
+      await fs.mkdir(dirname8(noticePath), { recursive: true, mode: 448 });
+      try {
+        await fs.writeFile(noticePath, "1\n", { flag: "wx", mode: 384 });
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+    } catch {
+      config.telemetry.usageEnabled = false;
+    }
+  }
+  telemetry = command.name() === "telemetry" ? void 0 : await createTelemetry(config.telemetry, version);
+  telemetryCommand = command.name();
+  await telemetry?.capture("command_started", telemetryCommand);
   setModelAliases(config.modelAliases ?? {});
   configuredHistoryStart = parseHistoryStartDate(config.historyStartDate);
   if (thisCommand.opts().verbose) {
@@ -11986,12 +12542,12 @@ program.command("status").description("Compact status output (today + week + mon
 `);
       }
     }
-    const exeOsDir = join32(homedir17(), ".exe-os");
+    const exeOsDir = join33(homedir17(), ".exe-os");
     const exeOsDetected = existsSync8(exeOsDir);
     let agentStats = null;
     let statsFileAge = null;
     try {
-      const statsPath = join32(exeOsDir, "agent-stats.json");
+      const statsPath = join33(exeOsDir, "agent-stats.json");
       if (existsSync8(statsPath)) {
         statsFileAge = Math.round((Date.now() - statSync3(statsPath).mtimeMs) / 1e3);
         const parsed = JSON.parse(readFileSync2(statsPath, "utf-8"));
@@ -12397,9 +12953,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 = join32(homedir17(), ".exe-os");
-  const statsPath = join32(exeOsDir, "agent-stats.json");
-  const pidPath = join32(exeOsDir, "exed.pid");
+  const exeOsDir = join33(homedir17(), ".exe-os");
+  const statsPath = join33(exeOsDir, "agent-stats.json");
+  const pidPath = join33(exeOsDir, "exed.pid");
   const dirExists = existsSync8(exeOsDir);
   const statsExists = dirExists && existsSync8(statsPath);
   const pidExists = dirExists && existsSync8(pidPath);
@@ -12431,15 +12987,55 @@ program.command("agent-status").description("Diagnose exe-os agent data pipeline
   }
   console.log(lines.join("\n"));
 });
+program.command("telemetry").description("Optional self-hosted usage statistics and sanitized error diagnostics (basic usage on; diagnostics off by default)").option("--usage <on|off>", "Allow pseudonymous installation and foreground feature counters").option("--errors <on|off>", "Consent to error category/class/version; no messages or content").option("--test-error", "Send one harmless handled diagnostic when error consent is enabled").action(async (opts) => {
+  const config = await readConfig();
+  for (const value of [opts.usage, opts.errors]) {
+    if (value !== void 0 && value !== "on" && value !== "off") throw new Error("Use on or off for telemetry consent");
+  }
+  config.telemetry ??= {};
+  if ((opts.usage !== void 0 || opts.errors !== void 0) && config.telemetry.enabled === false) {
+    config.telemetry.usageEnabled = false;
+    config.telemetry.diagnosticsEnabled = false;
+    delete config.telemetry.enabled;
+  }
+  if (opts.usage !== void 0 && config.telemetry.usageEnabled !== (opts.usage === "on")) {
+    config.telemetry.usageEnabled = opts.usage === "on";
+    config.telemetry.usageEpoch = (await import("crypto")).randomUUID();
+  }
+  if (opts.errors !== void 0 && config.telemetry.diagnosticsEnabled !== (opts.errors === "on")) {
+    config.telemetry.diagnosticsEnabled = opts.errors === "on";
+    config.telemetry.diagnosticsEpoch = (await import("crypto")).randomUUID();
+  }
+  if (opts.usage !== void 0 || opts.errors !== void 0) await saveConfig(config);
+  const effective = resolveTelemetry(config.telemetry);
+  const current = await createTelemetry(config.telemetry, version);
+  if (opts.testError && config.telemetry.diagnosticsEnabled === true) {
+    try {
+      throw new Error("Watcher harmless handled diagnostic");
+    } catch (error) {
+      await current.error(error);
+    }
+  }
+  await current.shutdown();
+  console.log(JSON.stringify({
+    usage: effective.usageEnabled,
+    errors: effective.diagnosticsEnabled,
+    collector: "https://data.odd.community",
+    recordingMinutes: "N/A",
+    notice: BASIC_NOTICE
+  }));
+});
 var releaseScan;
 var stopParentWatch = watchMenubarParent(Number(process.env["EXE_WATCHER_PARENT_PID"]));
 program.hook("preAction", async (_root, command) => {
-  if (command.name() === "status" && !command.opts().cachedOnly) releaseScan = await acquireFileLock(join32(getCacheDir(), "scan.lock"));
+  if (command.name() === "status" && !command.opts().cachedOnly) releaseScan = await acquireFileLock(join33(getCacheDir(), "scan.lock"));
 });
 program.hook("postAction", async () => {
   await releaseScan?.();
   releaseScan = void 0;
   stopParentWatch();
+  await telemetry?.capture("command_finished", telemetryCommand, !process.exitCode);
+  await telemetry?.shutdown();
 });
 if (process.argv.length <= 2 && process.platform === "darwin") {
   const isTTY = process.stdin.isTTY && process.stdout.isTTY;
@@ -12468,6 +13064,9 @@ if (process.argv.length <= 2 && process.platform === "darwin") {
   program.parseAsync().catch(async (error) => {
     await releaseScan?.();
     stopParentWatch();
+    await telemetry?.error(error);
+    await telemetry?.capture("command_finished", telemetryCommand, false);
+    await telemetry?.shutdown();
     console.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;
   });