llm-usage-metrics 0.9.0 → 0.10.0

package/dist/index.js

@@ -7,9 +7,9 @@ import { isMainThread, workerData } from "worker_threads";
 import { availableParallelism } from "os";
 
 // src/persistence/event-store-administration.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { chmod, link, mkdir, open, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import path3 from "path";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { chmod, link, open, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
 
 // src/utils/as-record.ts
 function isRecord(value) {
@@ -47,33 +47,6 @@ function normalizeSkippedRowReasons(value) {
   });
 }
 
-// src/utils/compare-by-code-point.ts
-function compareByCodePoint(left, right4) {
-  if (left === right4) {
-    return 0;
-  }
-  const leftIterator = left[Symbol.iterator]();
-  const rightIterator = right4[Symbol.iterator]();
-  for (; ; ) {
-    const leftStep = leftIterator.next();
-    const rightStep = rightIterator.next();
-    if (leftStep.done && rightStep.done) {
-      return 0;
-    }
-    if (leftStep.done) {
-      return -1;
-    }
-    if (rightStep.done) {
-      return 1;
-    }
-    const leftCodePoint = leftStep.value.codePointAt(0) ?? 0;
-    const rightCodePoint = rightStep.value.codePointAt(0) ?? 0;
-    if (leftCodePoint !== rightCodePoint) {
-      return leftCodePoint < rightCodePoint ? -1 : 1;
-    }
-  }
-}
-
 // src/domain/normalization.ts
 var CONTROL_CHARACTER_CLASS = String.raw`[\u0000-\u001F\u007F-\u009F\u061C\u200E\u200F\u2028-\u202E\u2066-\u2069]`;
 var CONTROL_CHARACTERS_PATTERN = new RegExp(CONTROL_CHARACTER_CLASS, "gu");
@@ -115,6 +88,33 @@ function normalizeTimestamp(value) {
   return date.toISOString();
 }
 
+// src/utils/compare-by-code-point.ts
+function compareByCodePoint(left, right4) {
+  if (left === right4) {
+    return 0;
+  }
+  const leftIterator = left[Symbol.iterator]();
+  const rightIterator = right4[Symbol.iterator]();
+  for (; ; ) {
+    const leftStep = leftIterator.next();
+    const rightStep = rightIterator.next();
+    if (leftStep.done && rightStep.done) {
+      return 0;
+    }
+    if (leftStep.done) {
+      return -1;
+    }
+    if (rightStep.done) {
+      return 1;
+    }
+    const leftCodePoint = leftStep.value.codePointAt(0) ?? 0;
+    const rightCodePoint = rightStep.value.codePointAt(0) ?? 0;
+    if (leftCodePoint !== rightCodePoint) {
+      return leftCodePoint < rightCodePoint ? -1 : 1;
+    }
+  }
+}
+
 // src/domain/provider-normalization.ts
 var billingProviderAliases = /* @__PURE__ */ new Map([
   ["openai-codex", "openai"],
@@ -226,6 +226,7 @@ function intersectCanonicalProviderRoots(left, right4) {
 
 // src/domain/usage-event.ts
 var USAGE_EVENT_NORMALIZATION_VERSION = 2;
+var LOCAL_MACHINE_NAME = "local";
 function normalizeSourceId(value) {
   if (typeof value !== "string") {
     return void 0;
@@ -404,7 +405,8 @@ function getUserDataRootDir(env = process.env, platform = process.platform, home
 
 // src/utils/fs-helpers.ts
 import { randomUUID } from "crypto";
-import { access, constants, rename, rm, stat, writeFile } from "fs/promises";
+import { access, constants, mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import path3 from "path";
 async function pathExists(filePath) {
   try {
     await access(filePath, constants.F_OK);
@@ -442,6 +444,36 @@ async function pathStat(filePath) {
     return void 0;
   }
 }
+async function ensureDirectory(directoryPath, mode) {
+  const missing = [];
+  let current = directoryPath;
+  while (!await pathIsDirectory(current)) {
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    missing.push(current);
+    current = parent;
+  }
+  for (const directory of missing.reverse()) {
+    try {
+      await mkdir(directory, { mode });
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+        throw error;
+      }
+      if (!await pathIsDirectory(directory)) {
+        throw error;
+      }
+    }
+  }
+}
+async function readRegularTextFile(filePath) {
+  if (!(await stat(filePath)).isFile()) {
+    throw new Error(`${filePath} is not a regular file`);
+  }
+  return readFile(filePath, "utf8");
+}
 async function writeFileAtomic(filePath, content) {
   const tempPath = `${filePath}.${randomUUID()}.tmp`;
   try {
@@ -480,8 +512,13 @@ function toText(value) {
   const normalized = value.trim();
   return normalized || void 0;
 }
+var databasesInTransaction = /* @__PURE__ */ new WeakSet();
 function runTransaction(database, task) {
+  if (databasesInTransaction.has(database)) {
+    return task();
+  }
   database.exec("BEGIN IMMEDIATE");
+  databasesInTransaction.add(database);
   try {
     const result = task();
     database.exec("COMMIT");
@@ -489,6 +526,8 @@ function runTransaction(database, task) {
   } catch (error) {
     database.exec("ROLLBACK");
     throw error;
+  } finally {
+    databasesInTransaction.delete(database);
   }
 }
 
@@ -875,6 +914,11 @@ function initializeSchema(database) {
   throw new EventStoreSchemaVersionError(schemaVersion);
 }
 
+// src/utils/error-code.ts
+function hasErrorCode(error, ...codes) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && codes.includes(error.code);
+}
+
 // src/persistence/event-store-administration.ts
 var EVENT_STORE_OPEN_TIMEOUT_MS = 2e3;
 var loadEventStoreSqliteModule = () => loadNodeSqliteModule("Event store");
@@ -965,16 +1009,13 @@ function stringifySkippedRowReasons(skippedRowReasons) {
   return normalizedReasons.length > 0 ? JSON.stringify(normalizedReasons) : null;
 }
 function getDefaultEventStorePath() {
-  return path3.join(getUserDataRootDir(), "llm-usage-metrics", "events.db");
+  return path4.join(getUserDataRootDir(), "llm-usage-metrics", "events.db");
 }
 function getLegacyEventStorePath() {
-  return path3.join(getUserCacheRootDir(), "llm-usage-metrics", "events.db");
-}
-function isErrorCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+  return path4.join(getUserCacheRootDir(), "llm-usage-metrics", "events.db");
 }
 function getLegacyCopyMarkerPath(targetPath) {
-  return path3.join(path3.dirname(targetPath), "legacy-ledger-copied");
+  return path4.join(path4.dirname(targetPath), "legacy-ledger-copied");
 }
 async function findLegacyEventStore(targetPath) {
   const legacyPath = getLegacyEventStorePath();
@@ -1003,7 +1044,7 @@ async function copyLegacyEventStore(targetPath, sqliteModule) {
       try {
         await link(snapshotPath, targetPath);
       } catch (error) {
-        if (!isErrorCode(error, "EEXIST")) {
+        if (!hasErrorCode(error, "EEXIST")) {
           throw error;
         }
       }
@@ -1015,6 +1056,10 @@ async function copyLegacyEventStore(targetPath, sqliteModule) {
 `, { mode: 384 });
 }
 async function prepareEventStoreFile(filePath) {
+  const existing = await pathStat(filePath);
+  if (existing && !existing.isFile()) {
+    throw new Error(`Event store path ${filePath} is not a regular file`);
+  }
   const fileHandle = await open(filePath, "a", 384);
   try {
     await chmod(filePath, 384);
@@ -1028,7 +1073,7 @@ async function restrictEventStoreFiles(filePath) {
     try {
       await chmod(sidecarPath, 384);
     } catch (error) {
-      if (isErrorCode(error, "ENOENT")) {
+      if (hasErrorCode(error, "ENOENT")) {
         continue;
       }
       throw error;
@@ -1036,8 +1081,8 @@ async function restrictEventStoreFiles(filePath) {
   }
 }
 async function openEventStore(filePath = getDefaultEventStorePath(), loadSqliteModule = loadEventStoreSqliteModule) {
-  const parentDirectory = path3.dirname(filePath);
-  await mkdir(parentDirectory, { recursive: true, mode: 448 });
+  const parentDirectory = path4.dirname(filePath);
+  await ensureDirectory(parentDirectory, 448);
   if (filePath === getDefaultEventStorePath()) {
     await chmod(parentDirectory, 448);
   }
@@ -1115,6 +1160,99 @@ async function readEventStoreStoredFiles(filePath = getDefaultEventStorePath(),
     database.close();
   }
 }
+function listStoredFileFingerprints(store) {
+  const rows = store.database.prepare("SELECT source, file_path, fingerprint FROM files ORDER BY source ASC, file_path ASC").all();
+  const files = [];
+  for (const row of rows) {
+    const source = toText(row.source);
+    const filePath = toText(row.file_path);
+    const fingerprint = toText(row.fingerprint);
+    if (source && filePath && fingerprint) {
+      files.push({ source, filePath, fingerprint });
+    }
+  }
+  return files;
+}
+function readEventStoreMeta(store, key) {
+  return toText(store.database.prepare("SELECT value FROM meta WHERE key = ?").get(key)?.value);
+}
+function writeEventStoreMeta(store, entries) {
+  runTransaction(store.database, () => {
+    for (const [key, value] of Object.entries(entries)) {
+      if (value === void 0) {
+        store.database.prepare("DELETE FROM meta WHERE key = ?").run(key);
+      } else {
+        store.database.prepare(
+          "INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+        ).run(key, value);
+      }
+    }
+  });
+}
+async function readEventStoreMetaValues(filePath, loadSqliteModule = loadEventStoreSqliteModule) {
+  const sqliteModule = await loadSqliteModule();
+  if (!isEventStoreSqliteModule(sqliteModule)) {
+    throw new Error("Event store requires a sqlite module with a DatabaseSync constructor");
+  }
+  const database = new sqliteModule.DatabaseSync(filePath, {
+    readOnly: true,
+    timeout: EVENT_STORE_OPEN_TIMEOUT_MS
+  });
+  try {
+    return readMetaValues(database);
+  } finally {
+    database.close();
+  }
+}
+function readMetaValues(database) {
+  const meta = /* @__PURE__ */ new Map();
+  for (const row of database.prepare("SELECT key, value FROM meta").all()) {
+    const key = toText(row.key);
+    const value = toText(row.value);
+    if (key && value) {
+      meta.set(key, value);
+    }
+  }
+  return meta;
+}
+async function readEventStoreEvents(filePath, window = {}, loadSqliteModule = loadEventStoreSqliteModule) {
+  const sqliteModule = await loadSqliteModule();
+  if (!isEventStoreSqliteModule(sqliteModule)) {
+    throw new Error("Event store requires a sqlite module with a DatabaseSync constructor");
+  }
+  const database = new sqliteModule.DatabaseSync(filePath, {
+    readOnly: true,
+    timeout: EVENT_STORE_OPEN_TIMEOUT_MS
+  });
+  try {
+    assertSupportedSchemaVersion(database);
+    const statement = database.prepare(
+      [
+        "SELECT source, session_id, timestamp, model, provider, repo_root,",
+        "  input_tokens, output_tokens, reasoning_tokens, cache_read_tokens,",
+        "  cache_write_tokens, total_tokens, cost_usd, cost_mode",
+        "FROM events",
+        "WHERE timestamp >= ? AND timestamp < ?",
+        "ORDER BY source, file_path, event_index"
+      ].join("\n")
+    );
+    statement.setReturnArrays(true);
+    const rows = statement.all(
+      window.fromTimestamp ?? "",
+      window.toTimestamp ?? "\uFFFF"
+    );
+    const events = [];
+    for (const row of rows) {
+      const event = normalizeStoredEventTuple(row);
+      if (event) {
+        events.push(event);
+      }
+    }
+    return { meta: readMetaValues(database), events };
+  } finally {
+    database.close();
+  }
+}
 function deleteFileEntry(store, source, filePath) {
   deleteStoredFiles(store, [{ source, filePath }]);
 }
@@ -1176,6 +1314,39 @@ function readFileEvents(store, source, filePath) {
   }
   return events;
 }
+function readDepartedFileEvents(store, source, filePath) {
+  const normalizedSource = normalizeStoreSource(source);
+  const normalizedFilePath = normalizeStoreFilePath(filePath);
+  const events = [];
+  for (const row of selectFileEventRows(store, normalizedSource, normalizedFilePath)) {
+    const event = normalizeStoredEventTuple(row);
+    if (!event) {
+      continue;
+    }
+    events.push(event);
+  }
+  return events;
+}
+function readStoredFileSnapshots(store, files) {
+  const snapshots = [];
+  store.database.exec("BEGIN");
+  try {
+    for (const file of files) {
+      const source = normalizeStoreSource(file.source);
+      const filePath = normalizeStoreFilePath(file.filePath);
+      const events = readDepartedFileEvents(store, source, filePath);
+      snapshots.push({
+        source,
+        filePath,
+        revision: createHash2("sha256").update(JSON.stringify(events)).digest("hex").slice(0, 16),
+        events
+      });
+    }
+  } finally {
+    store.database.exec("COMMIT");
+  }
+  return snapshots;
+}
 function countMatchingRows(store, tableName, source, filePath) {
   const row = store.database.prepare(`SELECT COUNT(*) AS count FROM ${tableName} WHERE source = ? AND file_path = ?`).get(source, filePath);
   return toNonNegativeInteger(row?.count) ?? 0;
@@ -1419,9 +1590,8 @@ function getEventStoreRuntimeConfig(env = process.env, config = {}) {
 }
 
 // src/config/user-config.ts
-import { readFile as readFileFromFs } from "fs/promises";
 import os4 from "os";
-import path5 from "path";
+import path6 from "path";
 
 // node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -2182,10 +2352,10 @@ var HAS_WELLFORMED = !!"".isWellFormed;
 
 // src/utils/config-root-dir.ts
 import os3 from "os";
-import path4 from "path";
+import path5 from "path";
 function getUserConfigRootDir(env = process.env, platform = process.platform, homedir = os3.homedir()) {
   const xdgConfigDir = env.XDG_CONFIG_HOME;
-  if (xdgConfigDir && path4.isAbsolute(xdgConfigDir)) {
+  if (xdgConfigDir && path5.isAbsolute(xdgConfigDir)) {
     return xdgConfigDir;
   }
   if (platform === "win32") {
@@ -2194,7 +2364,7 @@ function getUserConfigRootDir(env = process.env, platform = process.platform, ho
       return appData;
     }
   }
-  return path4.join(homedir, ".config");
+  return path5.join(homedir, ".config");
 }
 
 // src/config/user-config.ts
@@ -2236,6 +2406,7 @@ var USER_CONFIG_SOURCE_DIR_KEYS = [
 var knownTopLevelKeys = [
   "eventStore",
   "logLevel",
+  "machines",
   "monthlyBudgetUsd",
   "parseMaxParallel",
   "parseWorkerMinBytes",
@@ -2256,20 +2427,30 @@ var knownPricingKeys = [
 ];
 var knownEventStoreKeys = ["enabled", "path"];
 var knownUpdateKeys = ["cacheTtlMs", "fetchTimeoutMs", "skipCheck"];
+var knownMachineKeys = ["command", "enabled", "ssh"];
 var USER_CONFIG_KNOWN_KEY_PATHS = [
   ...knownTopLevelKeys,
   ...knownPricingKeys.map((key) => `pricing.${key}`),
   ...knownEventStoreKeys.map((key) => `eventStore.${key}`),
   ...knownUpdateKeys.map((key) => `update.${key}`),
+  ...knownMachineKeys.map((key) => `machines.<name>.${key}`),
   ...USER_CONFIG_SOURCE_DIR_KEYS.map((key) => `sourceDirs.${key}`)
 ];
 var knownTopLevelKeySet = new Set(knownTopLevelKeys);
 var knownPricingKeySet = new Set(knownPricingKeys);
 var knownEventStoreKeySet = new Set(knownEventStoreKeys);
 var knownUpdateKeySet = new Set(knownUpdateKeys);
+var knownMachineKeySet = new Set(knownMachineKeys);
+var MACHINE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/u;
+function isValidMachineName(name) {
+  return MACHINE_NAME_PATTERN.test(name) && name !== LOCAL_MACHINE_NAME;
+}
+function isValidSshTarget(target) {
+  return target.length > 0 && !target.startsWith("-") && !/[\s\u0000-\u001F\u007F]/u.test(target);
+}
 var sourceDirKeySet = new Set(USER_CONFIG_SOURCE_DIR_KEYS);
 function getDefaultUserConfigPath(env) {
-  return path5.join(
+  return path6.join(
     getUserConfigRootDir(env, process.platform, os4.homedir()),
     "llm-usage-metrics",
     "config.toml"
@@ -2282,21 +2463,18 @@ function resolveUserConfigPath(env = process.env) {
   }
   return getDefaultUserConfigPath(env);
 }
-function isMissingFileError(error) {
-  return asRecord(error)?.code === "ENOENT";
-}
 function hasConfigPathOverride(env) {
   return Boolean(env.LLM_USAGE_CONFIG_PATH?.trim());
 }
 function getLegacyJsonConfigPath(configPath) {
-  return path5.join(path5.dirname(configPath), "config.json");
+  return path6.join(path6.dirname(configPath), "config.json");
 }
 async function throwIfLegacyJsonConfigExists(tomlPath, readFile9) {
   const jsonPath = getLegacyJsonConfigPath(tomlPath);
   try {
     await readFile9(jsonPath);
   } catch (error) {
-    if (isMissingFileError(error)) {
+    if (hasErrorCode(error, "ENOENT")) {
       return;
     }
     throw error;
@@ -2370,14 +2548,14 @@ function resolveConfigPath(value, configDir) {
   if (value === "~") {
     return os4.homedir();
   }
-  if (value.startsWith("~/") || value.startsWith(`~${path5.sep}`)) {
-    return path5.join(os4.homedir(), value.slice(2));
+  if (value.startsWith("~/") || value.startsWith(`~${path6.sep}`)) {
+    return path6.join(os4.homedir(), value.slice(2));
   }
-  return path5.resolve(configDir, value);
+  return path6.resolve(configDir, value);
 }
 function readPath(context, keyPath, value) {
-  const text = readKey(context, keyPath, value, toNonBlankString, "a non-empty path");
-  return text === void 0 ? void 0 : resolveConfigPath(text, context.configDir);
+  const text2 = readKey(context, keyPath, value, toNonBlankString, "a non-empty path");
+  return text2 === void 0 ? void 0 : resolveConfigPath(text2, context.configDir);
 }
 function readLogLevel(value) {
   if (value === "silent" || value === "warn" || value === "info" || value === "debug") {
@@ -2542,6 +2720,65 @@ function readUpdateConfig(context, value) {
   }
   return Object.keys(update).length === 0 ? void 0 : update;
 }
+function readMachinesConfig(context, value) {
+  const record = readTable(context, "machines", value);
+  if (!record) {
+    return void 0;
+  }
+  const machines = {};
+  for (const [name, machineValue] of Object.entries(record)) {
+    const keyPath = `machines.${name}`;
+    if (!isValidMachineName(name)) {
+      context.warnings.push(
+        `Ignoring ${keyPath}: a machine name is 1-32 lowercase letters, digits or dashes, and not "${LOCAL_MACHINE_NAME}"`
+      );
+      continue;
+    }
+    const machineRecord = readTable(context, keyPath, machineValue);
+    if (!machineRecord) {
+      continue;
+    }
+    const ssh = readKey(
+      context,
+      `${keyPath}.ssh`,
+      machineRecord.ssh,
+      (target) => {
+        const text2 = toNonBlankString(target);
+        return text2 !== void 0 && isValidSshTarget(text2) ? text2 : void 0;
+      },
+      'an ssh destination such as "user@host" (no spaces, not starting with -)'
+    );
+    if (ssh === void 0) {
+      if (isUnset(machineRecord.ssh)) {
+        context.warnings.push(`Ignoring ${keyPath}: set ssh = "user@host"`);
+      }
+      continue;
+    }
+    const machine = { ssh };
+    const command = readKey(
+      context,
+      `${keyPath}.command`,
+      machineRecord.command,
+      toNonBlankString,
+      "a non-empty command"
+    );
+    const enabled = readKey(
+      context,
+      `${keyPath}.enabled`,
+      machineRecord.enabled,
+      toBoolean,
+      "true or false"
+    );
+    if (command !== void 0) {
+      machine.command = command;
+    }
+    if (enabled !== void 0) {
+      machine.enabled = enabled;
+    }
+    machines[name] = machine;
+  }
+  return Object.keys(machines).length === 0 ? void 0 : machines;
+}
 function readParseWorkers(value) {
   if (value === "auto") {
     return "auto";
@@ -2597,6 +2834,7 @@ function readConfig(context, root) {
     PARSE_WORKER_MIN_BYTES_MAX
   );
   const update = readUpdateConfig(context, root.update);
+  const machines = readMachinesConfig(context, root.machines);
   if (timezone !== void 0) {
     config.timezone = timezone;
   }
@@ -2630,6 +2868,9 @@ function readConfig(context, root) {
   if (update !== void 0) {
     config.update = update;
   }
+  if (machines !== void 0) {
+    config.machines = machines;
+  }
   return config;
 }
 function collectUnknownKeyWarnings(root) {
@@ -2638,6 +2879,14 @@ function collectUnknownKeyWarnings(root) {
   pushUnknownNestedKeys(unknownKeys, root, "eventStore", knownEventStoreKeySet);
   pushUnknownNestedKeys(unknownKeys, root, "update", knownUpdateKeySet);
   pushUnknownNestedKeys(unknownKeys, root, "sourceDirs", sourceDirKeySet);
+  for (const [name, machine] of Object.entries(asRecord(root.machines) ?? {})) {
+    const machineRecord = asRecord(machine);
+    if (machineRecord) {
+      unknownKeys.push(
+        ...collectUnknownKeys(machineRecord, knownMachineKeySet, `machines.${name}.`)
+      );
+    }
+  }
   const unknownKeyWarning = formatUnknownKeyWarning(unknownKeys);
   return unknownKeyWarning === void 0 ? [] : [unknownKeyWarning];
 }
@@ -2655,13 +2904,13 @@ function parseUserConfigRoot(filePath, content) {
   }
   return root;
 }
-async function loadUserConfig(env = process.env, readFile9 = (filePath) => readFileFromFs(filePath, "utf8")) {
+async function loadUserConfig(env = process.env, readFile9 = readRegularTextFile) {
   const configPath = resolveUserConfigPath(env);
   let content;
   try {
     content = await readFile9(configPath);
   } catch (error) {
-    if (isMissingFileError(error)) {
+    if (hasErrorCode(error, "ENOENT")) {
       if (!hasConfigPathOverride(env)) {
         await throwIfLegacyJsonConfigExists(configPath, readFile9);
       }
@@ -2676,7 +2925,7 @@ async function loadUserConfig(env = process.env, readFile9 = (filePath) => readF
   }
   const root = parseUserConfigRoot(configPath, content);
   const context = {
-    configDir: path5.dirname(path5.resolve(configPath)),
+    configDir: path6.dirname(path6.resolve(configPath)),
     warnings: []
   };
   const config = readConfig(context, root);
@@ -2689,8 +2938,7 @@ async function loadUserConfig(env = process.env, readFile9 = (filePath) => readF
 }
 
 // src/update/update-cache-repository.ts
-import { mkdir as mkdir2, readFile } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 import { setTimeout as sleepTimer } from "timers/promises";
 
 // src/update/version-utils.ts
@@ -2813,7 +3061,7 @@ async function sleep(delayMs, signal) {
   await sleepTimer(delayMs, void 0, { signal });
 }
 function getDefaultUpdateCheckCachePath() {
-  return path6.join(getUserCacheRootDir(), "llm-usage-metrics", "update-check.json");
+  return path7.join(getUserCacheRootDir(), "llm-usage-metrics", "update-check.json");
 }
 function sanitizeCachePathFragment(value) {
   return value.replace(/[^\w.-]/gu, "_");
@@ -2836,8 +3084,8 @@ function getSessionScopedCachePath(baseCacheFilePath, env, options = {}) {
   }
   const parentPid = options.parentPid ?? process.ppid;
   const sessionKey = toCacheSessionKey(env[UPDATE_CHECK_CACHE_SESSION_KEY_ENV_VAR]) ?? `ppid-${parentPid}`;
-  const parsedPath = path6.parse(baseCacheFilePath);
-  return path6.join(parsedPath.dir, `${parsedPath.name}.${sessionKey}${parsedPath.ext}`);
+  const parsedPath = path7.parse(baseCacheFilePath);
+  return path7.join(parsedPath.dir, `${parsedPath.name}.${sessionKey}${parsedPath.ext}`);
 }
 function toNonNegativeNumber2(value) {
   if (typeof value !== "number") {
@@ -2861,7 +3109,7 @@ function isCacheFresh(payload, cacheTtlMs, now) {
 async function readUpdateCheckCachePayload(cacheFilePath) {
   let content;
   try {
-    content = await readFile(cacheFilePath, "utf8");
+    content = await readRegularTextFile(cacheFilePath);
   } catch {
     return void 0;
   }
@@ -2886,7 +3134,7 @@ async function readUpdateCheckCachePayload(cacheFilePath) {
   };
 }
 async function writeUpdateCheckCachePayload(cacheFilePath, payload) {
-  await mkdir2(path6.dirname(cacheFilePath), { recursive: true });
+  await ensureDirectory(path7.dirname(cacheFilePath));
   await writeFileAtomic(cacheFilePath, JSON.stringify(payload));
 }
 async function fetchLatestVersion(packageName, fetchImpl, fetchTimeoutMs, signal) {
@@ -3015,6 +3263,7 @@ function shouldSkipUpdateCheckForArgv(argv) {
     "efficiency",
     "optimize",
     "statusline",
+    "machine",
     "help",
     "version"
   ]);
@@ -3025,7 +3274,7 @@ function shouldSkipUpdateCheckForArgv(argv) {
     return true;
   }
   const firstRecognizedCommand = executableArgs.find((arg) => commandNames.has(arg));
-  return firstRecognizedCommand === "help" || firstRecognizedCommand === "version" || firstRecognizedCommand === "statusline";
+  return firstRecognizedCommand === "help" || firstRecognizedCommand === "version" || firstRecognizedCommand === "statusline" || firstRecognizedCommand === "machine" && executableArgs[executableArgs.indexOf("machine") + 1] === "export";
 }
 function isLikelyNpxExecution(argv, env) {
   const executablePath = argv[1] ?? "";
@@ -3149,12 +3398,9 @@ var logger = {
 };
 
 // src/utils/stdout-pipe-errors.ts
-function isBrokenPipeError(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "EPIPE";
-}
 function exitQuietlyOnBrokenPipe(stream, exit = () => process.exit()) {
   stream.on("error", (error) => {
-    if (isBrokenPipeError(error)) {
+    if (hasErrorCode(error, "EPIPE")) {
       exit();
       return;
     }
@@ -3163,7 +3409,7 @@ function exitQuietlyOnBrokenPipe(stream, exit = () => process.exit()) {
 }
 
 // src/cli/create-cli.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/utils/suggest-closest.ts
 function editDistance(left, right4) {
@@ -3231,7 +3477,26 @@ function getDateTimeFormatter(timezone) {
   dateTimeFormatterCache.set(timezone, formatter);
   return formatter;
 }
+var MAX_MEMOIZED_TIMESTAMPS = 1e5;
+var localDatePartsByTimestamp = /* @__PURE__ */ new Map();
 function extractLocalDateParts(timestampIso, timezone) {
+  let partsByTimestamp = localDatePartsByTimestamp.get(timezone);
+  if (!partsByTimestamp) {
+    partsByTimestamp = /* @__PURE__ */ new Map();
+    localDatePartsByTimestamp.set(timezone, partsByTimestamp);
+  }
+  const cachedParts = partsByTimestamp.get(timestampIso);
+  if (cachedParts) {
+    return cachedParts;
+  }
+  const parts = parseLocalDateParts(timestampIso, timezone);
+  if (partsByTimestamp.size >= MAX_MEMOIZED_TIMESTAMPS) {
+    partsByTimestamp.clear();
+  }
+  partsByTimestamp.set(timestampIso, parts);
+  return parts;
+}
+function parseLocalDateParts(timestampIso, timezone) {
   const date = new Date(timestampIso);
   const timestampMs = date.getTime();
   if (Number.isNaN(timestampMs)) {
@@ -3564,6 +3829,21 @@ function sourceSortComparator(left, right4, sourceWeightMap) {
   }
   return compareByCodePoint(left, right4);
 }
+function toMachineRowKey(source, machine) {
+  return `${source}\0${machine}`;
+}
+function fromMachineRowKey(rowKey) {
+  const separator = rowKey.indexOf("\0");
+  return { source: rowKey.slice(0, separator), machine: rowKey.slice(separator + 1) };
+}
+function compareRowKeys(left, right4, sourceWeightMap, byMachine) {
+  if (!byMachine) {
+    return sourceSortComparator(left, right4, sourceWeightMap);
+  }
+  const leftKey = fromMachineRowKey(left);
+  const rightKey = fromMachineRowKey(right4);
+  return sourceSortComparator(leftKey.source, rightKey.source, sourceWeightMap) || Number(leftKey.machine !== LOCAL_MACHINE_NAME) - Number(rightKey.machine !== LOCAL_MACHINE_NAME) || compareByCodePoint(leftKey.machine, rightKey.machine);
+}
 function aggregateUsage(events, options) {
   const includeModelBreakdown = options.includeModelBreakdown ?? true;
   const sourceWeightMap = /* @__PURE__ */ new Map();
@@ -3575,8 +3855,9 @@ function aggregateUsage(events, options) {
     const periodKey = getPeriodKey(event.timestamp, options.granularity, options.timezone);
     const periodSources = periodMap.get(periodKey) ?? /* @__PURE__ */ new Map();
     periodMap.set(periodKey, periodSources);
-    const rowAccumulator = periodSources.get(event.source) ?? createRowAccumulator(includeModelBreakdown);
-    periodSources.set(event.source, rowAccumulator);
+    const rowKey = options.byMachine ? toMachineRowKey(event.source, event.machine ?? LOCAL_MACHINE_NAME) : event.source;
+    const rowAccumulator = periodSources.get(rowKey) ?? createRowAccumulator(includeModelBreakdown);
+    periodSources.set(rowKey, rowAccumulator);
     addEventToAccumulator(rowAccumulator, event, includeModelBreakdown);
   }
   const sortedPeriodKeys = [...periodMap.keys()].sort(compareByCodePoint);
@@ -3590,11 +3871,12 @@ function aggregateUsage(events, options) {
     }
     const periodCombinedTotals = createEmptyTotals();
     const periodCombinedModelTotals = /* @__PURE__ */ new Map();
-    const sortedSources = [...sourceMap.keys()].sort(
-      (left, right4) => sourceSortComparator(left, right4, sourceWeightMap)
+    const sortedRowKeys = [...sourceMap.keys()].sort(
+      (left, right4) => compareRowKeys(left, right4, sourceWeightMap, options.byMachine === true)
     );
-    for (const source of sortedSources) {
-      const accumulator = sourceMap.get(source);
+    for (const rowKey of sortedRowKeys) {
+      const accumulator = sourceMap.get(rowKey);
+      const { source, machine } = options.byMachine ? fromMachineRowKey(rowKey) : { source: rowKey, machine: void 0 };
       if (!accumulator) {
         continue;
       }
@@ -3603,6 +3885,7 @@ function aggregateUsage(events, options) {
         rowType: "period_source",
         periodKey,
         source,
+        ...machine === void 0 ? {} : { machine },
         models: rankedModelUsage.models,
         modelBreakdown: rankedModelUsage.modelBreakdown,
         ...accumulator.totals
@@ -3615,7 +3898,7 @@ function aggregateUsage(events, options) {
         mergeModelTotals(grandModelTotals, accumulator.modelTotals);
       }
     }
-    if (sortedSources.length > 1) {
+    if (sortedRowKeys.length > 1) {
       const rankedCombinedModels = includeModelBreakdown ? toRankedModelUsage(periodCombinedModelTotals) : { models: [], modelBreakdown: [] };
       const combinedRow = {
         rowType: "period_combined",
@@ -3871,11 +4154,11 @@ async function resolveUserConfigForOptions(options, deps = {}) {
 
 // src/sources/amp/amp-source-adapter.ts
 import os5 from "os";
-import path8 from "path";
+import path9 from "path";
 
 // src/utils/discover-files.ts
 import { readdir, realpath, stat as stat2 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 var UNRESOLVABLE_SYMLINK_ERROR_CODES = /* @__PURE__ */ new Set(["ENOENT", "ELOOP", "ENOTDIR", "ENAMETOOLONG"]);
 function getNodeErrorCode(error) {
   const record = asRecord(error);
@@ -3934,7 +4217,7 @@ async function walkDirectory(rootDir, acc, options, ancestryRealPaths) {
     entries.sort((left, right4) => compareByCodePoint(left.name, right4.name));
   }
   for (const entry of entries) {
-    const entryPath = path7.join(rootDir, entry.name);
+    const entryPath = path8.join(rootDir, entry.name);
     if (entry.isSymbolicLink()) {
       try {
         const entryStats = await stat2(entryPath);
@@ -3943,7 +4226,7 @@ async function walkDirectory(rootDir, acc, options, ancestryRealPaths) {
           await walkDirectory(entryPath, acc, options, nextAncestryRealPaths);
           continue;
         }
-        if (entryStats.isFile() && (matchesExtension(entry.name, options.extension) || matchesExtension(path7.basename(resolvedEntryPath), options.extension))) {
+        if (entryStats.isFile() && (matchesExtension(entry.name, options.extension) || matchesExtension(path8.basename(resolvedEntryPath), options.extension))) {
           acc.push(entryPath);
         }
       } catch (error) {
@@ -4140,13 +4423,13 @@ function normalizeEnvPath(value) {
   return normalized || void 0;
 }
 function resolveDefaultAmpThreadsDir(env, homeDir) {
-  const dataHome = normalizeEnvPath(env.XDG_DATA_HOME) ?? path8.join(homeDir, ".local", "share");
-  return path8.join(dataHome, "amp", "threads");
+  const dataHome = normalizeEnvPath(env.XDG_DATA_HOME) ?? path9.join(homeDir, ".local", "share");
+  return path9.join(dataHome, "amp", "threads");
 }
 function toIdentityText(value) {
-  const text = asTrimmedText(value);
-  if (text) {
-    return text;
+  const text2 = asTrimmedText(value);
+  if (text2) {
+    return text2;
   }
   if (typeof value === "number" && Number.isFinite(value)) {
     return String(Math.trunc(value));
@@ -4392,20 +4675,20 @@ var AmpSourceAdapter = class {
 };
 
 // src/sources/antigravity/antigravity-source-adapter.ts
-import path10 from "path";
+import path11 from "path";
 
 // src/sources/antigravity/antigravity-path-resolver.ts
 import os6 from "os";
-import path9 from "path";
+import path10 from "path";
 function resolveGeminiCliHome(options) {
-  return asTrimmedText(options.env.GEMINI_CLI_HOME) ?? path9.join(options.homeDir, ".gemini");
+  return asTrimmedText(options.env.GEMINI_CLI_HOME) ?? path10.join(options.homeDir, ".gemini");
 }
 function getDefaultAntigravityConversationsDir(options = {}) {
   const resolvedOptions = {
     env: options.env ?? process.env,
     homeDir: options.homeDir ?? os6.homedir()
   };
-  return path9.join(resolveGeminiCliHome(resolvedOptions), "antigravity-cli", "conversations");
+  return path10.join(resolveGeminiCliHome(resolvedOptions), "antigravity-cli", "conversations");
 }
 
 // src/sources/antigravity/antigravity-proto-reader.ts
@@ -4786,7 +5069,7 @@ var AntigravitySourceAdapter = class {
       const skippedRowReasons = /* @__PURE__ */ new Map();
       for (const row of rows) {
         const parsedRow = parseAntigravityMetadataBlob(row.data, {
-          sessionId: path10.basename(normalizedDbPath, path10.extname(normalizedDbPath)),
+          sessionId: path11.basename(normalizedDbPath, path11.extname(normalizedDbPath)),
           fallbackTimestamp,
           seenResponseIds
         });
@@ -4810,7 +5093,7 @@ var AntigravitySourceAdapter = class {
 
 // src/sources/claude/claude-source-adapter.ts
 import os7 from "os";
-import path13 from "path";
+import path14 from "path";
 
 // src/utils/discover-jsonl-files.ts
 async function discoverJsonlFiles(rootDir) {
@@ -4912,7 +5195,7 @@ function isBlankLine(lineBytes, lineStart, lineEnd) {
 }
 
 // src/sources/multi-root-discovery.ts
-import path11 from "path";
+import path12 from "path";
 function resolveRootDirs(overrideDir, defaultRootDirs2) {
   if (overrideDir === void 0) {
     return defaultRootDirs2;
@@ -4920,10 +5203,10 @@ function resolveRootDirs(overrideDir, defaultRootDirs2) {
   return typeof overrideDir === "string" ? [overrideDir] : overrideDir;
 }
 function isPathWithinRoots(filePath, rootDirs) {
-  const resolvedFilePath = path11.resolve(filePath);
+  const resolvedFilePath = path12.resolve(filePath);
   return rootDirs.some((rootDir) => {
-    const relativePath = path11.relative(path11.resolve(rootDir.trim()), resolvedFilePath);
-    return relativePath.length > 0 && !relativePath.startsWith("..") && !path11.isAbsolute(relativePath);
+    const relativePath = path12.relative(path12.resolve(rootDir.trim()), resolvedFilePath);
+    return relativePath.length > 0 && !relativePath.startsWith("..") && !path12.isAbsolute(relativePath);
   });
 }
 async function discoverFilesAcrossRoots(options) {
@@ -4942,22 +5225,22 @@ async function discoverFilesAcrossRoots(options) {
     discoveredFiles.push(...await options.discoverInRoot(normalizedRootDir));
   }
   const uniqueFiles = [
-    ...new Map(discoveredFiles.map((filePath) => [path11.resolve(filePath), filePath])).values()
+    ...new Map(discoveredFiles.map((filePath) => [path12.resolve(filePath), filePath])).values()
   ];
   return options.sortAcrossRoots ? uniqueFiles.sort(compareByCodePoint) : uniqueFiles;
 }
 
 // src/sources/claude/claude-fork-transcript.ts
-import path12 from "path";
+import path13 from "path";
 var SUBAGENT_TRANSCRIPT_PATTERN = /^agent-([\w-]+)\.jsonl$/u;
 var SUBAGENTS_DIR_NAME = "subagents";
 var CLAUDE_ASSISTANT_BYTES = Buffer.from('"assistant"');
 function getClaudeSubagentMetaPath(filePath) {
-  const match = SUBAGENT_TRANSCRIPT_PATTERN.exec(path12.basename(filePath));
-  if (!match || path12.basename(path12.dirname(filePath)) !== SUBAGENTS_DIR_NAME) {
+  const match = SUBAGENT_TRANSCRIPT_PATTERN.exec(path13.basename(filePath));
+  if (!match || path13.basename(path13.dirname(filePath)) !== SUBAGENTS_DIR_NAME) {
     return void 0;
   }
-  return path12.join(path12.dirname(filePath), `agent-${match[1]}.meta.json`);
+  return path13.join(path13.dirname(filePath), `agent-${match[1]}.meta.json`);
 }
 async function resolveClaudeForkParentPath(filePath) {
   const metaPath = getClaudeSubagentMetaPath(filePath);
@@ -4969,12 +5252,12 @@ async function resolveClaudeForkParentPath(filePath) {
   if (meta?.isFork !== true) {
     return void 0;
   }
-  const subagentsDir = path12.dirname(filePath);
+  const subagentsDir = path13.dirname(filePath);
   const parentAgentId = asTrimmedText(meta.parentAgentId);
   if (parentAgentId) {
-    return SUBAGENT_TRANSCRIPT_PATTERN.test(`agent-${parentAgentId}.jsonl`) ? path12.join(subagentsDir, `agent-${parentAgentId}.jsonl`) : void 0;
+    return SUBAGENT_TRANSCRIPT_PATTERN.test(`agent-${parentAgentId}.jsonl`) ? path13.join(subagentsDir, `agent-${parentAgentId}.jsonl`) : void 0;
   }
-  return `${path12.dirname(subagentsDir)}.jsonl`;
+  return `${path13.dirname(subagentsDir)}.jsonl`;
 }
 function getClaudeMessageKey(line, message) {
   const messageId = asTrimmedText(message.id);
@@ -5003,12 +5286,12 @@ async function readClaudeMessageKeys(filePath) {
 
 // src/sources/claude/claude-source-adapter.ts
 function getClaudeRootDirsForConfigDir(configDir) {
-  return [path13.join(configDir, "projects"), path13.join(configDir, "transcripts")];
+  return [path14.join(configDir, "projects"), path14.join(configDir, "transcripts")];
 }
 function resolveDefaultClaudeRootDirs(env = process.env, homeDir = os7.homedir()) {
   const configDirs = (env.CLAUDE_CONFIG_DIR ?? "").split(",").map((configDir) => configDir.trim()).filter((configDir) => configDir.length > 0);
   if (configDirs.length === 0) {
-    return getClaudeRootDirsForConfigDir(path13.join(homeDir, ".claude"));
+    return getClaudeRootDirsForConfigDir(path14.join(homeDir, ".claude"));
   }
   return configDirs.flatMap((configDir) => getClaudeRootDirsForConfigDir(configDir));
 }
@@ -5018,7 +5301,7 @@ function shouldParseClaudeJsonlLineBytes(lineBytes) {
   return lineBytes.includes(CLAUDE_ASSISTANT_BYTES2) && lineBytes.includes(CLAUDE_USAGE_BYTES);
 }
 function getFallbackSessionId(filePath) {
-  return path13.basename(filePath, ".jsonl");
+  return path14.basename(filePath, ".jsonl");
 }
 function resolveProvider(message, model) {
   const explicitProvider = asTrimmedText(message.provider);
@@ -5204,11 +5487,11 @@ var ClaudeSourceAdapter = class {
 
 // src/sources/cline/cline-family-adapter.ts
 import os8 from "os";
-import path15 from "path";
+import path16 from "path";
 
 // src/sources/cline/cline-task-parser.ts
 import { readFile as readFile3 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 var ENVIRONMENT_DETAILS_OPEN_TAG = "<environment_details>";
 var ENVIRONMENT_DETAILS_CLOSE_TAG = "</environment_details>";
 var MODEL_OPEN_TAG = "<model>";
@@ -5242,10 +5525,10 @@ function incrementContextSkippedReason2(context, reason) {
   incrementSkippedReason(context.skippedRowReasons, reason);
 }
 function getTaskId(filePath) {
-  return path14.basename(path14.dirname(filePath));
+  return path15.basename(path15.dirname(filePath));
 }
 function getClineTaskHistoryPath(uiMessagesPath) {
-  return path14.join(path14.dirname(uiMessagesPath), "api_conversation_history.json");
+  return path15.join(path15.dirname(uiMessagesPath), "api_conversation_history.json");
 }
 var CACHE_INCLUSIVE_INPUT_SOURCE_IDS = /* @__PURE__ */ new Set(["roocode", "kilocode"]);
 function resolveInputTokens(sourceId, tokensIn, cacheReadTokens, cacheWriteTokens) {
@@ -5280,12 +5563,12 @@ function extractUsage(sourceId, payload) {
   };
 }
 function parsePayload(entry) {
-  const text = asTrimmedText(entry.text);
-  if (!text) {
+  const text2 = asTrimmedText(entry.text);
+  if (!text2) {
     return void 0;
   }
   try {
-    return asRecord(JSON.parse(text));
+    return asRecord(JSON.parse(text2));
   } catch {
     return void 0;
   }
@@ -5402,23 +5685,23 @@ function normalizeEnvPath2(value) {
   return normalized || void 0;
 }
 function getExtensionTasksDir(codeRoot, extensionId) {
-  return path15.join(codeRoot, "User", "globalStorage", extensionId, "tasks");
+  return path16.join(codeRoot, "User", "globalStorage", extensionId, "tasks");
 }
 function getWindowsCodeRoot(homeDir, env) {
-  const appDataRoot = normalizeEnvPath2(env.APPDATA) ?? normalizeEnvPath2(env.USERPROFILE) ?? path15.join(homeDir, "AppData", "Roaming");
-  if (appDataRoot.endsWith(`${path15.sep}Code`) || path15.basename(appDataRoot) === "Code") {
+  const appDataRoot = normalizeEnvPath2(env.APPDATA) ?? normalizeEnvPath2(env.USERPROFILE) ?? path16.join(homeDir, "AppData", "Roaming");
+  if (appDataRoot.endsWith(`${path16.sep}Code`) || path16.basename(appDataRoot) === "Code") {
     return appDataRoot;
   }
-  return path15.join(appDataRoot, "Code");
+  return path16.join(appDataRoot, "Code");
 }
 function getPlatformCodeRoots(platform, homeDir, env) {
   switch (platform) {
     case "win32":
       return [getWindowsCodeRoot(homeDir, env)];
     case "darwin":
-      return [path15.join(homeDir, "Library", "Application Support", "Code")];
+      return [path16.join(homeDir, "Library", "Application Support", "Code")];
     default:
-      return [path15.join(homeDir, ".config", "Code")];
+      return [path16.join(homeDir, ".config", "Code")];
   }
 }
 function getDefaultClineTaskRootCandidates(options) {
@@ -5426,7 +5709,7 @@ function getDefaultClineTaskRootCandidates(options) {
   const homeDir = options.homeDir ?? os8.homedir();
   const env = options.env ?? process.env;
   const localRoots = getPlatformCodeRoots(platform, homeDir, env);
-  const remoteRoots = [path15.join(homeDir, ".vscode-server", "data")];
+  const remoteRoots = [path16.join(homeDir, ".vscode-server", "data")];
   const tasksDirs = [...localRoots, ...remoteRoots].map(
     (root) => getExtensionTasksDir(root, options.extensionId)
   );
@@ -5434,7 +5717,7 @@ function getDefaultClineTaskRootCandidates(options) {
 }
 async function discoverUiMessageFiles(rootDir) {
   const jsonFiles = await discoverFiles(rootDir, { extension: ".json" });
-  return jsonFiles.filter((filePath) => path15.basename(filePath) === "ui_messages.json");
+  return jsonFiles.filter((filePath) => path16.basename(filePath) === "ui_messages.json");
 }
 var ClineFamilyAdapter = class {
   id;
@@ -5479,9 +5762,9 @@ function createClineFamilyAdapter(options) {
 
 // src/sources/codex/codex-source-adapter.ts
 import os9 from "os";
-import path16 from "path";
+import path17 from "path";
 function resolveDefaultCodexSessionsDir(env = process.env, homeDir = os9.homedir()) {
-  return path16.join(asTrimmedText(env.CODEX_HOME) ?? path16.join(homeDir, ".codex"), "sessions");
+  return path17.join(asTrimmedText(env.CODEX_HOME) ?? path17.join(homeDir, ".codex"), "sessions");
 }
 var LEGACY_CODEX_MODEL_FALLBACK = "legacy-codex-unknown";
 var SESSION_META_BYTES = Buffer.from('"session_meta"');
@@ -5611,7 +5894,7 @@ function createLastUsageOnlyKey(timestamp, usage) {
   ].join(":");
 }
 function getFallbackSessionId2(filePath) {
-  return path16.basename(filePath, ".jsonl");
+  return path17.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromPayload(payload) {
   if (!payload) {
@@ -5811,9 +6094,9 @@ var CodexSourceAdapter = class {
 
 // src/sources/copilot/copilot-source-adapter.ts
 import os10 from "os";
-import path17 from "path";
+import path18 from "path";
 import { realpath as realpath2 } from "fs/promises";
-var defaultOtelDir = path17.join(os10.homedir(), ".copilot", "otel");
+var defaultOtelDir = path18.join(os10.homedir(), ".copilot", "otel");
 function shouldParseCopilotJsonlLine(lineText) {
   return lineText.includes('"attributes"');
 }
@@ -5928,7 +6211,7 @@ function hasTokenUsage(candidate) {
   return candidate.inputTokens + candidate.outputTokens + candidate.reasoningTokens + candidate.cacheReadTokens + candidate.cacheWriteTokens + (candidate.totalTokens ?? 0) > 0;
 }
 function getFallbackSessionId3(filePath) {
-  return path17.basename(filePath, ".jsonl");
+  return path18.basename(filePath, ".jsonl");
 }
 function extractCandidate(record, filePath, lineIndex) {
   const attributes = asRecord(record.attributes);
@@ -6126,18 +6409,18 @@ var CopilotSourceAdapter = class {
 
 // src/sources/droid/droid-source-adapter.ts
 import os11 from "os";
-import path18 from "path";
-var defaultSessionsDir = path18.join(os11.homedir(), ".factory", "sessions");
+import path19 from "path";
+var defaultSessionsDir = path19.join(os11.homedir(), ".factory", "sessions");
 var DROID_SESSION_START_LINE_PATTERN = /"type"\s*:\s*"session_start"/u;
 var DROID_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 function shouldParseDroidJsonlLine(lineText) {
   return DROID_SESSION_START_LINE_PATTERN.test(lineText) || DROID_MESSAGE_LINE_PATTERN.test(lineText);
 }
 function getSettingsSessionId(filePath) {
-  return path18.basename(filePath, ".settings.json");
+  return path19.basename(filePath, ".settings.json");
 }
 function getSiblingJsonlPath(settingsPath) {
-  return path18.join(path18.dirname(settingsPath), `${getSettingsSessionId(settingsPath)}.jsonl`);
+  return path19.join(path19.dirname(settingsPath), `${getSettingsSessionId(settingsPath)}.jsonl`);
 }
 function isSessionStartRecord(line) {
   return asTrimmedText(line.type) === "session_start";
@@ -6286,7 +6569,7 @@ var DroidSourceAdapter = class {
 };
 
 // src/sources/dsh/dsh-source-adapter.ts
-import path20 from "path";
+import path21 from "path";
 
 // src/sources/dsh/dsh-session-log-reader.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -6347,8 +6630,8 @@ async function decodeFrame(frameBytes) {
   }
   return decoded;
 }
-function* parseJsonlLines(text, options) {
-  for (const rawLine of text.split("\n")) {
+function* parseJsonlLines(text2, options) {
+  for (const rawLine of text2.split("\n")) {
     const line = rawLine.trim();
     if (line.length === 0 || !options.shouldParseLine(line)) {
       continue;
@@ -6399,17 +6682,17 @@ async function* readDshSessionLogRecords(filePath, options) {
 
 // src/sources/dsh/dsh-path-resolver.ts
 import os12 from "os";
-import path19 from "path";
+import path20 from "path";
 function resolveDshHome(options) {
   const configuredHome = asTrimmedText(options.env.DSH_HOME);
   if (!configuredHome) {
-    return path19.join(options.homeDir, ".dsh");
+    return path20.join(options.homeDir, ".dsh");
   }
   if (configuredHome === "~") {
     return options.homeDir;
   }
   if (configuredHome.startsWith("~/") || configuredHome.startsWith("~\\")) {
-    return path19.join(options.homeDir, configuredHome.slice(2));
+    return path20.join(options.homeDir, configuredHome.slice(2));
   }
   return configuredHome;
 }
@@ -6418,7 +6701,7 @@ function getDefaultDshSessionsDir(options = {}) {
     env: options.env ?? process.env,
     homeDir: options.homeDir ?? os12.homedir()
   };
-  return path19.join(resolveDshHome(resolvedOptions), "sessions");
+  return path20.join(resolveDshHome(resolvedOptions), "sessions");
 }
 
 // src/sources/dsh/dsh-source-adapter.ts
@@ -6433,11 +6716,11 @@ function isDshSessionLogFile(fileName) {
   return DSH_SESSION_LOG_FILENAME_PATTERN.test(fileName);
 }
 function getFallbackSessionId4(filePath) {
-  const parentDirName = path20.basename(path20.dirname(filePath));
+  const parentDirName = path21.basename(path21.dirname(filePath));
   if (parentDirName.startsWith("session-")) {
     return parentDirName;
   }
-  return path20.basename(filePath).replace(/\.zstd$/u, "");
+  return path21.basename(filePath).replace(/\.zstd$/u, "");
 }
 function resolveRoute(record) {
   const route = asRecord(record?.route) ?? record;
@@ -6502,7 +6785,7 @@ var DshSourceAdapter = class {
           ...await discoverFiles(rootDir, { extension: ".jsonl" }),
           ...await discoverFiles(rootDir, { extension: ".jsonl.zstd" })
         ];
-        return discovered.filter((filePath) => isDshSessionLogFile(path20.basename(filePath)));
+        return discovered.filter((filePath) => isDshSessionLogFile(path21.basename(filePath)));
       }
     });
   }
@@ -6589,19 +6872,19 @@ var DshSourceAdapter = class {
 };
 
 // src/sources/gemini/gemini-source-adapter.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
 import os13 from "os";
-import path21 from "path";
-var defaultGeminiDir = path21.join(os13.homedir(), ".gemini");
+import path22 from "path";
+var defaultGeminiDir = path22.join(os13.homedir(), ".gemini");
 function resolveDefaultGeminiDir(env) {
   return asTrimmedText(env.GEMINI_CLI_HOME) ?? defaultGeminiDir;
 }
 function getProjectsJsonPath(geminiDir) {
-  return path21.join(geminiDir, "projects.json");
+  return path22.join(geminiDir, "projects.json");
 }
 function hashProjectPath(projectPath) {
-  return createHash2("sha256").update(projectPath).digest("hex");
+  return createHash3("sha256").update(projectPath).digest("hex");
 }
 function parseProjectsJson(data) {
   const mapping = /* @__PURE__ */ new Map();
@@ -6645,7 +6928,7 @@ async function loadProjectsJson(geminiDir) {
   }
 }
 async function discoverSessionFiles(geminiDir) {
-  const tmpDir = path21.join(geminiDir, "tmp");
+  const tmpDir = path22.join(geminiDir, "tmp");
   let projectEntries;
   try {
     projectEntries = await readdir2(tmpDir, { withFileTypes: true, encoding: "utf8" });
@@ -6662,7 +6945,7 @@ async function discoverSessionFiles(geminiDir) {
     if (!projectEntry.isDirectory() && !projectEntry.isSymbolicLink()) {
       continue;
     }
-    const chatsDir = path21.join(tmpDir, projectEntry.name, "chats");
+    const chatsDir = path22.join(tmpDir, projectEntry.name, "chats");
     const discoveredChatFiles = await discoverFiles(chatsDir, { extension: ".json" });
     allSessionFiles.push(...discoveredChatFiles);
   }
@@ -6676,9 +6959,9 @@ function resolveRepoRoot(filePath, sessionData, projectMapping) {
       return mappedRoot;
     }
   }
-  const chatsDir = path21.dirname(filePath);
-  const projectDir = path21.dirname(chatsDir);
-  const projectIdentifier = path21.basename(projectDir);
+  const chatsDir = path22.dirname(filePath);
+  const projectDir = path22.dirname(chatsDir);
+  const projectIdentifier = path22.basename(projectDir);
   return projectMapping.get(projectIdentifier);
 }
 function toFiniteNumber3(value) {
@@ -6793,7 +7076,7 @@ var GeminiSourceAdapter = class {
       incrementSkippedReason(skippedRowReasons, "invalid_session_data");
       return toParseDiagnostics(events, skippedRows, skippedRowReasons);
     }
-    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path21.basename(filePath, ".json");
+    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path22.basename(filePath, ".json");
     const projectMapping = await this.getProjectMappingForParse();
     const repoRoot = resolveRepoRoot(filePath, sessionDataRecord, projectMapping);
     if (!Array.isArray(sessionDataRecord.messages)) {
@@ -6851,7 +7134,7 @@ var GeminiSourceAdapter = class {
 
 // src/sources/goose/goose-db-path-resolver.ts
 import os14 from "os";
-import path22 from "path";
+import path23 from "path";
 function deduplicate(paths) {
   return [...new Set(paths)];
 }
@@ -6863,28 +7146,28 @@ function normalizeEnvPath3(value) {
   return normalized || void 0;
 }
 function getGooseDbPath(rootDir) {
-  return path22.join(rootDir, "goose", "sessions", "sessions.db");
+  return path23.join(rootDir, "goose", "sessions", "sessions.db");
 }
 function getLinuxLikeCandidates(homeDir, env) {
-  const xdgDataHome = normalizeEnvPath3(env.XDG_DATA_HOME) ?? path22.join(homeDir, ".local", "share");
+  const xdgDataHome = normalizeEnvPath3(env.XDG_DATA_HOME) ?? path23.join(homeDir, ".local", "share");
   return [
     getGooseDbPath(xdgDataHome),
-    path22.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
+    path23.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
   ];
 }
 function getMacOsCandidates(homeDir) {
   return [
-    path22.join(homeDir, "Library", "Application Support", "goose", "sessions", "sessions.db"),
-    path22.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
+    path23.join(homeDir, "Library", "Application Support", "goose", "sessions", "sessions.db"),
+    path23.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
   ];
 }
 function getWindowsCandidates(homeDir, env) {
   const userProfile = normalizeEnvPath3(env.USERPROFILE);
-  const roamingBase = normalizeEnvPath3(env.APPDATA) ?? normalizeEnvPath3(env.LOCALAPPDATA) ?? (userProfile ? path22.join(userProfile, "AppData", "Roaming") : void 0);
+  const roamingBase = normalizeEnvPath3(env.APPDATA) ?? normalizeEnvPath3(env.LOCALAPPDATA) ?? (userProfile ? path23.join(userProfile, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [getGooseDbPath(roamingBase)] : [];
   return [
     ...roamingCandidates,
-    path22.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
+    path23.join(homeDir, ".local", "share", "Block", "goose", "sessions", "sessions.db")
   ];
 }
 function getDefaultGooseDbPathCandidates(options = {}) {
@@ -6892,7 +7175,7 @@ function getDefaultGooseDbPathCandidates(options = {}) {
   const homeDir = options.homeDir ?? os14.homedir();
   const env = options.env ?? process.env;
   const goosePathRoot = normalizeEnvPath3(env.GOOSE_PATH_ROOT);
-  const envCandidates = goosePathRoot ? [path22.join(goosePathRoot, "data", "sessions", "sessions.db")] : [];
+  const envCandidates = goosePathRoot ? [path23.join(goosePathRoot, "data", "sessions", "sessions.db")] : [];
   switch (platform) {
     case "win32":
       return deduplicate([...envCandidates, ...getWindowsCandidates(homeDir, env)]);
@@ -7094,9 +7377,9 @@ var GooseSourceAdapter = class {
 // src/sources/kimi/kimi-source-adapter.ts
 import { readFile as readFile6 } from "fs/promises";
 import os15 from "os";
-import path23 from "path";
-var defaultKimiCliSessionsDir = path23.join(os15.homedir(), ".kimi", "sessions");
-var defaultKimiCodeSessionsDir = path23.join(os15.homedir(), ".kimi-code", "sessions");
+import path24 from "path";
+var defaultKimiCliSessionsDir = path24.join(os15.homedir(), ".kimi", "sessions");
+var defaultKimiCodeSessionsDir = path24.join(os15.homedir(), ".kimi-code", "sessions");
 var defaultRootDirs = [defaultKimiCliSessionsDir, defaultKimiCodeSessionsDir];
 var KIMI_STATUS_UPDATE_LINE_TEXT = '"StatusUpdate"';
 var KIMI_USAGE_RECORD_LINE_TEXT = '"usage.record"';
@@ -7143,14 +7426,14 @@ function incrementContextSkippedReason3(context, reason) {
   incrementSkippedReason(context.skippedRowReasons, reason);
 }
 function getCliSessionId(filePath) {
-  return path23.basename(path23.dirname(filePath));
+  return path24.basename(path24.dirname(filePath));
 }
 function getCliConfigPath(filePath) {
-  const sessionsDir = path23.dirname(path23.dirname(path23.dirname(filePath)));
-  return path23.join(path23.dirname(sessionsDir), "config.json");
+  const sessionsDir = path24.dirname(path24.dirname(path24.dirname(filePath)));
+  return path24.join(path24.dirname(sessionsDir), "config.json");
 }
 function isCodeWireFile(filePath) {
-  return path23.basename(path23.dirname(path23.dirname(filePath))) === "agents";
+  return path24.basename(path24.dirname(path24.dirname(filePath))) === "agents";
 }
 async function readCliConfigModel(filePath) {
   try {
@@ -7164,10 +7447,10 @@ function getCliFallbackModel(timestamp) {
   return Date.parse(timestamp) < KIMI_K2_6_CUTOFF_MS ? KIMI_K2_5_MODEL : KIMI_K2_6_MODEL;
 }
 function getCodeSessionId(filePath) {
-  const agentDir = path23.dirname(filePath);
-  const agentsDir = path23.dirname(agentDir);
-  const sessionDir = path23.dirname(agentsDir);
-  return path23.basename(sessionDir);
+  const agentDir = path24.dirname(filePath);
+  const agentsDir = path24.dirname(agentDir);
+  const sessionDir = path24.dirname(agentsDir);
+  return path24.basename(sessionDir);
 }
 function normalizeKimiCodeModel(model) {
   const normalizedModel = asTrimmedText(model);
@@ -7268,7 +7551,7 @@ function parseUsageRecordLine(context, filePath, line) {
 }
 async function discoverWireFiles(rootDir) {
   const jsonlFiles = await discoverFiles(rootDir, { extension: ".jsonl" });
-  return jsonlFiles.filter((filePath) => path23.basename(filePath) === "wire.jsonl");
+  return jsonlFiles.filter((filePath) => path24.basename(filePath) === "wire.jsonl");
 }
 var KimiSourceAdapter = class {
   id = "kimi";
@@ -7334,12 +7617,13 @@ var KimiSourceAdapter = class {
 };
 
 // src/sources/opencode/opencode-source-adapter.ts
-import path25 from "path";
+import path26 from "path";
+import { setTimeout as sleep2 } from "timers/promises";
 
 // src/sources/opencode/opencode-db-path-resolver.ts
 import { readdirSync } from "fs";
 import os16 from "os";
-import path24 from "path";
+import path25 from "path";
 var CHANNEL_DB_FILE_PATTERN = /^opencode-.+\.db$/u;
 function deduplicate2(paths) {
   return [...new Set(paths)];
@@ -7362,30 +7646,30 @@ function listChannelDbFileNames(directory) {
 }
 function getDirectoryCandidates(directory) {
   return [
-    path24.join(directory, "opencode.db"),
-    ...listChannelDbFileNames(directory).map((fileName) => path24.join(directory, fileName)),
-    path24.join(directory, "db.sqlite")
+    path25.join(directory, "opencode.db"),
+    ...listChannelDbFileNames(directory).map((fileName) => path25.join(directory, fileName)),
+    path25.join(directory, "db.sqlite")
   ];
 }
 function getLinuxLikeCandidates2(homeDir, env) {
-  const xdgDataHome = normalizeEnvPath4(env.XDG_DATA_HOME) ?? path24.join(homeDir, ".local", "share");
+  const xdgDataHome = normalizeEnvPath4(env.XDG_DATA_HOME) ?? path25.join(homeDir, ".local", "share");
   return [
-    ...getDirectoryCandidates(path24.join(xdgDataHome, "opencode")),
-    ...getDirectoryCandidates(path24.join(homeDir, ".opencode"))
+    ...getDirectoryCandidates(path25.join(xdgDataHome, "opencode")),
+    ...getDirectoryCandidates(path25.join(homeDir, ".opencode"))
   ];
 }
 function getMacOsCandidates2(homeDir) {
-  const appSupportDir = path24.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path25.join(homeDir, "Library", "Application Support");
   return [
-    ...getDirectoryCandidates(path24.join(appSupportDir, "opencode")),
-    ...getDirectoryCandidates(path24.join(homeDir, ".opencode"))
+    ...getDirectoryCandidates(path25.join(appSupportDir, "opencode")),
+    ...getDirectoryCandidates(path25.join(homeDir, ".opencode"))
   ];
 }
 function getWindowsCandidates2(homeDir, env) {
   const userProfile = normalizeEnvPath4(env.USERPROFILE);
-  const roamingBase = normalizeEnvPath4(env.APPDATA) ?? normalizeEnvPath4(env.LOCALAPPDATA) ?? (userProfile ? path24.join(userProfile, "AppData", "Roaming") : void 0);
-  const roamingCandidates = roamingBase ? getDirectoryCandidates(path24.join(roamingBase, "opencode")) : [];
-  return [...roamingCandidates, ...getDirectoryCandidates(path24.join(homeDir, ".opencode"))];
+  const roamingBase = normalizeEnvPath4(env.APPDATA) ?? normalizeEnvPath4(env.LOCALAPPDATA) ?? (userProfile ? path25.join(userProfile, "AppData", "Roaming") : void 0);
+  const roamingCandidates = roamingBase ? getDirectoryCandidates(path25.join(roamingBase, "opencode")) : [];
+  return [...roamingCandidates, ...getDirectoryCandidates(path25.join(homeDir, ".opencode"))];
 }
 function getDefaultOpenCodeDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
@@ -7724,14 +8008,6 @@ function queryOpenCodeMessageRows(database) {
 // src/sources/opencode/opencode-source-adapter.ts
 var DEFAULT_BUSY_RETRY_COUNT = 2;
 var DEFAULT_BUSY_RETRY_DELAY_MS = 50;
-function isBlankText2(value) {
-  return value.trim().length === 0;
-}
-async function sleep2(delayMs) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, delayMs);
-  });
-}
 function getOpenCodeParseDependencies(dbPath) {
   return [`${dbPath}-wal`, `${dbPath}-journal`];
 }
@@ -7763,7 +8039,7 @@ var OpenCodeSourceAdapter = class {
   }
   async discoverFiles() {
     if (this.explicitDbPath !== void 0) {
-      if (isBlankText2(this.explicitDbPath)) {
+      if (isBlankText(this.explicitDbPath)) {
         throw new Error("--opencode-db must be a non-empty path");
       }
       const explicitDbPath = this.explicitDbPath.trim();
@@ -7780,7 +8056,7 @@ var OpenCodeSourceAdapter = class {
     let selectedDirectory;
     const selectedPaths = [];
     for (const candidatePath of this.resolveDefaultDbPaths()) {
-      const directory = path25.dirname(candidatePath);
+      const directory = path26.dirname(candidatePath);
       if (selectedDirectory !== void 0 && directory !== selectedDirectory) {
         break;
       }
@@ -7798,7 +8074,7 @@ var OpenCodeSourceAdapter = class {
     }
     if (selectedPaths.length > 0) {
       const channelDbPaths = selectedPaths.filter(
-        (candidatePath) => path25.basename(candidatePath) !== "db.sqlite"
+        (candidatePath) => path26.basename(candidatePath) !== "db.sqlite"
       );
       return channelDbPaths.length > 0 ? channelDbPaths : selectedPaths;
     }
@@ -7812,13 +8088,13 @@ var OpenCodeSourceAdapter = class {
     return parseDiagnostics.events;
   }
   async getParseDependencies(dbPath) {
-    if (isBlankText2(dbPath)) {
+    if (isBlankText(dbPath)) {
       return [];
     }
     return getOpenCodeParseDependencies(dbPath.trim());
   }
   async parseFileWithDiagnostics(dbPath) {
-    if (isBlankText2(dbPath)) {
+    if (isBlankText(dbPath)) {
       throw new Error("OpenCode DB path must be a non-empty path");
     }
     const normalizedDbPath = dbPath.trim();
@@ -7850,10 +8126,10 @@ var OpenCodeSourceAdapter = class {
 
 // src/sources/openclaw/openclaw-source-adapter.ts
 import os17 from "os";
-import path27 from "path";
+import path28 from "path";
 
 // src/sources/openclaw/openclaw-session-parser.ts
-import path26 from "path";
+import path27 from "path";
 var SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
 var MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
@@ -7864,7 +8140,7 @@ function shouldParseOpenClawJsonlLine(lineText) {
   return SESSION_LINE_PATTERN.test(lineText) || MESSAGE_LINE_PATTERN.test(lineText) || MODEL_CHANGE_LINE_PATTERN.test(lineText) || USAGE_LINE_PATTERN.test(lineText) || MODEL_LINE_PATTERN.test(lineText) || PROVIDER_LINE_PATTERN.test(lineText);
 }
 function getFallbackSessionId5(filePath) {
-  return path26.basename(filePath, ".jsonl");
+  return path27.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord(record) {
   if (!record) {
@@ -8054,12 +8330,12 @@ async function parseOpenClawSessionFile(sourceId, filePath) {
 }
 
 // src/sources/openclaw/openclaw-source-adapter.ts
-var defaultAgentsDir = path27.join(os17.homedir(), ".openclaw", "agents");
+var defaultAgentsDir = path28.join(os17.homedir(), ".openclaw", "agents");
 var defaultOpenClawRootDirs = [
   defaultAgentsDir,
-  path27.join(os17.homedir(), ".clawdbot", "agents"),
-  path27.join(os17.homedir(), ".moltbot", "agents"),
-  path27.join(os17.homedir(), ".moldbot", "agents")
+  path28.join(os17.homedir(), ".clawdbot", "agents"),
+  path28.join(os17.homedir(), ".moltbot", "agents"),
+  path28.join(os17.homedir(), ".moldbot", "agents")
 ];
 var OpenClawSourceAdapter = class {
   id = "openclaw";
@@ -8095,7 +8371,7 @@ var OpenClawSourceAdapter = class {
 
 // src/sources/pi/pi-source-adapter.ts
 import os18 from "os";
-import path28 from "path";
+import path29 from "path";
 
 // src/utils/read-first-line.ts
 import { open as open2 } from "fs/promises";
@@ -8120,10 +8396,10 @@ async function readFirstLine(filePath, maxBytes = DEFAULT_MAX_FIRST_LINE_BYTES)
 }
 
 // src/sources/pi/pi-source-adapter.ts
-var defaultSessionsDir2 = path28.join(os18.homedir(), ".pi", "agent", "sessions");
+var defaultSessionsDir2 = path29.join(os18.homedir(), ".pi", "agent", "sessions");
 var defaultPiRootDirs = [
   defaultSessionsDir2,
-  path28.join(os18.homedir(), ".omp", "agent", "sessions")
+  path29.join(os18.homedir(), ".omp", "agent", "sessions")
 ];
 var PI_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var PI_SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
@@ -8143,7 +8419,7 @@ function resolveTimestamp6(line, message, state) {
 }
 function resolveParentSessionPath(sessionLine, filePath) {
   const parentSession = asTrimmedText(sessionLine.parentSession);
-  return parentSession ? path28.resolve(path28.dirname(filePath), parentSession) : void 0;
+  return parentSession ? path29.resolve(path29.dirname(filePath), parentSession) : void 0;
 }
 async function readParentSessionPath(filePath) {
   const firstLine = await readFirstLine(filePath);
@@ -8203,7 +8479,7 @@ function extractUsage4(line, message) {
   return extractUsageFromRecord2(messageUsage);
 }
 function getFallbackSessionId6(filePath) {
-  return path28.basename(filePath, ".jsonl");
+  return path29.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord2(record) {
   if (!record) {
@@ -8316,8 +8592,8 @@ var PiSourceAdapter = class {
 
 // src/sources/qwen/qwen-source-adapter.ts
 import os19 from "os";
-import path29 from "path";
-var defaultProjectsDir = path29.join(os19.homedir(), ".qwen", "projects");
+import path30 from "path";
+var defaultProjectsDir = path30.join(os19.homedir(), ".qwen", "projects");
 var QWEN_USAGE_LINE_TEXT = '"usageMetadata"';
 function shouldParseQwenJsonlLine(lineText) {
   return lineText.includes(QWEN_USAGE_LINE_TEXT);
@@ -8365,10 +8641,10 @@ function extractTokenUsage2(usageMetadata, model) {
   };
 }
 function getFallbackSessionId7(filePath) {
-  const chatsDir = path29.dirname(filePath);
-  const projectDir = path29.dirname(chatsDir);
-  const projectName = path29.basename(projectDir);
-  const fileStem = path29.basename(filePath, ".jsonl");
+  const chatsDir = path30.dirname(filePath);
+  const projectDir = path30.dirname(chatsDir);
+  const projectName = path30.basename(projectDir);
+  const fileStem = path30.basename(filePath, ".jsonl");
   return `${projectName}-${fileStem}`;
 }
 var QwenSourceAdapter = class {
@@ -8453,7 +8729,7 @@ var QwenSourceAdapter = class {
 };
 
 // src/sources/multi-directory-source-adapter.ts
-import path30 from "path";
+import path31 from "path";
 var MultiDirectorySourceAdapter = class {
   id;
   parserVersion;
@@ -8480,7 +8756,7 @@ var MultiDirectorySourceAdapter = class {
     const adapterByFile = /* @__PURE__ */ new Map();
     for (const adapter of this.adapters) {
       for (const filePath of await adapter.discoverFiles()) {
-        const resolvedPath = path30.resolve(filePath);
+        const resolvedPath = path31.resolve(filePath);
         if (!discoveredPaths.has(resolvedPath)) {
           discoveredPaths.add(resolvedPath);
           adapterByFile.set(filePath, adapter);
@@ -8510,8 +8786,8 @@ var MultiDirectorySourceAdapter = class {
 };
 
 // src/sources/create-default-adapters.ts
-var dirOptions = ({ path: path38, requireExistingPath }) => ({
-  dir: path38,
+var dirOptions = ({ path: path41, requireExistingPath }) => ({
+  dir: path41,
   requireDir: requireExistingPath
 });
 var sourceRegistrations = [
@@ -8560,7 +8836,7 @@ var sourceRegistrations = [
       flag: "--opencode-db <path>",
       help: "Path to OpenCode SQLite DB"
     },
-    create: ({ path: path38 }) => new OpenCodeSourceAdapter({ dbPath: path38 })
+    create: ({ path: path41 }) => new OpenCodeSourceAdapter({ dbPath: path41 })
   },
   {
     id: "openclaw",
@@ -8602,7 +8878,7 @@ var sourceRegistrations = [
     format: "sqlite",
     supportsSourceDir: false,
     option: { key: "gooseDb", flag: "--goose-db <path>", help: "Path to Goose SQLite DB" },
-    create: ({ path: path38 }) => new GooseSourceAdapter({ dbPath: path38 })
+    create: ({ path: path41 }) => new GooseSourceAdapter({ dbPath: path41 })
   },
   {
     id: "amp",
@@ -8843,6 +9119,16 @@ function normalizeSourceFilter(source) {
   }
   return new Set(normalizedSources);
 }
+function normalizeMachineFilter(machine) {
+  if (!machine || Array.isArray(machine) && machine.length === 0) {
+    return void 0;
+  }
+  const names = (Array.isArray(machine) ? machine : [machine]).flatMap((candidate) => candidate.split(",")).map((candidate) => candidate.trim().toLowerCase()).filter((candidate) => candidate.length > 0);
+  if (names.length === 0) {
+    throw new Error("--machine must contain at least one machine name");
+  }
+  return new Set(names);
+}
 function normalizeModelFilter(model) {
   if (!model || Array.isArray(model) && model.length === 0) {
     return void 0;
@@ -8947,6 +9233,7 @@ function normalizeBuildUsageInputs(options, cliOptions = options) {
     sourceFilter,
     sourceFilterLabel: cliOptions.source === void 0 && options.source !== void 0 ? "config `sources`" : "--source",
     modelFilter,
+    machineFilter: normalizeMachineFilter(options.machine),
     explicitSourceIds,
     pricingUrl: normalizedPricingUrl
   };
@@ -9011,6 +9298,14 @@ function throwOnExplicitSourceScopeConflicts(adapters, selectedAdapters, options
     `Explicitly requested source(s) are incompatible with the requested ${describeExplicitScopeConstraint(options)} scope: ${incompatibleExplicitSources.join(", ")}.`
   );
 }
+function selectAdaptersBySourceFilter(adapters, source) {
+  const sourceFilter = normalizeSourceFilter(source);
+  validateSourceFilterValues(sourceFilter, new Set(getDefaultSourceIds()));
+  if (!sourceFilter) {
+    return adapters;
+  }
+  return adapters.filter((adapter) => sourceFilter.has(adapter.id.toLowerCase()));
+}
 
 // src/cli/build-usage-data-diagnostics.ts
 function buildUsageDiagnostics(params) {
@@ -9093,14 +9388,8 @@ function formatEnvVarOverrides(overrides) {
 import { stat as stat4 } from "fs/promises";
 
 // src/persistence/event-store-history.ts
-function toNonNegativeInteger4(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    return void 0;
-  }
-  return Math.trunc(value);
-}
 function toPositiveCount(value) {
-  return toNonNegativeInteger4(value) ?? 0;
+  return toNonNegativeInteger(value) ?? 0;
 }
 function normalizeHistorySource(source) {
   return normalizeSourceId(source)?.toLowerCase();
@@ -9262,8 +9551,8 @@ function readDepartedFiles(store) {
   for (const row of rows) {
     const source = toText(row.source);
     const filePath = toText(row.file_path);
-    const ingestedAt = toNonNegativeInteger4(row.ingested_at);
-    const eventCount = toNonNegativeInteger4(row.event_count);
+    const ingestedAt = toNonNegativeInteger(row.ingested_at);
+    const eventCount = toNonNegativeInteger(row.event_count);
     const newestTimestamp = toText(row.newest_timestamp);
     if (!source || !filePath || ingestedAt === void 0 || eventCount === void 0) {
       continue;
@@ -9413,6 +9702,7 @@ function loadHistoryEvents(store, input) {
   const suppressedFileCount = departedFiles.length - servedFiles.length;
   return {
     events,
+    servedFiles: servedFiles.map(({ source, filePath }) => ({ source, filePath })),
     departedFileCount: departedFiles.length,
     servedFileCount: servedFiles.length,
     suppressedFileCount,
@@ -9422,15 +9712,12 @@ function loadHistoryEvents(store, input) {
 
 // src/cli/history-live-files.ts
 var MAX_CONCURRENT_STATS = 32;
-function isMissingPathError(error) {
-  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
-}
 async function checkDiskPresence(filePath, statFile) {
   try {
     await statFile(filePath);
     return "present";
   } catch (error) {
-    return isMissingPathError(error) ? "missing" : "unknown";
+    return hasErrorCode(error, "ENOENT", "ENOTDIR") ? "missing" : "unknown";
   }
 }
 async function mapWithConcurrency(inputs, concurrency, mapInput) {
@@ -9564,9 +9851,6 @@ function createParseBudget(maxParallelFileParsing) {
 
 // src/cli/parse/parse-fingerprint.ts
 import { stat as stat5 } from "fs/promises";
-function isMissingPathError2(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
 async function createParseDependencyFingerprint(filePath, options) {
   try {
     const fileStat = await stat5(filePath);
@@ -9577,7 +9861,7 @@ async function createParseDependencyFingerprint(filePath, options) {
       mtimeMs: fileStat.mtimeMs
     };
   } catch (error) {
-    if (options.allowMissing && isMissingPathError2(error)) {
+    if (options.allowMissing && hasErrorCode(error, "ENOENT")) {
       return {
         path: filePath,
         exists: false
@@ -9928,6 +10212,7 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, runWithParseB
       source: adapter.id,
       events: [],
       filePaths: [],
+      parsedFilePaths: [],
       filesFound: 0,
       skippedRows: 0,
       skippedRowReasons: []
@@ -9936,6 +10221,7 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, runWithParseB
   const safeMaxParallelFileParsing = Number.isFinite(maxParallelFileParsing) && maxParallelFileParsing > 0 ? Math.max(1, Math.floor(maxParallelFileParsing)) : 1;
   const parsedByFile = Array.from({ length: files.length }, () => []);
   const skippedRowsByFile = Array.from({ length: files.length }, () => 0);
+  const parsedFileIndexes = /* @__PURE__ */ new Set();
   const skippedRowReasons = /* @__PURE__ */ new Map();
   let pendingStoreWrites = [];
   let pendingStoreEventCount = 0;
@@ -9959,6 +10245,7 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, runWithParseB
       params.diagnostics.skippedRowReasons
     );
     parsedByFile[params.fileIndex] = params.diagnostics.events;
+    parsedFileIndexes.add(params.fileIndex);
     skippedRowsByFile[params.fileIndex] = skippedRows;
     for (const reasonStat of normalizedSkippedRowReasons) {
       skippedRowReasons.set(
@@ -10183,6 +10470,7 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, runWithParseB
     source: adapter.id,
     events: parsedByFile.flat(),
     filePaths: files,
+    parsedFilePaths: files.filter((_, fileIndex) => parsedFileIndexes.has(fileIndex)),
     filesFound: files.length,
     skippedRows: skippedRowsByFile.reduce((sum, skippedRowsCount) => sum + skippedRowsCount, 0),
     skippedRowReasons: [...skippedRowReasons.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right4) => compareByCodePoint(left.reason, right4.reason))
@@ -10254,17 +10542,14 @@ async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, op
   const sourceFailures = [];
   const successfulParseResults = [];
   const discoveredFiles = [];
+  const parsedFiles = [];
   for (const [index, parseResult] of parseResults.entries()) {
     const source = adaptersToParse[index].id;
     if (parseResult.status === "fulfilled") {
-      const { filePaths, ...parseResultWithoutFiles } = parseResult.value;
+      const { filePaths, parsedFilePaths, ...parseResultWithoutFiles } = parseResult.value;
       successfulParseResults.push(parseResultWithoutFiles);
-      discoveredFiles.push(
-        ...filePaths.map((filePath) => ({
-          source,
-          filePath
-        }))
-      );
+      discoveredFiles.push(...filePaths.map((filePath) => ({ source, filePath })));
+      parsedFiles.push(...parsedFilePaths.map((filePath) => ({ source, filePath })));
       continue;
     }
     sourceFailures.push({ source, reason: getErrorReason(parseResult.reason) });
@@ -10272,6 +10557,7 @@ async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, op
   return {
     successfulParseResults,
     discoveredFiles,
+    parsedFiles,
     eventStoreAvailable: Boolean(options.eventStore?.enabled) && !eventStoreFailureState.disabled,
     sourceFailures,
     warnings: eventStoreFailureState.warning ? [eventStoreFailureState.warning] : []
@@ -10362,6 +10648,949 @@ function filterParsedAdapterEvents(parseResults, options) {
   return filterByModelRules(providerAndDateFilteredEvents, options.modelFilter);
 }
 
+// src/machines/machine-cache.ts
+import { rm as rm3 } from "fs/promises";
+import path32 from "path";
+
+// src/machines/machine-export-bundle.ts
+var MACHINE_EXPORT_FORMAT = "llm-usage-metrics.machine-export";
+var MACHINE_EXPORT_VERSION = 1;
+function isNonEmptyText(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function toFileKey(source, filePath) {
+  return JSON.stringify([source, filePath]);
+}
+function parseKnownFiles(text2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch (error) {
+    throw new Error("Known files must be JSON", { cause: error });
+  }
+  const record = asRecord(parsed);
+  if (record?.version !== MACHINE_EXPORT_VERSION || !Array.isArray(record.files)) {
+    throw new Error(
+      `Known files must be {"version":${MACHINE_EXPORT_VERSION},"files":[[source, filePath, revision], ...]}`
+    );
+  }
+  const knownFiles = /* @__PURE__ */ new Map();
+  for (const entry of record.files) {
+    const [source, filePath, revision] = Array.isArray(entry) ? entry : [];
+    if (!Array.isArray(entry) || entry.length !== 3 || !isNonEmptyText(source) || !isNonEmptyText(filePath) || !isNonEmptyText(revision)) {
+      throw new Error("Each known file must be [source, filePath, revision]");
+    }
+    knownFiles.set(toFileKey(source, filePath), revision);
+  }
+  return knownFiles;
+}
+function buildMachineExportLines(header, snapshots, knownFiles = /* @__PURE__ */ new Map()) {
+  const lines = [
+    { type: "header", format: MACHINE_EXPORT_FORMAT, version: MACHINE_EXPORT_VERSION, ...header }
+  ];
+  const files = [];
+  let eventCount = 0;
+  for (const snapshot of snapshots) {
+    if (snapshot.events.length === 0) {
+      continue;
+    }
+    files.push([snapshot.source, snapshot.filePath, snapshot.revision]);
+    eventCount += snapshot.events.length;
+    if (knownFiles.get(toFileKey(snapshot.source, snapshot.filePath)) === snapshot.revision) {
+      continue;
+    }
+    lines.push({
+      type: "file",
+      source: snapshot.source,
+      filePath: snapshot.filePath,
+      revision: snapshot.revision,
+      events: snapshot.events
+    });
+  }
+  lines.push({ type: "end", files, eventCount });
+  return lines;
+}
+function parseBundleLine(line, lineNumber) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (error) {
+    throw new Error(`line ${lineNumber} is not JSON`, { cause: error });
+  }
+  const record = asRecord(parsed);
+  if (!record) {
+    throw new Error(`line ${lineNumber} is not an object`);
+  }
+  return record;
+}
+function readHeader(record) {
+  if (record.type !== "header" || record.format !== MACHINE_EXPORT_FORMAT) {
+    throw new Error("the output is not a machine export (no header line)");
+  }
+  if (record.version !== MACHINE_EXPORT_VERSION) {
+    throw new Error(
+      `it exports bundle version ${String(record.version)}, but this llm-usage-metrics reads version ${MACHINE_EXPORT_VERSION}; install the same version on both machines`
+    );
+  }
+  return {
+    type: "header",
+    format: MACHINE_EXPORT_FORMAT,
+    version: MACHINE_EXPORT_VERSION,
+    cliVersion: typeof record.cliVersion === "string" ? record.cliVersion : "",
+    hostname: typeof record.hostname === "string" ? record.hostname : "",
+    exportedAt: typeof record.exportedAt === "string" ? record.exportedAt : ""
+  };
+}
+function optionalText(record, key) {
+  const value = record[key];
+  if (value !== void 0 && typeof value !== "string") {
+    throw new Error(`${key} is not a string`);
+  }
+  return value;
+}
+function optionalCount(record, key) {
+  const value = record[key];
+  if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < 0)) {
+    throw new Error(`${key} is not a non-negative number`);
+  }
+  return value;
+}
+function toUsageEventInput(value) {
+  const record = asRecord(value);
+  if (!record) {
+    throw new Error("not an object");
+  }
+  const costMode = record.costMode;
+  if (costMode !== "explicit" && costMode !== "estimated") {
+    throw new Error("costMode is not explicit or estimated");
+  }
+  return {
+    source: optionalText(record, "source") ?? "",
+    sessionId: optionalText(record, "sessionId") ?? "",
+    timestamp: optionalText(record, "timestamp") ?? "",
+    repoRoot: optionalText(record, "repoRoot"),
+    provider: optionalText(record, "provider"),
+    model: optionalText(record, "model"),
+    inputTokens: optionalCount(record, "inputTokens"),
+    outputTokens: optionalCount(record, "outputTokens"),
+    reasoningTokens: optionalCount(record, "reasoningTokens"),
+    cacheReadTokens: optionalCount(record, "cacheReadTokens"),
+    cacheWriteTokens: optionalCount(record, "cacheWriteTokens"),
+    totalTokens: optionalCount(record, "totalTokens"),
+    costUsd: optionalCount(record, "costUsd"),
+    costMode
+  };
+}
+function readFileLine(record, lineNumber) {
+  const { source, filePath, revision, events } = record;
+  if (!isNonEmptyText(source) || !isNonEmptyText(filePath) || !isNonEmptyText(revision) || !Array.isArray(events) || events.length === 0) {
+    throw new Error(`line ${lineNumber} is not a valid file line`);
+  }
+  return {
+    type: "file",
+    source,
+    filePath,
+    revision,
+    events: events.map((event, index) => {
+      try {
+        const usageEvent = createUsageEvent(toUsageEventInput(event));
+        if (usageEvent.source !== source) {
+          throw new Error(`its source is ${usageEvent.source}, not ${source}`);
+        }
+        return usageEvent;
+      } catch (error) {
+        throw new Error(
+          `line ${lineNumber} has an invalid event at index ${index}: ${getErrorReason(error)}`,
+          { cause: error }
+        );
+      }
+    })
+  };
+}
+function readEndLine(record, lineNumber) {
+  const { files, eventCount } = record;
+  if (!Array.isArray(files) || typeof eventCount !== "number" || !Number.isSafeInteger(eventCount) || eventCount < 0) {
+    throw new Error(`line ${lineNumber} is not a valid end line`);
+  }
+  const fileKeys = files.map((entry) => {
+    const [source, filePath, revision] = Array.isArray(entry) ? entry : [];
+    if (!Array.isArray(entry) || entry.length !== 3 || !isNonEmptyText(source) || !isNonEmptyText(filePath) || !isNonEmptyText(revision)) {
+      throw new Error(`line ${lineNumber} lists an invalid file`);
+    }
+    return [source, filePath, revision];
+  });
+  return { type: "end", files: fileKeys, eventCount };
+}
+async function readMachineExport(lines) {
+  let header;
+  let end;
+  const sentFiles = [];
+  let lineNumber = 0;
+  for await (const line of lines) {
+    lineNumber += 1;
+    if (line.trim().length === 0) {
+      continue;
+    }
+    if (end) {
+      throw new Error(`line ${lineNumber} follows the end line`);
+    }
+    if (!header) {
+      if (line.includes(`"${MACHINE_EXPORT_FORMAT}"`)) {
+        header = readHeader(parseBundleLine(line, lineNumber));
+      }
+      continue;
+    }
+    const record = parseBundleLine(line, lineNumber);
+    if (record.type === "file") {
+      sentFiles.push(readFileLine(record, lineNumber));
+    } else if (record.type === "end") {
+      end = readEndLine(record, lineNumber);
+    } else {
+      throw new Error(`line ${lineNumber} has an unknown type`);
+    }
+  }
+  if (!header) {
+    throw new Error("the output is not a machine export (no header line)");
+  }
+  if (!end) {
+    throw new Error("the export ended early (no end line)");
+  }
+  const listedRevisions = /* @__PURE__ */ new Map();
+  for (const [source, filePath, revision] of end.files) {
+    const key = toFileKey(source, filePath);
+    if (listedRevisions.has(key)) {
+      throw new Error(`the end line lists ${filePath} twice`);
+    }
+    listedRevisions.set(key, revision);
+  }
+  const sentKeys = /* @__PURE__ */ new Set();
+  for (const file of sentFiles) {
+    const key = toFileKey(file.source, file.filePath);
+    if (sentKeys.has(key) || listedRevisions.get(key) !== file.revision) {
+      throw new Error(`the export sent ${file.filePath} but does not list it at that revision`);
+    }
+    sentKeys.add(key);
+  }
+  return { header, sentFiles, files: end.files, eventCount: end.eventCount };
+}
+
+// src/machines/machine-cache.ts
+var REVISION_PREFIX = "machine-export:";
+function getMachineCacheDirectory() {
+  return path32.join(path32.dirname(getDefaultEventStorePath()), "machines");
+}
+function getMachineCachePath(name) {
+  return path32.join(getMachineCacheDirectory(), `${name}.db`);
+}
+async function openMachineCache(name) {
+  const cache = await openEventStore(getMachineCachePath(name));
+  cache.database.exec("CREATE INDEX IF NOT EXISTS machine_events_timestamp ON events (timestamp)");
+  return cache;
+}
+async function deleteMachineCache(name) {
+  const cachePath = getMachineCachePath(name);
+  for (const filePath of [cachePath, `${cachePath}-wal`, `${cachePath}-shm`]) {
+    await rm3(filePath, { force: true });
+  }
+}
+function toRevisionFingerprint(filePath, revision) {
+  return {
+    parserVersion: `${REVISION_PREFIX}${revision}`,
+    dependencies: [{ path: filePath, exists: false }]
+  };
+}
+function readRevision(fingerprint) {
+  try {
+    const parsed = JSON.parse(fingerprint);
+    const parserVersion = typeof parsed === "object" && parsed !== null && "parserVersion" in parsed ? parsed.parserVersion : void 0;
+    return typeof parserVersion === "string" && parserVersion.startsWith(REVISION_PREFIX) ? parserVersion.slice(REVISION_PREFIX.length) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readCachedFiles(cache) {
+  const files = [];
+  for (const file of listStoredFileFingerprints(cache)) {
+    const revision = readRevision(file.fingerprint);
+    if (revision) {
+      files.push([file.source, file.filePath, revision]);
+    }
+  }
+  return files;
+}
+function countCachedEvents(cache, source, filePath) {
+  const row = cache.database.prepare("SELECT COUNT(*) AS count FROM events WHERE source = ? AND file_path = ?").get(source, filePath);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function applyMachineExport(cache, bundle, now) {
+  return runTransaction(cache.database, () => {
+    const listedKeys = new Set(
+      bundle.files.map(([source, filePath]) => toFileKey(source, filePath))
+    );
+    const staleFiles = readCachedFiles(cache).filter(
+      ([source, filePath]) => !listedKeys.has(toFileKey(source, filePath))
+    );
+    deleteStoredFiles(
+      cache,
+      staleFiles.map(([source, filePath]) => ({ source, filePath }))
+    );
+    replaceFilesEvents(
+      cache,
+      bundle.sentFiles.map((file) => ({
+        source: file.source,
+        filePath: file.filePath,
+        fingerprint: toRevisionFingerprint(file.filePath, file.revision),
+        events: file.events,
+        skippedRows: 0,
+        now
+      }))
+    );
+    const cachedRevisions = new Map(
+      readCachedFiles(cache).map(([source, filePath, revision]) => [
+        toFileKey(source, filePath),
+        revision
+      ])
+    );
+    let eventCount = 0;
+    for (const [source, filePath, revision] of bundle.files) {
+      if (cachedRevisions.get(toFileKey(source, filePath)) !== revision) {
+        throw new Error(`the export skipped ${filePath}, which the cache does not hold`);
+      }
+      eventCount += countCachedEvents(cache, source, filePath);
+    }
+    if (cachedRevisions.size !== bundle.files.length || eventCount !== bundle.eventCount) {
+      throw new Error(
+        `the cache holds ${eventCount} event(s) after the sync, but the export counts ${bundle.eventCount}`
+      );
+    }
+    writeEventStoreMeta(cache, {
+      hostname: bundle.header.hostname || void 0,
+      cliVersion: bundle.header.cliVersion || void 0,
+      syncedAt: String(now),
+      attemptedAt: String(now),
+      lastError: void 0
+    });
+    return {
+      receivedFileCount: bundle.sentFiles.length,
+      removedFileCount: staleFiles.length,
+      fileCount: bundle.files.length,
+      eventCount
+    };
+  });
+}
+function recordMachineSyncFailure(cache, reason, now) {
+  writeEventStoreMeta(cache, { attemptedAt: String(now), lastError: reason });
+}
+function toEpochMs(value) {
+  const parsed = value === void 0 ? Number.NaN : Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function toSyncState(readMeta) {
+  return {
+    hostname: readMeta("hostname"),
+    cliVersion: readMeta("cliVersion"),
+    syncedAt: toEpochMs(readMeta("syncedAt")),
+    attemptedAt: toEpochMs(readMeta("attemptedAt")),
+    lastError: readMeta("lastError")
+  };
+}
+function readMachineSyncState(cache) {
+  return toSyncState((key) => readEventStoreMeta(cache, key));
+}
+async function readMachineCacheUsage(name, window) {
+  const cachePath = getMachineCachePath(name);
+  if (!await pathExists(cachePath)) {
+    return void 0;
+  }
+  const { meta, events } = await readEventStoreEvents(cachePath, window);
+  return { state: toSyncState((key) => meta.get(key)), events };
+}
+async function readMachineCacheStatus(name) {
+  const cachePath = getMachineCachePath(name);
+  if (!await pathExists(cachePath)) {
+    return void 0;
+  }
+  const [meta, summary, storedFiles] = await Promise.all([
+    readEventStoreMetaValues(cachePath),
+    readEventStoreSummary(cachePath),
+    readEventStoreStoredFiles(cachePath)
+  ]);
+  return {
+    state: toSyncState((key) => meta.get(key)),
+    fileCount: storedFiles.length,
+    eventCount: summary.eventCount
+  };
+}
+async function readMachineSyncStateIfCached(name) {
+  const cachePath = getMachineCachePath(name);
+  if (!await pathExists(cachePath)) {
+    return void 0;
+  }
+  const meta = await readEventStoreMetaValues(cachePath);
+  return toSyncState((key) => meta.get(key));
+}
+function isMachineSyncDue(state, now, intervalMs) {
+  const last = Math.max(state?.syncedAt ?? 0, state?.attemptedAt ?? 0);
+  return now - last >= intervalMs;
+}
+function claimMachineSync(cache, now, intervalMs) {
+  return runTransaction(cache.database, () => {
+    if (!isMachineSyncDue(readMachineSyncState(cache), now, intervalMs)) {
+      return false;
+    }
+    writeEventStoreMeta(cache, { attemptedAt: String(now) });
+    return true;
+  });
+}
+
+// src/machines/merge-machine-events.ts
+function countHashes(events) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const hash = computeEventContentHash(event);
+    counts.set(hash, (counts.get(hash) ?? 0) + 1);
+  }
+  return counts;
+}
+function groupBySession(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const key = getEventSessionKey(event);
+    const group = groups.get(key);
+    if (group) {
+      group.push(event);
+    } else {
+      groups.set(key, [event]);
+    }
+  }
+  return groups;
+}
+function mergeMachineEvents(servedEvents, machines) {
+  const servedBySession = groupBySession(servedEvents);
+  const servedHashesBySession = /* @__PURE__ */ new Map();
+  const merged = [];
+  for (const machine of machines) {
+    const kept = [];
+    let duplicateCount = 0;
+    for (const [sessionKey, events] of groupBySession(machine.events)) {
+      const served = servedBySession.get(sessionKey);
+      if (!served) {
+        servedBySession.set(sessionKey, [...events]);
+        kept.push(...events);
+        continue;
+      }
+      let servedHashes = servedHashesBySession.get(sessionKey);
+      if (!servedHashes) {
+        servedHashes = countHashes(served);
+        servedHashesBySession.set(sessionKey, servedHashes);
+      }
+      const available = new Map(servedHashes);
+      for (const event of events) {
+        const hash = computeEventContentHash(event);
+        const count = available.get(hash) ?? 0;
+        if (count > 0) {
+          available.set(hash, count - 1);
+          duplicateCount += 1;
+          continue;
+        }
+        kept.push(event);
+        served.push(event);
+        servedHashes.set(hash, (servedHashes.get(hash) ?? 0) + 1);
+      }
+    }
+    merged.push({ name: machine.name, events: kept, duplicateCount });
+  }
+  return merged;
+}
+
+// src/machines/load-machine-usage.ts
+function selectMachines(machines, machineFilter, options) {
+  const configured = Object.keys(machines ?? {}).sort();
+  if (!machineFilter) {
+    return { includeLocal: true, names: options.customSourceDirectories ? [] : configured };
+  }
+  const known = /* @__PURE__ */ new Set([LOCAL_MACHINE_NAME, ...configured]);
+  const unknown = [...machineFilter].filter((name) => !known.has(name));
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown machine(s) for --machine: ${unknown.join(", ")} (known: ${[...known].join(", ")})`
+    );
+  }
+  return {
+    includeLocal: machineFilter.has(LOCAL_MACHINE_NAME),
+    names: configured.filter((name) => machineFilter.has(name))
+  };
+}
+function toTimestampBound(date, offsetDays) {
+  if (date === void 0) {
+    return void 0;
+  }
+  const bound = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+  bound.setUTCDate(bound.getUTCDate() + offsetDays);
+  return bound.toISOString();
+}
+async function loadMachineUsage(params) {
+  const window = {
+    fromTimestamp: toTimestampBound(params.since, -1),
+    toTimestamp: toTimestampBound(params.until, 2)
+  };
+  const warnings = [];
+  const caches = await Promise.all(
+    params.names.map(async (name) => {
+      try {
+        return { name, usage: await readMachineCacheUsage(name, window) };
+      } catch (error) {
+        warnings.push(
+          `Left out machine ${name}: its cache cannot be read (${getErrorReason(error)})`
+        );
+        return void 0;
+      }
+    })
+  );
+  const readable = caches.filter((cache) => cache !== void 0);
+  const merged = mergeMachineEvents(
+    params.servedEvents,
+    readable.map(({ name, usage }) => ({
+      name,
+      events: (usage?.events ?? []).filter((event) => params.sources.has(event.source))
+    }))
+  );
+  return {
+    events: merged.flatMap(
+      (machine) => machine.events.map((event) => ({ ...event, machine: machine.name }))
+    ),
+    machines: readable.map(({ name, usage }, index) => ({
+      name,
+      enabled: !params.disabledNames?.has(name),
+      state: usage?.state,
+      duplicateCount: merged[index].duplicateCount
+    })),
+    warnings
+  };
+}
+
+// src/machines/machine-ssh.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { stripVTControlCharacters } from "util";
+var DEFAULT_MACHINE_COMMAND = "llm-usage";
+var MACHINE_EXPORT_TIMEOUT_MARK = "timed out";
+var STDERR_TAIL_BYTES = 4096;
+var spawnSystemSsh = (args) => spawn("ssh", args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+function buildSshArgs(target, remoteCommand) {
+  return [
+    "-T",
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "ConnectTimeout=10",
+    "-o",
+    "ServerAliveInterval=15",
+    "-o",
+    "ServerAliveCountMax=3",
+    "-o",
+    "Compression=yes",
+    "--",
+    target,
+    remoteCommand
+  ];
+}
+function buildSshExportArgs(machine) {
+  return buildSshArgs(
+    machine.ssh,
+    `${machine.command ?? DEFAULT_MACHINE_COMMAND} machine export --known - --quiet`
+  );
+}
+var LOGIN_SHELL_MARKER = "llm-usage-metrics: asking the login shell";
+var PROBE_OUTPUT_BYTES = 64 * 1024;
+var PROBE_TIMEOUT_MS = 2e4;
+var SAFE_PATH_PATTERN = /^\/[\w./+@-]*$/u;
+function ignoreStreamErrors(child) {
+  child.stdin.on("error", () => void 0);
+  child.stdout.on("error", () => void 0);
+  child.stderr.on("error", () => void 0);
+}
+function readProbeValue(lines, key) {
+  const value = lines.filter((line) => line.startsWith(`${key}=`)).at(-1)?.slice(key.length + 1);
+  return value !== void 0 && SAFE_PATH_PATTERN.test(value) ? value : void 0;
+}
+async function detectRemoteCommand(target, options = {}) {
+  const probe = [
+    `command -v ${DEFAULT_MACHINE_COMMAND} && exit 0`,
+    `echo '${LOGIN_SHELL_MARKER}'`,
+    `"$SHELL" -lic 'echo "command=$(command -v ${DEFAULT_MACHINE_COMMAND})"; echo "node=$(node -p process.execPath)"'`
+  ].join("; ");
+  const child = (options.spawnSsh ?? spawnSystemSsh)(buildSshArgs(target, probe));
+  const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;
+  const timeout = { expired: false };
+  let output = "";
+  const timer = setTimeout(() => {
+    timeout.expired = true;
+    child.kill();
+  }, timeoutMs);
+  ignoreStreamErrors(child);
+  child.stdin.end();
+  child.stdout.on("data", (chunk) => {
+    output = (output + chunk.toString("utf8")).slice(-PROBE_OUTPUT_BYTES);
+  });
+  child.stderr.resume();
+  try {
+    await new Promise((resolve) => {
+      child.once("error", () => {
+        resolve();
+      });
+      child.once("close", () => {
+        resolve();
+      });
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (timeout.expired) {
+    logger.info(
+      `Looking up llm-usage in ${target}'s login shell took over ${Math.round(timeoutMs / 1e3)}s (a startup file may wait for input); trying the default command`
+    );
+    return void 0;
+  }
+  const lines = output.split(/\r?\n/u).map((line) => line.trim());
+  const markerIndex = lines.indexOf(LOGIN_SHELL_MARKER);
+  const afterMarker = lines.slice(markerIndex + 1);
+  const command = readProbeValue(afterMarker, "command");
+  if (markerIndex === -1 || !command?.endsWith(`/${DEFAULT_MACHINE_COMMAND}`)) {
+    return void 0;
+  }
+  const node = readProbeValue(afterMarker, "node");
+  const directories = [command, node].filter((filePath) => filePath !== void 0).map((filePath) => filePath.slice(0, filePath.lastIndexOf("/")));
+  return `env PATH=${[...new Set(directories)].join(":")}:"$PATH" ${DEFAULT_MACHINE_COMMAND}`;
+}
+function readStderrTail(chunks) {
+  const text2 = Buffer.concat(chunks).toString("utf8").slice(-STDERR_TAIL_BYTES);
+  return stripControlCharacters(stripVTControlCharacters(text2).replaceAll(/\s+/gu, " ")).trim();
+}
+function describeExportFailure(machine, exitCode, stderr) {
+  const command = machine.command ?? DEFAULT_MACHINE_COMMAND;
+  const detail = (stderr || `exit code ${String(exitCode)}`).replace(/\.$/u, "");
+  if (exitCode === null) {
+    return `ssh was stopped by a signal: ${detail}`;
+  }
+  if (exitCode === 255) {
+    if (/permission denied|too many authentication failures/iu.test(stderr)) {
+      return `ssh could not log in without a prompt: ${detail}. Set up key login (ssh-copy-id ${machine.ssh}) or load your key into ssh-agent.`;
+    }
+    if (/host key verification failed/iu.test(stderr)) {
+      return `ssh does not know this host yet: ${detail}. Connect once with \`ssh ${machine.ssh}\` to check and accept its host key.`;
+    }
+    return `ssh failed: ${detail}`;
+  }
+  if (exitCode === 127 || /command not found|not recognized as an internal/iu.test(stderr)) {
+    return `${command} was not found on ${machine.ssh}: ${detail}. Install llm-usage-metrics there, or give the command that starts it (machine add --command, or command in config.toml).`;
+  }
+  if (/unknown command 'machine'|unknown command 'export'/iu.test(stderr)) {
+    return `${command} on ${machine.ssh} is too old to export usage: ${detail}. Update llm-usage-metrics there.`;
+  }
+  return `machine export failed: ${detail}`;
+}
+async function fetchMachineExport(machine, knownFiles, options = {}) {
+  if (options.signal?.aborted) {
+    throw new Error("stopped: the report it was for ended");
+  }
+  const child = (options.spawnSsh ?? spawnSystemSsh)(buildSshExportArgs(machine));
+  const stopOnAbort = () => {
+    child.kill();
+  };
+  options.signal?.addEventListener("abort", stopOnAbort, { once: true });
+  const stderrChunks = [];
+  const closed = new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", resolve);
+  });
+  const timeout = { expired: false };
+  const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    timeout.expired = true;
+    child.kill();
+  }, options.timeoutMs);
+  let stderrBytes = 0;
+  ignoreStreamErrors(child);
+  child.stderr.on("data", (chunk) => {
+    stderrChunks.push(chunk);
+    stderrBytes += chunk.length;
+    while (stderrBytes > STDERR_TAIL_BYTES * 4 && stderrChunks.length > 1) {
+      stderrBytes -= stderrChunks.shift()?.length ?? 0;
+    }
+  });
+  child.stdin.end(JSON.stringify({ version: MACHINE_EXPORT_VERSION, files: knownFiles }));
+  let bundle;
+  let readError;
+  let stoppedByUs = false;
+  child.stdout.on("error", (error) => {
+    readError ??= error;
+  });
+  try {
+    bundle = await readMachineExport(createInterface({ input: child.stdout, crlfDelay: Infinity }));
+  } catch (error) {
+    readError = error;
+    if (!child.stdout.readableEnded) {
+      stoppedByUs = true;
+      child.kill();
+    }
+  }
+  let exitCode;
+  try {
+    exitCode = await closed;
+  } catch (error) {
+    throw new Error(`could not run ssh: ${getErrorReason(error)}`, { cause: error });
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", stopOnAbort);
+  }
+  if (options.signal?.aborted) {
+    throw new Error("stopped: the report it was for ended");
+  }
+  if (timeout.expired) {
+    throw new Error(
+      `no complete export within ${Math.round((options.timeoutMs ?? 0) / 1e3)}s (${MACHINE_EXPORT_TIMEOUT_MARK})`
+    );
+  }
+  if (exitCode !== 0 && !stoppedByUs) {
+    throw new Error(describeExportFailure(machine, exitCode, readStderrTail(stderrChunks)));
+  }
+  if (!bundle) {
+    throw new Error(`the export from ${machine.ssh} is invalid: ${getErrorReason(readError)}`, {
+      cause: readError
+    });
+  }
+  const remoteWarnings = Buffer.concat(stderrChunks).toString("utf8").slice(-STDERR_TAIL_BYTES).split("\n").map((line) => stripControlCharacters(stripVTControlCharacters(line)).trim()).filter((line) => line.length > 0);
+  return { bundle, remoteWarnings };
+}
+
+// src/render/render-machines.ts
+var integerFormat = new Intl.NumberFormat("en-US");
+function formatAge(ageMs) {
+  const minutes = Math.floor(Math.max(0, ageMs) / 6e4);
+  if (minutes < 1) {
+    return "just now";
+  }
+  if (minutes < 60) {
+    return `${minutes} min ago`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) {
+    return `${hours} h ago`;
+  }
+  return `${Math.floor(hours / 24)} days ago`;
+}
+function formatCachedTotals(fileCount, eventCount) {
+  return `${integerFormat.format(fileCount)} file(s), ${integerFormat.format(eventCount)} event(s)`;
+}
+function formatRemoteVersion(state) {
+  if (!state.cliVersion) {
+    return "";
+  }
+  return state.hostname ? ` from ${state.hostname} (llm-usage-metrics ${state.cliVersion})` : ` (llm-usage-metrics ${state.cliVersion})`;
+}
+function renderSyncOutcome(outcome, now) {
+  if (outcome.ok) {
+    const { result } = outcome;
+    const changes = result.receivedFileCount === 0 && result.removedFileCount === 0 ? "up to date" : `${integerFormat.format(result.receivedFileCount)} file(s) updated, ${integerFormat.format(result.removedFileCount)} removed`;
+    return [
+      `\u2713 ${outcome.name}: ${changes}; ${formatCachedTotals(result.fileCount, result.eventCount)} cached${formatRemoteVersion(outcome.state)}`,
+      ...outcome.remoteWarnings.map((warning) => `  ${outcome.name} warned: ${warning}`)
+    ];
+  }
+  const cacheNote = outcome.state.syncedAt === void 0 ? "nothing cached yet" : `reports keep its usage from ${formatAge(now - outcome.state.syncedAt)}`;
+  return [`\u2717 ${outcome.name}: ${outcome.error} (${cacheNote})`];
+}
+function describeMachineStatus(entry, now) {
+  const { state } = entry;
+  if (entry.machine.enabled === false) {
+    return "disabled (cached usage stays in reports)";
+  }
+  if (state?.syncedAt === void 0) {
+    return state?.lastError ? `never synced: ${state.lastError}` : "never synced";
+  }
+  const synced = `synced ${formatAge(now - state.syncedAt)}, ${formatCachedTotals(entry.fileCount, entry.eventCount)}`;
+  if (state.lastError && (state.attemptedAt ?? 0) >= state.syncedAt) {
+    return `${synced}; last attempt failed ${formatAge(now - (state.attemptedAt ?? 0))}: ${state.lastError}`;
+  }
+  return synced;
+}
+function renderMachineList(entries, now) {
+  if (entries.length === 0) {
+    return ["No machines configured.", "Add one with: llm-usage machine add <name> [user@host]"];
+  }
+  const nameWidth = Math.max(...entries.map((entry) => entry.name.length));
+  const sshWidth = Math.max(...entries.map((entry) => entry.machine.ssh.length));
+  return entries.map(
+    (entry) => `${entry.name.padEnd(nameWidth)}  ${entry.machine.ssh.padEnd(sshWidth)}  ${describeMachineStatus(entry, now)}`
+  );
+}
+function describeIncludedMachine(machine, now, localVersion) {
+  const { state } = machine;
+  if (!machine.enabled) {
+    return state?.syncedAt === void 0 ? `${machine.name} (disabled, nothing cached)` : `${machine.name} (disabled, usage from ${formatAge(now - state.syncedAt)})`;
+  }
+  if (state?.syncedAt === void 0) {
+    return `${machine.name} (never synced; run llm-usage sync ${machine.name})`;
+  }
+  const details = [`synced ${formatAge(now - state.syncedAt)}`];
+  if (state.lastError !== void 0 && (state.attemptedAt ?? 0) >= state.syncedAt) {
+    details.push("last sync failed");
+  }
+  if (state.cliVersion && state.cliVersion !== localVersion) {
+    details.push(
+      `llm-usage-metrics ${state.cliVersion} there; shared sessions may count twice until both run the same version`
+    );
+  }
+  return `${machine.name} (${details.join(", ")})`;
+}
+function formatMachinesNote(machines, now, localVersion) {
+  const duplicateCount = machines.reduce((sum, machine) => sum + machine.duplicateCount, 0);
+  const duplicates = duplicateCount > 0 ? `; left out ${integerFormat.format(duplicateCount)} event(s) already counted` : "";
+  return `Machines: ${machines.map((machine) => describeIncludedMachine(machine, now, localVersion)).join(", ")}${duplicates}.`;
+}
+var STALE_CACHE_MS = 24 * 60 * 6e4;
+function formatRefreshFailure(outcome, now) {
+  if (outcome.ok) {
+    return void 0;
+  }
+  const { syncedAt } = outcome.state;
+  if (syncedAt === void 0) {
+    return {
+      text: `Could not sync ${outcome.name} (${outcome.error}); it has no usage cached yet.`,
+      stale: true
+    };
+  }
+  const hint = outcome.error.endsWith(`(${MACHINE_EXPORT_TIMEOUT_MARK})`) ? ` Run llm-usage sync ${outcome.name} to wait for it.` : "";
+  return {
+    text: `Could not sync ${outcome.name} (${outcome.error}); using its usage from ${formatAge(now - syncedAt)}.${hint}`,
+    stale: now - syncedAt >= STALE_CACHE_MS
+  };
+}
+
+// src/machines/sync-machine.ts
+async function syncMachine(name, machine, options = {}) {
+  const now = options.now ?? Date.now;
+  let cache;
+  try {
+    cache = await openMachineCache(name);
+  } catch (error) {
+    return {
+      name,
+      ok: false,
+      error: `cannot open its cache at ${getMachineCachePath(name)}: ${getErrorReason(error)}`,
+      state: {}
+    };
+  }
+  try {
+    if (options.recordAttemptFirst === true) {
+      try {
+        writeEventStoreMeta(cache, { attemptedAt: String(now()) });
+      } catch {
+      }
+    }
+    const { bundle, remoteWarnings } = await fetchMachineExport(
+      machine,
+      options.full === true ? [] : readCachedFiles(cache),
+      { spawnSsh: options.spawnSsh, timeoutMs: options.timeoutMs, signal: options.signal }
+    );
+    const result = applyMachineExport(cache, bundle, now());
+    return { name, ok: true, result, remoteWarnings, state: readMachineSyncState(cache) };
+  } catch (error) {
+    const reason = getErrorReason(error);
+    let state = {};
+    try {
+      if (!options.signal?.aborted) {
+        recordMachineSyncFailure(cache, reason, now());
+      }
+      state = readMachineSyncState(cache);
+    } catch {
+    }
+    return { name, ok: false, error: reason, state };
+  } finally {
+    closeEventStore(cache);
+  }
+}
+
+// src/machines/refresh-machines.ts
+var MACHINE_REFRESH_INTERVAL_MS = 10 * 6e4;
+var MACHINE_REFRESH_TIMEOUT_MS = 3e4;
+async function claimDueSync(name, now) {
+  try {
+    if (!isMachineSyncDue(await readMachineSyncStateIfCached(name), now, MACHINE_REFRESH_INTERVAL_MS)) {
+      return false;
+    }
+  } catch {
+  }
+  try {
+    const cache = await openMachineCache(name);
+    try {
+      return claimMachineSync(cache, now, MACHINE_REFRESH_INTERVAL_MS);
+    } finally {
+      closeEventStore(cache);
+    }
+  } catch {
+    return false;
+  }
+}
+async function refreshDueMachines(machines, options = {}) {
+  const now = options.now ?? Date.now;
+  const outcomes = await Promise.all(
+    machines.filter(({ machine }) => machine.enabled !== false).map(async ({ name, machine }) => {
+      if (!await claimDueSync(name, now())) {
+        return void 0;
+      }
+      return syncMachine(name, machine, {
+        spawnSsh: options.spawnSsh,
+        now,
+        timeoutMs: options.timeoutMs ?? MACHINE_REFRESH_TIMEOUT_MS,
+        signal: options.signal
+      });
+    })
+  );
+  return outcomes.filter((outcome) => outcome !== void 0);
+}
+
+// src/cli/package-metadata.ts
+import { createRequire as createRequire2 } from "module";
+var DEFAULT_PACKAGE_NAME = "llm-usage-metrics";
+var DEFAULT_PACKAGE_VERSION = "0.0.0";
+var defaultPackageJsonCandidates = ["../package.json", "../../package.json"];
+function normalizeMetadata(candidate) {
+  const packageJson = asRecord(candidate);
+  if (!packageJson) {
+    return void 0;
+  }
+  const packageName = typeof packageJson.name === "string" ? packageJson.name.trim() : void 0;
+  const packageVersion = typeof packageJson.version === "string" ? packageJson.version.trim() : void 0;
+  if (!packageName || !packageVersion) {
+    return void 0;
+  }
+  return {
+    packageName,
+    packageVersion
+  };
+}
+function resolvePackageMetadata(loadJson, packageJsonCandidates = defaultPackageJsonCandidates) {
+  for (const candidatePath of packageJsonCandidates) {
+    try {
+      const metadata = normalizeMetadata(loadJson(candidatePath));
+      if (metadata) {
+        return metadata;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return {
+    packageName: DEFAULT_PACKAGE_NAME,
+    packageVersion: DEFAULT_PACKAGE_VERSION
+  };
+}
+function loadPackageMetadataFromRuntime() {
+  const require3 = createRequire2(import.meta.url);
+  return resolvePackageMetadata((candidatePath) => require3(candidatePath));
+}
+
 // src/pricing/cost-engine.ts
 var ONE_MILLION = 1e6;
 function estimateTokenGroupCost(tokens, per1MUsd) {
@@ -10472,7 +11701,6 @@ function applyPricingToEvents(events, pricingSource) {
 }
 
 // src/pricing/pricing-override-source.ts
-import { readFile as readFile7 } from "fs/promises";
 var requiredRateKeys = ["inputPer1MUsd", "outputPer1MUsd"];
 var optionalRateKeys = ["cacheReadPer1MUsd", "cacheWritePer1MUsd", "reasoningPer1MUsd"];
 var knownOverrideKeys = /* @__PURE__ */ new Set([
@@ -10572,7 +11800,7 @@ function normalizeOverrideFile(payload) {
   return overrides;
 }
 async function loadPricingOverrides(filePath) {
-  const fileContents = await readFile7(filePath, "utf8");
+  const fileContents = await readRegularTextFile(filePath);
   const parsed = JSON.parse(fileContents);
   return normalizeOverrideFile(parsed);
 }
@@ -10599,8 +11827,8 @@ var PricingOverrideSource = class {
 };
 
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile8 } from "fs/promises";
-import path31 from "path";
+import path33 from "path";
+import { setTimeout as sleep3 } from "timers/promises";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -29366,11 +30594,6 @@ function isRetryableFetchFailure2(error) {
   }
   return /timeout|timed out|network|econn|enotfound|eai_again/iu.test(error.message);
 }
-async function sleep3(delayMs) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, delayMs);
-  });
-}
 var bundledLiteLLMPricingSnapshot;
 function toNonNegativeNumber3(value) {
   if (typeof value === "number") {
@@ -29531,7 +30754,7 @@ function formatStaleCacheWarning(fetchedAt, fetchError) {
   return `Pricing: the LiteLLM refresh failed (${fetchError}); using cached pricing from ${fetchedDate}.`;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path31.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path33.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 var LiteLLMPricingFetcher = class {
   sourceUrl;
@@ -29664,11 +30887,11 @@ var LiteLLMPricingFetcher = class {
       );
     }
     if (!response.body) {
-      const text = await response.text();
-      if (Buffer.byteLength(text, "utf8") > this.maxResponseBytes) {
+      const text2 = await response.text();
+      if (Buffer.byteLength(text2, "utf8") > this.maxResponseBytes) {
         throw new Error(`LiteLLM pricing response exceeds ${this.maxResponseBytes} bytes`);
       }
-      return JSON.parse(text);
+      return JSON.parse(text2);
     }
     const chunks = [];
     let receivedBytes = 0;
@@ -29759,7 +30982,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile8(this.cacheFilePath, "utf8");
+      content = await readRegularTextFile(this.cacheFilePath);
     } catch {
       return void 0;
     }
@@ -29772,8 +30995,8 @@ var LiteLLMPricingFetcher = class {
     return normalizeLiteLLMCachePayload(parsedPayload);
   }
   async writeCache() {
-    const directoryPath = path31.dirname(this.cacheFilePath);
-    await mkdir3(directoryPath, { recursive: true });
+    const directoryPath = path33.dirname(this.cacheFilePath);
+    await ensureDirectory(directoryPath);
     const payload = {
       fetchedAt: this.now(),
       sourceUrl: this.sourceUrl,
@@ -30199,6 +31422,26 @@ function appendHistoryEvents(parseResults, historyEvents) {
     };
   });
 }
+function appendMachineEvents(parseResults, machineEvents) {
+  const results = parseResults.map((result) => ({ ...result, events: [...result.events] }));
+  const resultsBySource = new Map(results.map((result) => [result.source, result]));
+  for (const event of machineEvents) {
+    let result = resultsBySource.get(event.source);
+    if (!result) {
+      result = {
+        source: event.source,
+        events: [],
+        filesFound: 0,
+        skippedRows: 0,
+        skippedRowReasons: []
+      };
+      resultsBySource.set(event.source, result);
+      results.push(result);
+    }
+    result.events.push(event);
+  }
+  return results;
+}
 async function buildUsageEventDataset(options, deps = {}) {
   const userConfigResolution = await resolveUserConfigForOptions(options, deps);
   const configuredOptions = userConfigResolution.options;
@@ -30221,7 +31464,9 @@ async function buildUsageEventDataset(options, deps = {}) {
   ]);
   const historyRequested = configuredOptions.history === true;
   const cliDirectorySourceIds = resolveCliDirectorySourceIds(userConfigResolution.cliOptions);
-  const includeHistory = configuredOptions.history !== false;
+  const machineSelection = selectMachines(config.machines, normalizedInputs.machineFilter, {
+    customSourceDirectories: cliDirectorySourceIds.size > 0
+  });
   if (historyRequested && !eventStoreRuntimeConfig.enabled) {
     throw new Error(
       eventStoreRuntimeConfig.disabledBy === "environment" ? "--history requires the event store (unset LLM_USAGE_EVENT_STORE=0)" : "--history requires the event store (set eventStore.enabled = true in config.toml)"
@@ -30248,6 +31493,13 @@ async function buildUsageEventDataset(options, deps = {}) {
     providerFilter: normalizedInputs.providerFilter,
     modelFilter: normalizedInputs.modelFilter
   });
+  const nowMs = () => (deps.now?.() ?? /* @__PURE__ */ new Date()).getTime();
+  const machineRefreshAbort = new AbortController();
+  const machineRefresh = configuredOptions.sync === false ? Promise.resolve([]) : refreshDueMachines(
+    Object.entries(config.machines ?? {}).filter(([name]) => machineSelection.names.includes(name)).map(([name, machine]) => ({ name, machine })),
+    { now: nowMs, spawnSsh: deps.spawnSsh, signal: machineRefreshAbort.signal }
+  );
+  const includeHistory = configuredOptions.history !== false;
   let openedEventStore;
   let dataset;
   try {
@@ -30255,6 +31507,7 @@ async function buildUsageEventDataset(options, deps = {}) {
     const {
       successfulParseResults,
       discoveredFiles,
+      parsedFiles,
       eventStoreAvailable,
       sourceFailures,
       warnings
@@ -30297,6 +31550,7 @@ async function buildUsageEventDataset(options, deps = {}) {
     const parseWarnings = eventStoreOpenWarning ? [eventStoreOpenWarning, ...warnings] : warnings;
     throwOnExplicitSourceFailures(sourceFailures, normalizedInputs.explicitSourceIds);
     let parseResultsForFiltering = successfulParseResults;
+    const ledger = eventStoreAvailable ? { path: eventStoreRuntimeConfig.path, countedFiles: [...parsedFiles] } : void 0;
     const historyWarnings = [];
     const historyNotes = [];
     const historyStore = openedEventStore;
@@ -30325,6 +31579,7 @@ async function buildUsageEventDataset(options, deps = {}) {
           parseResultsForFiltering,
           historyResult.events
         );
+        ledger?.countedFiles.push(...historyResult.servedFiles);
         if (historyRequested || historyResult.servedFileCount > 0) {
           historyNotes.push(formatHistoryNote(historyResult));
         }
@@ -30332,6 +31587,56 @@ async function buildUsageEventDataset(options, deps = {}) {
         historyWarnings.push(`Event store disabled after failure: ${getErrorReason(error)}`);
       }
     }
+    const machineWarnings = [];
+    const machineNotes = [];
+    if (!machineSelection.includeLocal) {
+      parseResultsForFiltering = parseResultsForFiltering.map((result) => ({
+        ...result,
+        events: []
+      }));
+    }
+    const refreshOutcomes = await measureRuntimeProfileStage(
+      runtimeProfile,
+      "usage.dataset.machine_refresh",
+      () => machineRefresh
+    );
+    for (const outcome of refreshOutcomes) {
+      if (outcome.ok) {
+        machineWarnings.push(
+          ...outcome.remoteWarnings.map((warning) => `${outcome.name} warned: ${warning}`)
+        );
+        continue;
+      }
+      const failure = formatRefreshFailure(outcome, nowMs());
+      if (failure) {
+        (failure.stale ? machineWarnings : machineNotes).push(failure.text);
+      }
+    }
+    if (machineSelection.names.length > 0) {
+      const machineUsage = await measureRuntimeProfileStage(
+        runtimeProfile,
+        "usage.dataset.machines",
+        () => loadMachineUsage({
+          names: machineSelection.names,
+          disabledNames: new Set(
+            machineSelection.names.filter((name) => config.machines?.[name]?.enabled === false)
+          ),
+          servedEvents: parseResultsForFiltering.flatMap((result) => result.events),
+          sources: new Set(adaptersToParse.map((adapter) => adapter.id)),
+          since: configuredOptions.since,
+          until: configuredOptions.until
+        })
+      );
+      parseResultsForFiltering = appendMachineEvents(parseResultsForFiltering, machineUsage.events);
+      machineWarnings.push(...machineUsage.warnings);
+      machineNotes.push(
+        formatMachinesNote(
+          machineUsage.machines,
+          nowMs(),
+          loadPackageMetadataFromRuntime().packageVersion
+        )
+      );
+    }
     const filteredEvents = measureRuntimeProfileStageSync(
       runtimeProfile,
       "usage.dataset.filter_events",
@@ -30354,6 +31659,7 @@ async function buildUsageEventDataset(options, deps = {}) {
         ...userConfigResolution.loadedConfig.warnings,
         ...parseWarnings,
         ...historyWarnings,
+        ...machineWarnings,
         ...findUnmatchedFilterWarnings({
           parseResults: parseResultsForFiltering,
           // A `sources` list from config.toml is a standing default, not a typed filter.
@@ -30367,13 +31673,15 @@ async function buildUsageEventDataset(options, deps = {}) {
           until: configuredOptions.until
         })
       ],
-      notes: historyNotes,
+      notes: [...historyNotes, ...machineNotes],
       filteredEvents,
+      ledger,
       pricingRuntimeConfig,
       readEnvVarOverrides: deps.getActiveEnvVarOverrides ?? getActiveEnvVarOverrides
     };
     return dataset;
   } finally {
+    machineRefreshAbort.abort();
     if (openedEventStore) {
       try {
         const closeStore = deps.closeEventStore ?? closeEventStore;
@@ -30465,7 +31773,8 @@ async function buildUsageData(granularity, commandOptions, commandDeps = {}) {
     () => aggregateUsage(pricedEvents, {
       granularity,
       timezone: dataset.normalizedInputs.timezone,
-      sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id)
+      sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id),
+      byMachine: options.byMachine === true
     })
   );
   const diagnostics = buildUsageDiagnostics({
@@ -30767,7 +32076,7 @@ var defaultTerminalStylePalette = {
   bold: pc3.bold,
   dim: pc3.dim
 };
-var passthroughStyler = (text) => text;
+var passthroughStyler = (text2) => text2;
 var periodColumnIndex = 0;
 var sourceColumnIndex = 1;
 var modelsColumnIndex = 2;
@@ -30780,7 +32089,7 @@ function styleModelsCell(cell, palette, options = {}) {
   const emphasizePrimaryWhenSingleLine = options.emphasizePrimaryWhenSingleLine ?? false;
   const primaryStyler = options.primaryStyler ?? palette.bold;
   const secondaryStyler = options.secondaryStyler ?? passthroughStyler;
-  const totalStyler = options.totalStyler ?? ((text) => palette.bold(palette.green(text)));
+  const totalStyler = options.totalStyler ?? ((text2) => palette.bold(palette.green(text2)));
   const lines = splitCellLines(cell);
   const modelEntryCount = lines.reduce((count, line) => {
     if (line === "\u03A3 TOTAL") {
@@ -31010,7 +32319,7 @@ function formatSource(row) {
   if (row.rowType === "grand_total") {
     return "TOTAL";
   }
-  return row.source;
+  return row.rowType === "period_source" && row.machine !== void 0 ? `${row.source} (${row.machine})` : row.source;
 }
 function formatFullTokenCount(value) {
   return integerFormatter.format(value ?? 0);
@@ -31810,6 +33119,22 @@ function renderCompareReport(compareData, format, options = {}) {
   }
 }
 
+// src/render/month-labels.ts
+var MONTH_LABELS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+
 // src/render/share-svg-theme.ts
 var shareThemes = {
   dark: {
@@ -31959,20 +33284,6 @@ function renderEmptyState(theme, message) {
     attributes: 'data-empty-state="true"'
   });
 }
-var MONTH_LABELS = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec"
-];
 var WEEKDAY_LABELS = [
   { row: 0, label: "Mon" },
   { row: 2, label: "Wed" },
@@ -32074,6 +33385,26 @@ function scaleY(value, max, top, bottom) {
   if (max <= 0) return bottom;
   return bottom - Math.max(0, value) / max * (bottom - top);
 }
+function renderValueGridLines(scaleMax, chart, formatValue, theme) {
+  const lines = [];
+  for (let step = 1; step <= 3; step += 1) {
+    const value = scaleMax / 3 * step;
+    const y = scaleY(value, scaleMax, chart.top, chart.bottom);
+    lines.push(
+      `<line x1="${chart.left}" y1="${y.toFixed(2)}" x2="${chart.right}" y2="${y.toFixed(2)}" stroke="${theme.line}" stroke-width="1" stroke-dasharray="3 5"/>`,
+      svgText(chart.left - 10, y + 4, formatValue(value), {
+        size: 12,
+        fill: theme.textMuted,
+        mono: true,
+        anchor: "end"
+      })
+    );
+  }
+  lines.push(
+    `<line x1="${chart.left}" y1="${chart.bottom}" x2="${chart.right}" y2="${chart.bottom}" stroke="${theme.line}" stroke-width="1"/>`
+  );
+  return lines.join("\n");
+}
 
 // src/render/render-compare-share-svg.ts
 var right = SHARE_WIDTH - SHARE_MARGIN;
@@ -32666,8 +33997,9 @@ function formatSkippedEntries(split) {
 }
 function formatSummaryLine(diagnostics, totalFiles) {
   const sourcesWithFiles = diagnostics.sessionStats.filter((session) => session.filesFound > 0).sort((left, right4) => right4.filesFound - left.filesFound);
+  const fileCounts = sourcesWithFiles.map((session) => `${session.source} ${integerFormatter3.format(session.filesFound)}`).join(", ");
   const parts = [
-    `Scanned ${pluralize(totalFiles, "file")} (${sourcesWithFiles.map((session) => `${session.source} ${integerFormatter3.format(session.filesFound)}`).join(", ")})`
+    totalFiles === 0 ? "Scanned no local files" : `Scanned ${pluralize(totalFiles, "file")} (${fileCounts})`
   ];
   const pricingLabel = pricingLabels[diagnostics.pricingOrigin];
   if (pricingLabel) {
@@ -32687,7 +34019,8 @@ function formatSettingsParts(diagnostics) {
 }
 function emitDiagnostics(diagnostics, diagnosticsLogger = logger) {
   const totalFiles = diagnostics.sessionStats.reduce((sum, session) => sum + session.filesFound, 0);
-  if (totalFiles > 0) {
+  const hasEvents = diagnostics.sessionStats.some((session) => session.eventsParsed > 0);
+  if (totalFiles > 0 || hasEvents) {
     diagnosticsLogger.info(formatSummaryLine(diagnostics, totalFiles));
   } else {
     const settings = formatSettingsParts(diagnostics);
@@ -32914,12 +34247,12 @@ ${options.svgs.light}
 }
 
 // src/cli/share-artifact.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { constants as constants2 } from "fs";
 import { access as access2, writeFile as writeFile3 } from "fs/promises";
-import path32 from "path";
+import path34 from "path";
 async function writeShareFile(fileName, content) {
-  const outputPath = path32.resolve(process.cwd(), fileName);
+  const outputPath = path34.resolve(process.cwd(), fileName);
   await writeFile3(outputPath, content, "utf8");
   return outputPath;
 }
@@ -32941,10 +34274,10 @@ async function resolveBinaryPath(primaryPath, fallbackNames) {
   if (await fileExists(primaryPath)) {
     return primaryPath;
   }
-  const pathDirs = (process.env.PATH ?? "").split(path32.delimiter).filter(Boolean);
+  const pathDirs = (process.env.PATH ?? "").split(path34.delimiter).filter(Boolean);
   for (const fallbackName of fallbackNames) {
     for (const dir of pathDirs) {
-      const candidate = path32.join(dir, fallbackName);
+      const candidate = path34.join(dir, fallbackName);
       if (await fileExists(candidate)) {
         return candidate;
       }
@@ -32990,7 +34323,7 @@ async function resolveOpenCommand(filePath, platform) {
 }
 async function spawnDetached(command, args) {
   await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
+    const child = spawn2(command, args, {
       detached: true,
       stdio: "ignore",
       windowsHide: true
@@ -33223,7 +34556,7 @@ function renderSummaryStats(allRow, theme) {
     }
   ];
   return stats.map(
-    (stat9, index) => renderStat({ theme, x: SHARE_MARGIN + index * statPitch, y: statsTop, size: 30, ...stat9 })
+    (stat10, index) => renderStat({ theme, x: SHARE_MARGIN + index * statPitch, y: statsTop, size: 30, ...stat10 })
   ).join("\n");
 }
 function renderPanelLabel(theme, panel, label) {
@@ -33828,9 +35161,9 @@ function aggregateEfficiency(options) {
 }
 
 // src/efficiency/git-outcome-collector.ts
-import { spawn as spawn2 } from "child_process";
-import { createInterface } from "readline";
-import path33 from "path";
+import { spawn as spawn3 } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+import path35 from "path";
 import { stat as stat6 } from "fs/promises";
 var GIT_COMMIT_MARKER = "";
 var SHORTSTAT_PATTERN = /(?<!\d)\d+\s+files?\s+changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/u;
@@ -33850,13 +35183,13 @@ function resolveGitCommandFailureReason(result) {
 }
 function resolveRepoDir(repoDir) {
   if (repoDir === void 0) {
-    return path33.resolve(process.cwd());
+    return path35.resolve(process.cwd());
   }
   const normalizedRepoDir = repoDir.trim();
   if (!normalizedRepoDir) {
     throw new Error("--repo-dir must be a non-empty path");
   }
-  return path33.resolve(normalizedRepoDir);
+  return path35.resolve(normalizedRepoDir);
 }
 function getNodeErrorCode2(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
@@ -34032,7 +35365,7 @@ function parseGitLogShortstatLines(lines, authorEmail) {
 }
 async function runGitCommand(repoDir, args) {
   return await new Promise((resolve, reject) => {
-    const child = spawn2("git", args, {
+    const child = spawn3("git", args, {
       cwd: repoDir,
       env: {
         ...process.env,
@@ -34043,7 +35376,7 @@ async function runGitCommand(repoDir, args) {
     });
     const lines = [];
     let stderr = "";
-    const stdoutReader = createInterface({ input: child.stdout });
+    const stdoutReader = createInterface2({ input: child.stdout });
     const stdoutPromise = (async () => {
       for await (const line of stdoutReader) {
         lines.push(line);
@@ -34237,21 +35570,21 @@ async function collectGitOutcomes(options, deps = {}) {
 
 // src/efficiency/repo-attribution.ts
 import { access as access3, constants as constants3, realpath as realpath3 } from "fs/promises";
-import path34 from "path";
+import path36 from "path";
 async function hasGitMarker(directoryPath) {
   try {
-    await access3(path34.join(directoryPath, ".git"), constants3.F_OK);
+    await access3(path36.join(directoryPath, ".git"), constants3.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 function normalizeComparablePath(value) {
-  const normalizedPath = path34.normalize(path34.resolve(value));
+  const normalizedPath = path36.normalize(path36.resolve(value));
   return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
 }
 async function resolveComparablePath(value) {
-  const resolvedPath = path34.resolve(value);
+  const resolvedPath = path36.resolve(value);
   try {
     return normalizeComparablePath(await realpath3(resolvedPath));
   } catch {
@@ -34263,12 +35596,12 @@ async function resolveRepoRootFromPathHint(pathHint) {
   if (!trimmedPath) {
     return void 0;
   }
-  let currentPath = path34.resolve(trimmedPath);
+  let currentPath = path36.resolve(trimmedPath);
   for (; ; ) {
     if (await hasGitMarker(currentPath)) {
       return currentPath;
     }
-    const parentPath = path34.dirname(currentPath);
+    const parentPath = path36.dirname(currentPath);
     if (parentPath === currentPath) {
       return void 0;
     }
@@ -35381,7 +36714,7 @@ async function runOptimizeReport(granularity, options) {
 }
 
 // src/render/render-session-report.ts
-import path35 from "path";
+import path37 from "path";
 import { markdownTable as markdownTable4 } from "markdown-table";
 
 // src/render/format-duration.ts
@@ -35450,7 +36783,7 @@ function toSessionTableCells(row, options) {
   return [
     options.truncateSessionIds ? truncateSessionId(row.sessionId) : row.sessionId,
     row.source,
-    row.repoRoot ? path35.basename(row.repoRoot) : "-",
+    row.repoRoot ? path37.basename(row.repoRoot) : "-",
     getPeriodKey(row.lastActivity, "daily", options.timezone),
     formatDuration(row.durationMs),
     formatInteger4(row.totalTokens),
@@ -35460,7 +36793,7 @@ function toSessionTableCells(row, options) {
 }
 function toRepoTableCells(row, timezone) {
   return [
-    row.repoRoot ? path35.basename(row.repoRoot) : "(no repo)",
+    row.repoRoot ? path37.basename(row.repoRoot) : "(no repo)",
     formatInteger4(row.sessionCount),
     getPeriodKey(row.lastActivity, "daily", timezone),
     formatInteger4(row.totalTokens),
@@ -35884,20 +37217,6 @@ var LEVEL_GLYPHS = ["\xB7", "\u2591", "\u2592", "\u2593", "\u2588"];
 var LEVELS = [0, 1, 2, 3, 4];
 var ROW_LABELS = ["Mon", "", "Wed", "", "Fri", "", ""];
 var ROW_LABEL_WIDTH = 4;
-var MONTH_LABELS2 = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec"
-];
 var MONTH_LABEL_WIDTH = 3;
 var MIN_HEATMAP_WEEKS = 13;
 var LEGEND_WIDTH = "Less ".length + LEVEL_GLYPHS.length + " More".length;
@@ -35917,7 +37236,7 @@ function renderMonthLabels(weeks) {
   weeks.forEach((week, column) => {
     const month = week[0].date.slice(5, 7);
     if (month !== previousMonth && (line.length === 0 || line.length < column) && column + MONTH_LABEL_WIDTH <= weeks.length) {
-      line = line.padEnd(column) + MONTH_LABELS2[Number(month) - 1];
+      line = line.padEnd(column) + MONTH_LABELS[Number(month) - 1];
     }
     previousMonth = month;
   });
@@ -36011,12 +37330,12 @@ function toActivityStats(activity) {
 }
 function renderTerminalActivity(activity, options, useColor) {
   const palette = options.palette ?? defaultTerminalStylePalette;
-  const paint = (styler) => (text) => useColor ? styler(text) : text;
+  const paint = (styler) => (text2) => useColor ? styler(text2) : text2;
   const dim = paint(palette.dim);
   const stats = toActivityStats(activity);
   const labelWidth = Math.max(...stats.map(([label]) => label.length));
   const valueStylers = [
-    paint((text) => palette.bold(palette.yellow(text))),
+    paint((text2) => palette.bold(palette.yellow(text2))),
     paint(palette.yellow),
     paint(palette.white),
     paint(palette.white)
@@ -36025,7 +37344,7 @@ function renderTerminalActivity(activity, options, useColor) {
     activity.days,
     {
       dim,
-      level: (level) => level === 0 ? dim : level >= 3 ? paint((text) => palette.bold(palette.green(text))) : paint(palette.green)
+      level: (level) => level === 0 ? dim : level >= 3 ? paint((text2) => palette.bold(palette.green(text2))) : paint(palette.green)
     },
     options.terminalWidth ?? resolveTtyColumns(process.stdout)
   );
@@ -36110,7 +37429,7 @@ function renderTerminalSummaryReport(summaryData, options) {
   const monthNotes = toMonthNotes(summaryData);
   if (monthNotes.length > 0) {
     const palette = options.palette ?? defaultTerminalStylePalette;
-    const warn = (text) => useColor ? palette.yellow(text) : text;
+    const warn = (text2) => useColor ? palette.yellow(text2) : text2;
     lines.push(
       "",
       ...monthNotes.map((note) => note.warning ? warn(`\u26A0 ${note.text}`) : note.text)
@@ -36177,22 +37496,8 @@ var statsTop3 = 168;
 var gridTop2 = 352;
 var gridLeft2 = SHARE_MARGIN + 36;
 var gridPitch = 19;
-var MONTH_NAMES = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec"
-];
 function formatShortDate(date) {
-  return `${MONTH_NAMES[Number(date.slice(5, 7)) - 1]} ${Number(date.slice(8, 10))}`;
+  return `${MONTH_LABELS[Number(date.slice(5, 7)) - 1]} ${Number(date.slice(8, 10))}`;
 }
 function findPeriod(data, key) {
   return data.periods.find((period) => period.key === key);
@@ -36581,7 +37886,7 @@ async function buildStatuslineSummary(options, deps) {
   if (options.json) {
     throw new Error("--json is not supported for statusline; use llm-usage summary --json");
   }
-  return buildSummaryData({ ...options, pricingOffline: true }, deps);
+  return buildSummaryData({ ...options, pricingOffline: true, sync: false }, deps);
 }
 async function runStatusline(options) {
   if (!options.verbose) {
@@ -37038,35 +38343,15 @@ function renderSummaryStats2(data, theme) {
     }
   ];
   return stats.map(
-    (stat9, index) => renderStat({
+    (stat10, index) => renderStat({
       theme,
       x: SHARE_MARGIN + index * statPitch3,
       y: statsTop4,
       size: 30,
-      ...stat9
+      ...stat10
     })
   ).join("\n");
 }
-function renderGridLines(scaleMax, metric, theme) {
-  const lines = [];
-  for (let step = 1; step <= 3; step += 1) {
-    const value = scaleMax / 3 * step;
-    const y = scaleY(value, scaleMax, chartTop, chartBottom);
-    lines.push(
-      `<line x1="${chartLeft2}" y1="${y.toFixed(2)}" x2="${chartRight2}" y2="${y.toFixed(2)}" stroke="${theme.line}" stroke-width="1" stroke-dasharray="3 5"/>`,
-      svgText(chartLeft2 - 10, y + 4, formatMetricValue4(value, metric), {
-        size: 12,
-        fill: theme.textMuted,
-        mono: true,
-        anchor: "end"
-      })
-    );
-  }
-  lines.push(
-    `<line x1="${chartLeft2}" y1="${chartBottom}" x2="${chartRight2}" y2="${chartBottom}" stroke="${theme.line}" stroke-width="1"/>`
-  );
-  return lines.join("\n");
-}
 function renderBars(buckets, scaleMax, theme) {
   const slot = (chartRight2 - chartLeft2) / buckets.length;
   const barWidth = Math.max(1, Math.min(40, slot * 0.7));
@@ -37097,7 +38382,12 @@ function renderTrendsShareSvg(data, theme) {
   const source = data.totalSeries.source === "combined" ? "all sources" : data.totalSeries.source;
   const body = buckets.length === 0 ? renderEmptyState(theme, "No usage in this window") : [
     renderSummaryStats2(data, theme),
-    renderGridLines(scaleMax, data.metric, theme),
+    renderValueGridLines(
+      scaleMax,
+      { left: chartLeft2, right: chartRight2, top: chartTop, bottom: chartBottom },
+      (value) => formatMetricValue4(value, data.metric),
+      theme
+    ),
     renderBars(buckets, scaleMax, theme),
     renderDateLabels(buckets, theme)
   ].join("\n");
@@ -37670,20 +38960,6 @@ var chartBottom2 = 500;
 var MAX_NAMED_SOURCES = 6;
 var MAX_PERIOD_LABELS = 8;
 var MIN_CENTERED_LABEL_SLOT = 80;
-var MONTH_NAMES2 = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec"
-];
 function extractPeriodSourceRows(rows) {
   return rows.filter((r) => r.rowType === "period_source");
 }
@@ -37729,7 +39005,7 @@ function formatPeriodLabel(period, granularity) {
   if (granularity === "weekly") {
     return period.slice(5);
   }
-  const month = MONTH_NAMES2[Number(period.slice(5, 7)) - 1] ?? period;
+  const month = MONTH_LABELS[Number(period.slice(5, 7)) - 1] ?? period;
   return granularity === "daily" ? `${month} ${Number(period.slice(8, 10))}` : `${month} ${period.slice(0, 4)}`;
 }
 function renderLegend(series, totalTokens, theme) {
@@ -37744,26 +39020,6 @@ ${svgText(chartLeft3 - 64, y, share, { size: 15, fill: theme.textSecondary, mono
 </g>`;
   }).join("\n");
 }
-function renderGridLines2(maxY, theme) {
-  const lines = [];
-  for (let step = 1; step <= 3; step += 1) {
-    const value = maxY / 3 * step;
-    const y = scaleY(value, maxY, chartTop2, chartBottom2);
-    lines.push(
-      `<line x1="${chartLeft3}" y1="${y.toFixed(2)}" x2="${chartRight3}" y2="${y.toFixed(2)}" stroke="${theme.line}" stroke-width="1" stroke-dasharray="3 5"/>`,
-      svgText(chartLeft3 - 10, y + 4, formatCompact(value), {
-        size: 12,
-        fill: theme.textMuted,
-        mono: true,
-        anchor: "end"
-      })
-    );
-  }
-  lines.push(
-    `<line x1="${chartLeft3}" y1="${chartBottom2}" x2="${chartRight3}" y2="${chartBottom2}" stroke="${theme.line}" stroke-width="1"/>`
-  );
-  return lines.join("\n");
-}
 function renderBars2(series, periodCount, maxY) {
   const slot = (chartRight3 - chartLeft3) / periodCount;
   const barWidth = Math.max(1, Math.min(56, slot * 0.68));
@@ -37840,7 +39096,12 @@ function renderUsageShareSvg(usageData, granularity, theme) {
       size: 30
     }),
     renderLegend(series, totalTokens, theme),
-    renderGridLines2(maxY, theme),
+    renderValueGridLines(
+      maxY,
+      { left: chartLeft3, right: chartRight3, top: chartTop2, bottom: chartBottom2 },
+      formatCompact,
+      theme
+    ),
     renderBars2(series, periods.length, maxY),
     renderPeriodLabels(periods, granularity, theme)
   ].join("\n");
@@ -37889,6 +39150,9 @@ async function prepareUsageReport(granularity, options, deps = {}) {
       if (options.compact && options.json) {
         throw new Error("--compact applies to terminal and markdown tables; drop it with --json");
       }
+      if (options.byMachine && options.share) {
+        throw new Error("--by-machine splits the table only; drop it with --share");
+      }
     },
     render: (usageData, format) => {
       const { output, notes } = renderUsageReportWithNotes(usageData, format, {
@@ -37923,7 +39187,7 @@ function formatByteSize(sizeBytes) {
 
 // src/render/render-doctor-report.ts
 import os20 from "os";
-import path36 from "path";
+import path38 from "path";
 var doctorStatusGlyphs = { ok: "\u2714", error: "\u2716" };
 var doctorStateGlyphs = {
   found: "\u2714",
@@ -37938,7 +39202,7 @@ var summaryStates = [
   { state: "not_installed", label: "not installed" }
 ];
 function abbreviateHome(searchPath, homeDir) {
-  if (homeDir.length === 0 || searchPath !== homeDir && !searchPath.startsWith(homeDir + path36.sep)) {
+  if (homeDir.length === 0 || searchPath !== homeDir && !searchPath.startsWith(homeDir + path38.sep)) {
     return searchPath;
   }
   return `~${searchPath.slice(homeDir.length)}`;
@@ -37972,15 +39236,16 @@ function renderDoctorText(results, options = {}) {
       (searchPath) => `    ${abbreviateHome(searchPath, homeDir)}`
     )
   ]);
-  const sourceResults = results.filter((result) => result.id !== "event-store");
-  return [...lines, "", formatSummary(sourceResults)].join("\n");
+  const sourceResults = results.filter((result) => result.state !== void 0);
+  const hasMachines = results.some((result) => result.format === "ssh");
+  const tip = hasMachines ? [] : [
+    "Tip: add your other machines to every report with llm-usage machine add <name> [user@host]"
+  ];
+  return [...lines, "", formatSummary(sourceResults), ...tip].join("\n");
 }
 
 // src/cli/run-doctor-report.ts
 var USAGE_PROBE_FILE_LIMIT = 25;
-function isMissingPathError3(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
 async function sortNewestFirst(files) {
   const mtimes = await Promise.all(
     files.map(async (filePath) => {
@@ -38060,18 +39325,10 @@ async function buildSourceResult(adapter, hasPathOverride) {
   };
   return { result, files };
 }
-function selectDoctorAdapters(adapters, source) {
-  const sourceFilter = normalizeSourceFilter(source);
-  validateSourceFilterValues(sourceFilter, new Set(getDefaultSourceIds()));
-  if (!sourceFilter) {
-    return adapters;
-  }
-  return adapters.filter((adapter) => sourceFilter.has(adapter.id.toLowerCase()));
-}
 async function buildDoctorResults(options, deps = {}) {
   const userConfigResolution = await resolveUserConfigForOptions(options, deps);
   const configuredOptions = userConfigResolution.options;
-  const adapters = selectDoctorAdapters(
+  const adapters = selectAdaptersBySourceFilter(
     createDefaultAdapters(configuredOptions),
     configuredOptions.source
   );
@@ -38101,8 +39358,42 @@ async function buildDoctorResults(options, deps = {}) {
       )
     );
   }
+  results.push(
+    ...await buildMachineDoctorResults(
+      userConfigResolution.loadedConfig.config.machines ?? {},
+      (deps.now ?? Date.now)()
+    )
+  );
   return results;
 }
+async function buildMachineDoctorResults(machines, now) {
+  return Promise.all(
+    Object.entries(machines).map(async ([name, machine]) => {
+      const id = `machine:${name}`;
+      try {
+        const status = await readMachineCacheStatus(name);
+        const entry = {
+          name,
+          machine,
+          state: status?.state,
+          fileCount: status?.fileCount ?? 0,
+          eventCount: status?.eventCount ?? 0
+        };
+        const detail = `${machine.ssh}: ${describeMachineStatus(entry, now)}`;
+        const { state } = entry;
+        const lastSyncFailed = state?.lastError !== void 0 && (state.attemptedAt ?? 0) >= (state.syncedAt ?? -1);
+        return lastSyncFailed && machine.enabled !== false ? { id, format: "ssh", status: "error", itemsFound: entry.eventCount, error: detail } : { id, format: "ssh", status: "ok", itemsFound: entry.eventCount, detail };
+      } catch (error) {
+        return {
+          id,
+          format: "ssh",
+          status: "error",
+          error: `cannot read its cache at ${getMachineCachePath(name)}: ${getErrorReason(error)}`
+        };
+      }
+    })
+  );
+}
 function getUnsupportedSchemaError(schemaVersion) {
   const versionLabel = schemaVersion ? `v${schemaVersion}` : "unknown";
   return `Event store schema ${versionLabel} is not supported by this llm-usage-metrics version (supports v${EVENT_STORE_SCHEMA_VERSION}); upgrade llm-usage-metrics or set LLM_USAGE_EVENT_STORE=0`;
@@ -38125,7 +39416,7 @@ async function buildEventStoreDoctorResult(filePath, discoveredFilesBySource, de
   try {
     fileStats = await stat7(filePath);
   } catch (error) {
-    if (isMissingPathError3(error)) {
+    if (hasErrorCode(error, "ENOENT")) {
       const legacyPath = await findLegacyEventStore(filePath);
       return {
         id: "event-store",
@@ -38248,9 +39539,6 @@ function renderPruneReport(result) {
 }
 
 // src/cli/run-prune-report.ts
-function isMissingPathError4(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
 function assertHasSelector(options) {
   if (options.suppressed || options.departedBefore !== void 0) {
     return;
@@ -38271,14 +39559,6 @@ function isOlderThanUtcDate(file, departedBeforeTimestamp) {
   const newestTimestamp = Date.parse(file.newestTimestamp);
   return Number.isFinite(newestTimestamp) && newestTimestamp < departedBeforeTimestamp;
 }
-function selectPruneAdapters(options, adapters) {
-  const sourceFilter = normalizeSourceFilter(options.source);
-  validateSourceFilterValues(sourceFilter, new Set(getDefaultSourceIds()));
-  if (!sourceFilter) {
-    return adapters;
-  }
-  return adapters.filter((adapter) => sourceFilter.has(adapter.id.toLowerCase()));
-}
 async function discoverLiveFiles(adapters) {
   const selectedSources = [];
   const discoveredFiles = [];
@@ -38326,7 +39606,7 @@ async function fileExists2(filePath, statFile) {
     await statFile(filePath);
     return true;
   } catch (error) {
-    if (isMissingPathError4(error)) {
+    if (hasErrorCode(error, "ENOENT")) {
       return false;
     }
     throw error;
@@ -38336,7 +39616,7 @@ async function readFileSize(filePath, statFile) {
   try {
     return (await statFile(filePath)).size;
   } catch (error) {
-    if (isMissingPathError4(error)) {
+    if (hasErrorCode(error, "ENOENT")) {
       return 0;
     }
     throw error;
@@ -38403,7 +39683,10 @@ async function buildPruneReport(options, deps = {}) {
     );
   }
   const makeAdapters = deps.createAdapters ?? createDefaultAdapters;
-  const adapters = selectPruneAdapters(configuredOptions, makeAdapters(configuredOptions));
+  const adapters = selectAdaptersBySourceFilter(
+    makeAdapters(configuredOptions),
+    configuredOptions.source
+  );
   const { selectedSources, discoveredFiles } = await discoverLiveFiles(adapters);
   const statFile = deps.statFile ?? stat8;
   const storePath = eventStoreRuntimeConfig.path;
@@ -38481,7 +39764,7 @@ async function runPruneReport(options, deps = {}) {
 
 // src/cli/run-events-report.ts
 var eventsExportFormats = ["jsonl", "csv"];
-var CSV_HEADER = "source,sessionId,timestamp,repoRoot,provider,model,inputTokens,outputTokens,reasoningTokens,cacheReadTokens,cacheWriteTokens,totalTokens,costUsd,costMode";
+var CSV_HEADER = "source,sessionId,timestamp,repoRoot,provider,model,inputTokens,outputTokens,reasoningTokens,cacheReadTokens,cacheWriteTokens,totalTokens,costUsd,costMode,machine";
 function resolveEventsFormat(options) {
   if (options.json) {
     throw new Error("--json is not supported for events; use --format jsonl");
@@ -38503,8 +39786,8 @@ function toCsvField(value) {
     return "";
   }
   const raw = String(value);
-  const text = typeof value === "string" && /^[=+\-@\t\r]/u.test(raw) ? `'${raw}` : raw;
-  return /[",\n\r]/u.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+  const text2 = typeof value === "string" && /^[=+\-@\t\r]/u.test(raw) ? `'${raw}` : raw;
+  return /[",\n\r]/u.test(text2) ? `"${text2.replaceAll('"', '""')}"` : text2;
 }
 function toCsvLine(event) {
   return [
@@ -38521,7 +39804,8 @@ function toCsvLine(event) {
     event.cacheWriteTokens,
     event.totalTokens,
     event.costUsd,
-    event.costMode
+    event.costMode,
+    event.machine
   ].map(toCsvField).join(",");
 }
 async function runEventsReport(options, deps = {}) {
@@ -38568,20 +39852,6 @@ var wrappedReportFormats = [
   "markdown",
   "json"
 ];
-var MONTH_LABELS3 = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec"
-];
 var INTENSITY_GLYPHS = ["\xB7", "\u2581", "\u2582", "\u2584", "\u2588"];
 var TOP_MODELS_HEADERS = ["#", "Model", "Tokens", "Cost"];
 var TOP_SOURCES_HEADERS = ["#", "Source", "Tokens", "Cost"];
@@ -38600,7 +39870,7 @@ function formatBusiestDay(busiestDay) {
   return busiestDay === void 0 ? "-" : `${busiestDay.date} (${formatInteger2(busiestDay.totalTokens)} tokens)`;
 }
 function renderStatLines(recap, paint, palette) {
-  const bold = (styler) => (text) => palette.bold(styler(text));
+  const bold = (styler) => (text2) => palette.bold(styler(text2));
   const totalSplitTokens = recap.weekdayTokens + recap.weekendTokens;
   const stats = [
     { label: "Tokens", value: formatInteger2(recap.totalTokens), styler: bold(palette.cyan) },
@@ -38641,16 +39911,16 @@ function renderStatLines(recap, paint, palette) {
     { label: "Events", value: formatInteger2(recap.eventCount), styler: palette.white },
     { label: "Sessions", value: formatInteger2(recap.sessionCount), styler: palette.white }
   );
-  const labelWidth = stats.reduce((max, stat9) => Math.max(max, stat9.label.length), 0);
+  const labelWidth = stats.reduce((max, stat10) => Math.max(max, stat10.label.length), 0);
   return stats.map(
-    (stat9) => `${paint(palette.dim)(stat9.label.padEnd(labelWidth))}  ${paint(stat9.styler)(stat9.value)}`
+    (stat10) => `${paint(palette.dim)(stat10.label.padEnd(labelWidth))}  ${paint(stat10.styler)(stat10.value)}`
   ).join("\n");
 }
 function renderMonthlyStrip(recap, paint, palette) {
-  const boldGreen = (text) => palette.bold(palette.green(text));
+  const boldGreen = (text2) => palette.bold(palette.green(text2));
   return recap.monthlyIntensity.map((month, index) => {
     const glyph = INTENSITY_GLYPHS[month.level] ?? "\xB7";
-    const label = MONTH_LABELS3[index] ?? month.month;
+    const label = MONTH_LABELS[index] ?? month.month;
     const glyphStyler = month.level === 0 ? palette.dim : month.level >= 3 ? boldGreen : palette.green;
     return `${paint(palette.dim)(label)} ${paint(glyphStyler)(glyph)}`;
   }).join("  ");
@@ -38690,7 +39960,7 @@ function renderTopTable(headerCells, bodyRows) {
 function renderWrappedTerminalReport(recap, options) {
   const useColor = options.useColor ?? shouldUseColorByDefault();
   const palette = options.palette ?? defaultTerminalStylePalette;
-  const paint = (styler) => (text) => useColor ? styler(text) : text;
+  const paint = (styler) => (text2) => useColor ? styler(text2) : text2;
   return [
     renderReportHeader({ title: `Wrapped ${recap.year}`, useColor }),
     paint(palette.dim)(`${recap.from} to ${recap.to} (${recap.timezone})`),
@@ -38828,7 +40098,7 @@ function renderStats2(data, theme) {
     }
   ];
   return stats.map(
-    (stat9, index) => renderStat({ theme, x: statColumns[index], y: statsTop6, size: 32, ...stat9 })
+    (stat10, index) => renderStat({ theme, x: statColumns[index], y: statsTop6, size: 32, ...stat10 })
   ).join("\n");
 }
 function renderTopList(theme, title, items, x) {
@@ -39367,7 +40637,11 @@ function registerSharedReportOptions(command, profile) {
     configuredCommand.option(
       "--history",
       "include usage from files that no longer exist on disk (the default; fails if the event store is unavailable)"
-    ).option("--no-history", "leave out usage from files that no longer exist on disk");
+    ).option("--no-history", "leave out usage from files that no longer exist on disk").option(
+      "--machine <name>",
+      "Count only these machines (repeatable or comma-separated; local is this one; default: all)",
+      collectRepeatedOption
+    ).option("--no-sync", "use other machines' cached usage without refreshing it over ssh");
   }
   if (profileConfig.includeMarkdown) {
     configuredCommand.option("--markdown", "Render output as markdown table");
@@ -39532,7 +40806,7 @@ function createUsageReportDefinition(granularity) {
       command.option(
         "--compact",
         "Abbreviate token counts and hide the Reasoning and Cache Write columns (terminal/markdown)"
-      );
+      ).option("--by-machine", "Split each source row by the machine its usage came from");
       command.action((options) => runUsageReport(granularity, options));
       return command;
     }
@@ -39892,8 +41166,8 @@ function createRootDescription() {
 }
 
 // src/cli/create-config-command.ts
-import { access as access4, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path37 from "path";
+import { access as access4, writeFile as writeFile4 } from "fs/promises";
+import path39 from "path";
 import { Command as Command2 } from "commander";
 var CONFIG_TEMPLATE_HEADER = `#:schema https://ayagmar.github.io/llm-usage-metrics/config-schema.json
 # llm-usage-metrics configuration. Uncomment a key to override its default.
@@ -39944,19 +41218,24 @@ ${sourceDirTemplate}
 # skipCheck = false
 # cacheTtlMs = ${UPDATE_CACHE_TTL_DEFAULT_MS}
 # fetchTimeoutMs = ${UPDATE_FETCH_TIMEOUT_DEFAULT_MS}
+
+# Other machines to sync usage from over ssh; each needs llm-usage-metrics
+# installed and ssh login without a prompt. \`llm-usage machine add\` checks
+# the connection and writes the table for you.
+# [machines.laptop]
+# ssh = "me@laptop.local"
+# command = "llm-usage"
+# enabled = true
 `;
-function isExistingFileError(error) {
-  return asRecord(error)?.code === "EEXIST";
-}
 async function writeConfigTemplate(configPath, options) {
-  await mkdir4(path37.dirname(configPath), { recursive: true });
+  await ensureDirectory(path39.dirname(configPath));
   try {
     await writeFile4(configPath, USER_CONFIG_TEMPLATE, {
       encoding: "utf8",
       flag: options.force === true ? "w" : "wx"
     });
   } catch (error) {
-    if (isExistingFileError(error)) {
+    if (hasErrorCode(error, "EEXIST")) {
       throw new Error(`Config file already exists: ${configPath} (use --force to overwrite)`, {
         cause: error
       });
@@ -40019,8 +41298,386 @@ function createConfigCommand() {
   return configCommand;
 }
 
-// src/cli/create-completion-command.ts
+// src/cli/create-machine-command.ts
 import { Command as Command3 } from "commander";
+
+// src/cli/run-machine-export.ts
+import { once } from "events";
+import { readFile as readFile7 } from "fs/promises";
+import os21 from "os";
+import { text } from "stream/consumers";
+async function readKnownFiles(known, stdin) {
+  if (known === void 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  return parseKnownFiles(known === "-" ? await text(stdin) : await readFile7(known, "utf8"));
+}
+async function writeLine(stdout, line) {
+  if (!stdout.write(`${JSON.stringify(line)}
+`)) {
+    await once(stdout, "drain");
+  }
+}
+async function runMachineExport(options, deps = {}) {
+  const stdout = deps.stdout ?? process.stdout;
+  const knownFiles = await readKnownFiles(options.known, deps.stdin ?? process.stdin);
+  const dataset = await buildUsageEventDataset({ machine: LOCAL_MACHINE_NAME }, deps);
+  emitReportRunDiagnostics(
+    buildUsageDiagnostics({
+      adaptersToParse: dataset.adaptersToParse,
+      successfulParseResults: dataset.successfulParseResults,
+      sourceFailures: dataset.sourceFailures,
+      pricingOrigin: "none",
+      warnings: dataset.warnings,
+      notes: dataset.notes,
+      activeEnvOverrides: dataset.readEnvVarOverrides(),
+      activeConfig: dataset.activeConfig,
+      timezone: dataset.normalizedInputs.timezone
+    }),
+    {
+      emitCommonDiagnostics: emitDiagnostics,
+      getEnvVarOverrides: (diagnostics) => diagnostics.activeEnvOverrides,
+      getActiveConfig: (diagnostics) => diagnostics.activeConfig
+    }
+  );
+  if (!dataset.ledger) {
+    throw new Error(
+      "machine export reads the event store, which is disabled or failed to open; see the warning above"
+    );
+  }
+  const store = await (deps.openEventStore ?? openEventStore)(dataset.ledger.path);
+  let snapshots;
+  try {
+    snapshots = readStoredFileSnapshots(store, dataset.ledger.countedFiles);
+  } finally {
+    (deps.closeEventStore ?? closeEventStore)(store);
+  }
+  const lines = buildMachineExportLines(
+    {
+      cliVersion: loadPackageMetadataFromRuntime().packageVersion,
+      hostname: os21.hostname(),
+      exportedAt: (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    },
+    snapshots,
+    knownFiles
+  );
+  const end = lines.at(-1);
+  const missingEventCount = dataset.filteredEvents.length - (end?.type === "end" ? end.eventCount : 0);
+  if (missingEventCount > 0) {
+    logger.warn(
+      `machine export left out ${missingEventCount} event(s) that reports count but the event store does not hold`
+    );
+  }
+  for (const line of lines) {
+    await writeLine(stdout, line);
+  }
+}
+
+// src/machines/machine-config-file.ts
+import { isDeepStrictEqual } from "util";
+import { randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile8, realpath as realpath4, rename as rename2, rm as rm4, stat as stat9, writeFile as writeFile5 } from "fs/promises";
+import path40 from "path";
+async function readConfigText(configPath) {
+  try {
+    return await readFile8(configPath, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function loadConfigText(configPath, content) {
+  const loaded = await loadUserConfig({ LLM_USAGE_CONFIG_PATH: configPath }, async () => content);
+  return loaded.config;
+}
+function withoutMachine(config, name) {
+  const machines = Object.fromEntries(
+    Object.entries(config.machines ?? {}).filter(([machineName]) => machineName !== name)
+  );
+  const rest = { ...config };
+  delete rest.machines;
+  return Object.keys(machines).length === 0 ? rest : { ...rest, machines };
+}
+async function replaceConfigFile(configPath, content) {
+  await ensureDirectory(path40.dirname(configPath));
+  const targetPath = await realpath4(configPath).catch(() => configPath);
+  const mode = (await stat9(targetPath).catch(() => void 0))?.mode;
+  const temporaryPath = `${targetPath}.${randomUUID3()}.tmp`;
+  try {
+    await writeFile5(temporaryPath, content, { encoding: "utf8", mode: mode ?? 420 });
+    await rename2(temporaryPath, targetPath);
+  } finally {
+    await rm4(temporaryPath, { force: true });
+  }
+}
+async function hasMachineEntry(configPath, name) {
+  const content = await readConfigText(configPath);
+  try {
+    return content !== void 0 && asRecord(asRecord(parse(content))?.machines)?.[name] !== void 0;
+  } catch {
+    return false;
+  }
+}
+function formatMachineBlock(name, machine, eol = "\n") {
+  const lines = [`[machines.${name}]`, `ssh = ${JSON.stringify(machine.ssh)}`];
+  if (machine.command !== void 0) {
+    lines.push(`command = ${JSON.stringify(machine.command)}`);
+  }
+  return `${lines.join(eol)}${eol}`;
+}
+async function addMachineToConfigFile(configPath, name, machine) {
+  const current = await readConfigText(configPath) ?? "";
+  const eol = current.includes("\r\n") ? "\r\n" : "\n";
+  const separator = current.length === 0 ? "" : current.endsWith("\n") ? eol : `${eol}${eol}`;
+  const updated = `${current}${separator}${formatMachineBlock(name, machine, eol)}`;
+  const before = await loadConfigText(configPath, current);
+  let after;
+  try {
+    after = await loadConfigText(configPath, updated);
+  } catch {
+    after = void 0;
+  }
+  if (!after || !isDeepStrictEqual(after.machines?.[name], machine) || !isDeepStrictEqual(withoutMachine(after, name), before)) {
+    throw new Error(
+      `Could not add [machines.${name}] to ${configPath} safely; add these lines to it by hand:
+${formatMachineBlock(name, machine)}`
+    );
+  }
+  await replaceConfigFile(configPath, updated);
+}
+var TABLE_HEADER_PATTERN = /^\s*\[/u;
+function isMachineHeader(line, name) {
+  const commentStart = line.indexOf("#");
+  const header = (commentStart === -1 ? line : line.slice(0, commentStart)).trim();
+  return header === `[machines.${name}]` || header === `[machines."${name}"]`;
+}
+async function removeMachineFromConfigFile(configPath, name) {
+  const current = await readConfigText(configPath) ?? "";
+  const lines = current.split("\n");
+  const start = lines.findIndex((line) => isMachineHeader(line, name));
+  const failure = new Error(
+    `Could not remove machine ${name} from ${configPath} safely; delete its [machines.${name}] table by hand`
+  );
+  if (start === -1) {
+    throw failure;
+  }
+  const nextTable = lines.findIndex(
+    (line, index) => index > start && TABLE_HEADER_PATTERN.test(line)
+  );
+  const tableEnd = nextTable === -1 ? lines.length : nextTable;
+  let end = start + 1;
+  for (let index = start + 1; index < tableEnd; index += 1) {
+    const text2 = lines[index].trim();
+    if (text2.length > 0 && !text2.startsWith("#")) {
+      end = index + 1;
+    }
+  }
+  if (end < tableEnd && lines[end].trim() === "") {
+    end += 1;
+  }
+  const isLast = lines.slice(end).every((line) => line.trim() === "");
+  const removeFrom = isLast && start > 0 && lines[start - 1].trim() === "" ? start - 1 : start;
+  const kept = [...lines.slice(0, removeFrom), ...lines.slice(isLast ? lines.length : end)].join(
+    "\n"
+  );
+  const updated = kept.length > 0 && current.endsWith("\n") && !kept.endsWith("\n") ? `${kept}
+` : kept;
+  const before = await loadConfigText(configPath, current);
+  let after;
+  try {
+    after = await loadConfigText(configPath, updated);
+  } catch {
+    after = void 0;
+  }
+  if (!after || !isDeepStrictEqual(after, withoutMachine(before, name))) {
+    throw failure;
+  }
+  await replaceConfigFile(configPath, updated);
+}
+
+// src/cli/run-machine-commands.ts
+async function loadConfiguredMachines() {
+  const loaded = await loadUserConfig();
+  for (const warning of loaded.warnings) {
+    logger.warn(warning);
+  }
+  return loaded.config.machines ?? {};
+}
+async function runMachineAdd(name, sshDestination, options, deps = {}) {
+  const sshTarget = sshDestination ?? name;
+  const print = deps.print ?? console.log;
+  if (!isValidMachineName(name)) {
+    const hint = /[@.:]/u.test(name) ? `; give a name first, then the destination: llm-usage machine add laptop ${name}` : "";
+    throw new Error(
+      `Invalid machine name "${name}": use 1-32 lowercase letters, digits or dashes (not "${LOCAL_MACHINE_NAME}")${hint}`
+    );
+  }
+  if (!isValidSshTarget(sshTarget)) {
+    throw new Error(
+      `Invalid ssh destination "${sshTarget}": use host, user@host or an ssh_config alias`
+    );
+  }
+  const configPath = resolveUserConfigPath(process.env);
+  if (Object.hasOwn(await loadConfiguredMachines(), name)) {
+    throw new Error(
+      `Machine ${name} is already configured in ${configPath}; pick another name or run llm-usage machine remove ${name}`
+    );
+  }
+  if (await hasMachineEntry(configPath, name)) {
+    throw new Error(
+      `${configPath} already has a machines.${name} entry that is not valid (see the warning above); fix or delete it first`
+    );
+  }
+  let command = options.command?.trim();
+  if (!command) {
+    command = await detectRemoteCommand(sshTarget, { spawnSsh: deps.spawnSsh });
+    if (command) {
+      logger.info(
+        `${sshTarget} finds llm-usage only in a login shell; launching it with: ${command}`
+      );
+    }
+  }
+  const machine = command ? { ssh: sshTarget, command } : { ssh: sshTarget };
+  logger.info(
+    `Syncing ${name} over ssh (${sshTarget}); its first export parses that machine's logs and can take a while...`
+  );
+  await deleteMachineCache(name);
+  const outcome = await syncMachine(name, machine, {
+    full: true,
+    spawnSsh: deps.spawnSsh,
+    now: deps.now
+  });
+  if (!outcome.ok) {
+    await deleteMachineCache(name);
+    throw new Error(`Could not add ${name}: ${outcome.error}`);
+  }
+  await addMachineToConfigFile(configPath, name, machine);
+  for (const line of renderSyncOutcome(outcome, (deps.now ?? Date.now)())) {
+    print(line);
+  }
+  print(
+    `Added ${name} to ${configPath}. Reports now include its usage; llm-usage sync fetches it again.`
+  );
+}
+async function runMachineRemove(name, deps = {}) {
+  const print = deps.print ?? console.log;
+  const configPath = resolveUserConfigPath(process.env);
+  if (!Object.hasOwn(await loadConfiguredMachines(), name)) {
+    throw new Error(`No machine named ${name} in ${configPath}`);
+  }
+  await removeMachineFromConfigFile(configPath, name);
+  await deleteMachineCache(name);
+  print(`Removed ${name} from ${configPath} and deleted its cached usage.`);
+}
+async function runMachineList(deps = {}) {
+  const print = deps.print ?? console.log;
+  const machines = await loadConfiguredMachines();
+  const entries = await Promise.all(
+    Object.entries(machines).map(async ([name, machine]) => {
+      const status = await readMachineCacheStatus(name);
+      return {
+        name,
+        machine,
+        state: status?.state,
+        fileCount: status?.fileCount ?? 0,
+        eventCount: status?.eventCount ?? 0
+      };
+    })
+  );
+  for (const line of renderMachineList(entries, (deps.now ?? Date.now)())) {
+    print(line);
+  }
+}
+async function runSync(names, options, deps = {}) {
+  const print = deps.print ?? console.log;
+  const machines = await loadConfiguredMachines();
+  const unknownNames = names.filter((name) => !Object.hasOwn(machines, name));
+  if (unknownNames.length > 0) {
+    const configured = Object.keys(machines);
+    throw new Error(
+      `Unknown machine(s): ${unknownNames.join(", ")}${configured.length > 0 ? ` (configured: ${configured.join(", ")})` : ""}`
+    );
+  }
+  const selected = Object.entries(machines).filter(
+    ([name, machine]) => names.length > 0 ? names.includes(name) : machine.enabled !== false
+  );
+  if (selected.length === 0) {
+    print(
+      Object.keys(machines).length === 0 ? "No machines configured. Add one with: llm-usage machine add <name> [user@host]" : "Every machine is disabled; name one to sync it anyway."
+    );
+    return;
+  }
+  const outcomes = await Promise.all(
+    selected.map(async ([name, machine]) => {
+      const outcome = await syncMachine(name, machine, {
+        full: options.full,
+        recordAttemptFirst: true,
+        spawnSsh: deps.spawnSsh,
+        now: deps.now
+      });
+      for (const line of renderSyncOutcome(outcome, (deps.now ?? Date.now)())) {
+        print(line);
+      }
+      return outcome;
+    })
+  );
+  if (outcomes.some((outcome) => !outcome.ok)) {
+    process.exitCode = 1;
+  }
+}
+
+// src/cli/create-machine-command.ts
+function createMachineCommand() {
+  const machineCommand = new Command3("machine").description("Combine usage from your other machines over ssh").addHelpText(
+    "after",
+    formatHelpExamples([
+      "llm-usage machine add laptop",
+      "llm-usage machine list",
+      "llm-usage machine remove laptop"
+    ])
+  );
+  const addCommand = new Command3("add").description(
+    "Sync a machine over ssh and add it to config.toml; it needs llm-usage-metrics installed and ssh login without a prompt"
+  ).argument("<name>", "Name for the machine in reports (lowercase letters, digits, dashes)").argument(
+    "[ssh-target]",
+    "ssh destination: host, user@host, or an ssh_config alias (default: the name)"
+  ).option("--command <command>", "How llm-usage-metrics is launched there (default: llm-usage)").addHelpText(
+    "after",
+    formatHelpExamples([
+      "llm-usage machine add laptop",
+      "llm-usage machine add work me@10.0.0.5",
+      "llm-usage machine add vps --command /home/me/.local/bin/llm-usage"
+    ])
+  ).action(
+    (name, sshTarget, options) => runMachineAdd(name, sshTarget, options)
+  );
+  const listCommand = new Command3("list").description("Show each machine, when it last synced, and how much usage is cached").addHelpText("after", formatHelpExamples(["llm-usage machine list"])).action(() => runMachineList());
+  const removeCommand = new Command3("remove").description("Remove a machine from config.toml and delete its cached usage").argument("<name>", "Machine name").addHelpText("after", formatHelpExamples(["llm-usage machine remove laptop"])).action((name) => runMachineRemove(name));
+  const exportCommand = new Command3("export").description(
+    "Print the usage this machine's reports count, as a versioned NDJSON bundle that sync reads"
+  ).option(
+    "--known <path>",
+    "Leave out files already held at the same revision, as listed in this JSON file (- for stdin)"
+  ).option("--quiet", "Suppress informational stderr output (warnings still print)").option(
+    "--verbose",
+    "Print detailed diagnostics on stderr (per-source counts, routine skips, config, env)"
+  ).addHelpText("after", formatHelpExamples(["llm-usage machine export > usage.ndjson"])).action((options) => runMachineExport(options));
+  machineCommand.addCommand(addCommand);
+  machineCommand.addCommand(listCommand);
+  machineCommand.addCommand(removeCommand);
+  machineCommand.addCommand(exportCommand);
+  return machineCommand;
+}
+function createSyncCommand() {
+  return new Command3("sync").description(
+    "Fetch your other machines' usage now (reports also fetch it when it is 10 minutes old)"
+  ).argument("[names...]", "Machines to sync (default: every enabled machine)").option("--full", "Fetch every file again instead of only the changed ones").addHelpText("after", formatHelpExamples(["llm-usage sync", "llm-usage sync laptop --full"])).action((names, options) => runSync(names, options));
+}
+
+// src/cli/create-completion-command.ts
+import { Command as Command4 } from "commander";
 var COMPLETION_SHELLS = ["bash", "zsh", "fish"];
 var PROGRAM_NAMES = ["llm-usage", "llm-usage-metrics"];
 function isPathFlag(flag) {
@@ -40216,7 +41873,7 @@ function parseShell(value) {
   return shell;
 }
 function createCompletionCommand(getProgram, argumentValues) {
-  return new Command3("completion").description("Print a shell completion script (bash, zsh, or fish)").argument("<shell>", `Shell: ${COMPLETION_SHELLS.join(" | ")}`, parseShell).addHelpText(
+  return new Command4("completion").description("Print a shell completion script (bash, zsh, or fish)").argument("<shell>", `Shell: ${COMPLETION_SHELLS.join(" | ")}`, parseShell).addHelpText(
     "after",
     formatHelpExamples([
       "source <(llm-usage completion bash)   # in ~/.bashrc",
@@ -40229,7 +41886,7 @@ function createCompletionCommand(getProgram, argumentValues) {
 }
 
 // src/cli/create-schema-command.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 
 // schema/config.schema.json
 var config_schema_default = {
@@ -40425,6 +42082,37 @@ var config_schema_default = {
       minimum: 0,
       maximum: 9007199254740991
     },
+    machines: {
+      description: "Other machines whose usage reports include, by name. Each needs llm-usage-metrics installed and ssh access without a password prompt. Add one with `llm-usage machine add`.",
+      type: "object",
+      propertyNames: {
+        pattern: "^[a-z0-9][a-z0-9-]{0,31}$",
+        not: { const: "local" }
+      },
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        required: ["ssh"],
+        properties: {
+          ssh: {
+            description: "ssh destination: host, user@host, or an alias from ~/.ssh/config.",
+            type: "string",
+            minLength: 1,
+            pattern: "^[^-\\s][^\\s]*$"
+          },
+          command: {
+            description: "How llm-usage-metrics is launched on that machine, e.g. a full path when a non-interactive ssh session does not find it.",
+            type: "string",
+            default: "llm-usage"
+          },
+          enabled: {
+            description: "Set to false to keep the machine's cached usage in reports but stop syncing it.",
+            type: "boolean",
+            default: true
+          }
+        }
+      }
+    },
     update: {
       description: "Startup update-check runtime settings.",
       type: "object",
@@ -40513,6 +42201,10 @@ var events_line_v1_schema_default = {
       type: "number",
       minimum: 0
     },
+    machine: {
+      description: "The configured machine the event came from (see machine add); omitted for this machine's own usage.",
+      type: "string"
+    },
     costMode: {
       description: "Whether the cost came from the source (explicit) or from pricing (estimated).",
       type: "string",
@@ -40523,6 +42215,92 @@ var events_line_v1_schema_default = {
   unevaluatedProperties: false
 };
 
+// schema/machine-export.v1.schema.json
+var machine_export_v1_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://ayagmar.github.io/llm-usage-metrics/machine-export.v1.schema.json",
+  title: "llm-usage-metrics machine export line (v1)",
+  description: "One NDJSON line of `llm-usage machine export`. A bundle is a header line, zero or more file lines, then an end line; a bundle without its end line is incomplete.",
+  oneOf: [{ $ref: "#/$defs/header" }, { $ref: "#/$defs/file" }, { $ref: "#/$defs/end" }],
+  $defs: {
+    header: {
+      type: "object",
+      properties: {
+        type: { const: "header" },
+        format: { const: "llm-usage-metrics.machine-export" },
+        version: {
+          description: "Bundle format version; readers reject versions they do not know.",
+          const: 1
+        },
+        cliVersion: {
+          description: "llm-usage-metrics version that wrote the bundle.",
+          type: "string"
+        },
+        hostname: { description: "Host name of the exporting machine.", type: "string" },
+        exportedAt: { description: "ISO 8601 time of the export.", type: "string" }
+      },
+      required: ["type", "format", "version", "cliVersion", "hostname", "exportedAt"],
+      additionalProperties: false
+    },
+    file: {
+      description: "The events of one counted file the reader does not hold at this revision.",
+      type: "object",
+      properties: {
+        type: { const: "file" },
+        source: { type: "string", minLength: 1 },
+        filePath: {
+          description: "Path of the file on the exporting machine.",
+          type: "string",
+          minLength: 1
+        },
+        revision: {
+          description: "Opaque; changes exactly when the file's events change.",
+          type: "string",
+          minLength: 1
+        },
+        events: {
+          description: "Unpriced usage events: costUsd is present only when the source recorded it (costMode explicit).",
+          type: "array",
+          minItems: 1,
+          items: {
+            $ref: "https://ayagmar.github.io/llm-usage-metrics/events-line.v1.schema.json"
+          }
+        }
+      },
+      required: ["type", "source", "filePath", "revision", "events"],
+      additionalProperties: false
+    },
+    end: {
+      description: "Every counted file, including those the reader already holds; a file it holds that is not listed is no longer counted.",
+      type: "object",
+      properties: {
+        type: { const: "end" },
+        files: {
+          type: "array",
+          items: {
+            description: "[source, filePath, revision]",
+            type: "array",
+            prefixItems: [
+              { type: "string", minLength: 1 },
+              { type: "string", minLength: 1 },
+              { type: "string", minLength: 1 }
+            ],
+            minItems: 3,
+            maxItems: 3
+          }
+        },
+        eventCount: {
+          description: "Total events across all listed files.",
+          type: "integer",
+          minimum: 0
+        }
+      },
+      required: ["type", "files", "eventCount"],
+      additionalProperties: false
+    }
+  }
+};
+
 // schema/report-common.v1.schema.json
 var report_common_v1_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -40843,8 +42621,14 @@ var report_doctor_v1_schema_default = {
       description: "Health of one source or the event store.",
       type: "object",
       properties: {
-        id: { description: "Source id, or event-store.", type: "string" },
-        format: { description: "Storage format of the source.", type: "string" },
+        id: {
+          description: "Source id, event-store, or machine:<name> for a configured machine.",
+          type: "string"
+        },
+        format: {
+          description: "Storage format of the source; ssh for a machine.",
+          type: "string"
+        },
         status: {
           description: "Whether discovery ran (error: it failed). See state for whether usage was found.",
           type: "string",
@@ -41782,6 +43566,10 @@ var report_usage_v1_schema_default = {
           description: "Source id for per-source rows, or combined.",
           type: "string"
         },
+        machine: {
+          description: "With --by-machine, per-source rows only: the machine the usage came from (local for this one).",
+          type: "string"
+        },
         models: {
           description: "Model identifiers active in the row.",
           type: "array",
@@ -42099,13 +43887,21 @@ var reportSchemas = {
 var schemaDocuments = {
   ...reportSchemas,
   "events-line": bundleCommonDefinitions(events_line_v1_schema_default),
+  // Its events are events-line objects, so both resources are embedded.
+  "machine-export": {
+    ...machine_export_v1_schema_default,
+    $defs: {
+      ...machine_export_v1_schema_default.$defs,
+      "events-line.v1": bundleCommonDefinitions(events_line_v1_schema_default)
+    }
+  },
   config: config_schema_default
 };
 
 // src/cli/create-schema-command.ts
 var schemaNames = Object.keys(schemaDocuments).sort();
 function createSchemaCommand() {
-  return new Command4("schema").description("Print a bundled report JSON Schema").argument("[name]", `Schema name: ${schemaNames.join(", ")}`).option("--list", "List available schema names").addHelpText(
+  return new Command5("schema").description("Print a bundled report JSON Schema").argument("[name]", `Schema name: ${schemaNames.join(", ")}`).option("--list", "List available schema names").addHelpText(
     "after",
     formatHelpExamples([
       "llm-usage schema --list",
@@ -42176,7 +43972,7 @@ function rejectUnknownCommand(program, args) {
   program.error(`error: unknown command '${unknownCommand}'${hint}`);
 }
 function createCli(options = {}) {
-  const program = new Command5();
+  const program = new Command6();
   program.name("llm-usage").description(createRootDescription()).version(options.version ?? "0.0.0").showHelpAfterError();
   for (const command of createReportCommands()) {
     const isSummary = isSummaryCommand(command);
@@ -42188,6 +43984,8 @@ function createCli(options = {}) {
     program.addCommand(command, { isDefault: isSummary });
   }
   program.addCommand(createConfigCommand());
+  program.addCommand(createMachineCommand());
+  program.addCommand(createSyncCommand());
   program.addCommand(createSchemaCommand());
   program.addCommand(
     createCompletionCommand(() => program, {
@@ -42211,47 +44009,6 @@ function createCli(options = {}) {
   return program;
 }
 
-// src/cli/package-metadata.ts
-import { createRequire as createRequire2 } from "module";
-var DEFAULT_PACKAGE_NAME = "llm-usage-metrics";
-var DEFAULT_PACKAGE_VERSION = "0.0.0";
-var defaultPackageJsonCandidates = ["../package.json", "../../package.json"];
-function normalizeMetadata(candidate) {
-  const packageJson = asRecord(candidate);
-  if (!packageJson) {
-    return void 0;
-  }
-  const packageName = typeof packageJson.name === "string" ? packageJson.name.trim() : void 0;
-  const packageVersion = typeof packageJson.version === "string" ? packageJson.version.trim() : void 0;
-  if (!packageName || !packageVersion) {
-    return void 0;
-  }
-  return {
-    packageName,
-    packageVersion
-  };
-}
-function resolvePackageMetadata(loadJson, packageJsonCandidates = defaultPackageJsonCandidates) {
-  for (const candidatePath of packageJsonCandidates) {
-    try {
-      const metadata = normalizeMetadata(loadJson(candidatePath));
-      if (metadata) {
-        return metadata;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return {
-    packageName: DEFAULT_PACKAGE_NAME,
-    packageVersion: DEFAULT_PACKAGE_VERSION
-  };
-}
-function loadPackageMetadataFromRuntime() {
-  const require3 = createRequire2(import.meta.url);
-  return resolvePackageMetadata((candidatePath) => require3(candidatePath));
-}
-
 // src/cli/index.ts
 async function loadConfigForUpdateCheck() {
   try {