@xerg/cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync8 } from "fs";
 import { styleText as styleText2 } from "util";
 
 // src/command-display.ts
@@ -111,7 +110,6 @@ function normalizeSignal(value) {
 }
 
 // src/commands/audit.ts
-import { readFileSync as readFileSync6 } from "fs";
 import { rmSync as rmSync4 } from "fs";
 
 // ../core/src/cursor/usage-csv.ts
@@ -314,6 +312,7 @@ function createDetectedSource(path) {
     }
     return {
       kind: "cursor-usage-csv",
+      runtime: "cursor",
       path: resolvedPath,
       sizeBytes: stats.size,
       mtimeMs: stats.mtimeMs
@@ -1140,6 +1139,7 @@ function buildComparisonKey(input) {
   ).sort();
   return sha1(
     JSON.stringify({
+      runtime: input.runtime,
       kinds,
       roots,
       since: normalizeSinceValue(input.since)
@@ -1250,13 +1250,31 @@ function buildFindingChanges(currentFindings, baselineFindings) {
     worsenedHighConfidenceWaste: sortFindingChanges(worsenedHighConfidenceWaste)
   };
 }
+function inferSummaryRuntime(summary) {
+  if ("runtime" in summary && summary.runtime) {
+    return summary.runtime;
+  }
+  if (summary.sourceFiles.some((source) => source.kind === "cursor-usage-csv")) {
+    return "cursor";
+  }
+  return "openclaw";
+}
 function hydrateAuditSummary(summary) {
+  const runtime = inferSummaryRuntime(summary);
+  const shouldRebuildComparisonKey = !("runtime" in summary) || !summary.runtime || !summary.comparisonKey;
+  const hydratedSources = summary.sourceFiles.map((source) => ({
+    ...source,
+    runtime: source.runtime ?? (source.kind === "cursor-usage-csv" ? "cursor" : runtime === "cursor" ? "openclaw" : runtime)
+  }));
   return {
     ...summary,
-    comparisonKey: summary.comparisonKey ?? buildComparisonKey({
-      sources: summary.sourceFiles,
+    runtime,
+    sourceFiles: hydratedSources,
+    comparisonKey: shouldRebuildComparisonKey ? buildComparisonKey({
+      runtime,
+      sources: hydratedSources,
       since: summary.since
-    }),
+    }) : summary.comparisonKey,
     comparison: summary.comparison ?? null,
     wasteByKind: summary.wasteByKind?.length > 0 ? summary.wasteByKind : buildTaxonomyBuckets(summary.findings, "waste"),
     opportunityByKind: summary.opportunityByKind?.length > 0 ? summary.opportunityByKind : buildTaxonomyBuckets(summary.findings, "opportunity"),
@@ -1330,175 +1348,6 @@ function readLatestComparableAuditSummary(input) {
   });
 }
 
-// ../core/src/detect/openclaw.ts
-import { readdirSync, statSync as statSync2 } from "fs";
-import { isAbsolute, join as join2, resolve as resolve2, sep } from "path";
-
-// ../core/src/utils/paths.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { platform } from "process";
-function getAppPaths() {
-  const home = homedir();
-  return platform === "darwin" ? {
-    data: join(home, "Library", "Application Support", "xerg"),
-    config: join(home, "Library", "Preferences", "xerg"),
-    cache: join(home, "Library", "Caches", "xerg")
-  } : platform === "win32" ? {
-    data: join(process.env.LOCALAPPDATA ?? join(home, "AppData", "Local"), "xerg", "Data"),
-    config: join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "xerg", "Config"),
-    cache: join(process.env.LOCALAPPDATA ?? join(home, "AppData", "Local"), "xerg", "Cache")
-  } : {
-    data: join(process.env.XDG_DATA_HOME ?? join(home, ".local", "share"), "xerg"),
-    config: join(process.env.XDG_CONFIG_HOME ?? join(home, ".config"), "xerg"),
-    cache: join(process.env.XDG_CACHE_HOME ?? join(home, ".cache"), "xerg")
-  };
-}
-function getDefaultDbPath() {
-  return join(getAppPaths().data, "xerg.db");
-}
-function getDefaultSessionsPattern() {
-  return join(homedir(), ".openclaw", "agents", "*", "sessions", "*.jsonl");
-}
-function getDefaultGatewayPattern() {
-  return "/tmp/openclaw/openclaw-*.log";
-}
-
-// ../core/src/detect/openclaw.ts
-function toDetected(path, kind) {
-  try {
-    const stats = statSync2(path);
-    if (!stats.isFile()) {
-      return null;
-    }
-    return {
-      kind,
-      path,
-      sizeBytes: stats.size,
-      mtimeMs: stats.mtimeMs
-    };
-  } catch {
-    return null;
-  }
-}
-async function detectOpenClawSources(options) {
-  const explicitSources = [];
-  if (options.logFile) {
-    const detected2 = toDetected(options.logFile, "gateway");
-    if (detected2) {
-      explicitSources.push(detected2);
-    }
-  }
-  if (options.sessionsDir) {
-    const matches = await collectGlobMatches("**/*.jsonl", {
-      cwd: options.sessionsDir,
-      resolveWith: options.sessionsDir
-    });
-    for (const match of matches) {
-      const detected2 = toDetected(match, "sessions");
-      if (detected2) {
-        explicitSources.push(detected2);
-      }
-    }
-  }
-  if (explicitSources.length > 0) {
-    return explicitSources.sort((left, right) => right.mtimeMs - left.mtimeMs);
-  }
-  const [gatewayMatches, sessionMatches] = await Promise.all([
-    collectGlobMatches(getDefaultGatewayPattern()),
-    collectGlobMatches(getDefaultSessionsPattern())
-  ]);
-  const detected = [
-    ...gatewayMatches.map((path) => toDetected(path, "gateway")).filter(Boolean),
-    ...sessionMatches.map((path) => toDetected(path, "sessions")).filter(Boolean)
-  ];
-  return detected.sort((left, right) => right.mtimeMs - left.mtimeMs);
-}
-async function collectGlobMatches(pattern, options) {
-  const baseDir = options?.cwd ? resolve2(options.cwd) : isAbsolute(pattern) ? sep : process.cwd();
-  const relativePattern = options?.cwd ? pattern : isAbsolute(pattern) ? pattern.slice(baseDir.length) : pattern;
-  const segments = relativePattern.split("/").filter(Boolean);
-  const matches = collectMatchesFromSegments(baseDir, segments);
-  return matches.map(
-    (match) => options?.resolveWith ? resolve2(options.resolveWith, match) : match
-  );
-}
-function collectMatchesFromSegments(currentPath, segments) {
-  if (segments.length === 0) {
-    return [currentPath];
-  }
-  const [segment, ...rest] = segments;
-  if (segment === "**") {
-    const matches2 = collectMatchesFromSegments(currentPath, rest);
-    for (const entry of readDirSafe(currentPath)) {
-      if (entry.isDirectory()) {
-        matches2.push(...collectMatchesFromSegments(join2(currentPath, entry.name), segments));
-      }
-    }
-    return matches2;
-  }
-  const matches = [];
-  const matcher = segmentToRegExp(segment);
-  for (const entry of readDirSafe(currentPath)) {
-    if (!matcher.test(entry.name)) {
-      continue;
-    }
-    const nextPath = join2(currentPath, entry.name);
-    if (rest.length === 0) {
-      matches.push(nextPath);
-      continue;
-    }
-    if (entry.isDirectory()) {
-      matches.push(...collectMatchesFromSegments(nextPath, rest));
-    }
-  }
-  return matches;
-}
-function readDirSafe(path) {
-  try {
-    return readdirSync(path, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-function segmentToRegExp(segment) {
-  const escaped = segment.replaceAll(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
-  return new RegExp(`^${escaped}$`);
-}
-async function inspectOpenClawSources(options) {
-  options.onProgress?.("Checking local OpenClaw defaults...");
-  const sources = await detectOpenClawSources(options);
-  const notes = [];
-  options.onProgress?.(
-    sources.length > 0 ? `Detected ${sources.length} local source file${sources.length === 1 ? "" : "s"}.` : "No local OpenClaw source files were detected."
-  );
-  if (sources.length === 0) {
-    notes.push("No OpenClaw gateway logs or session files were detected.");
-    notes.push(
-      "Doctor checks local defaults by default. Use --remote or --railway to inspect remote targets."
-    );
-    notes.push(
-      "Use --log-file or --sessions-dir if your OpenClaw data lives outside the defaults."
-    );
-  }
-  if (sources.some((source) => source.kind === "gateway")) {
-    notes.push("Gateway logs detected. These are preferred when cost metadata is present.");
-  }
-  if (sources.some((source) => source.kind === "sessions")) {
-    notes.push("Session transcript fallback detected. Xerg will extract usage metadata only.");
-  }
-  return {
-    canAudit: sources.length > 0,
-    sources,
-    defaults: {
-      gatewayPattern: getDefaultGatewayPattern(),
-      sessionsPattern: getDefaultSessionsPattern()
-    },
-    notes
-  };
-}
-
 // ../core/src/findings/cursor.ts
 function round3(value) {
   return Number(value.toFixed(6));
@@ -1778,10 +1627,6 @@ function buildFindings(runs) {
   };
 }
 
-// ../core/src/normalize/openclaw.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { basename } from "path";
-
 // ../core/src/pricing-catalog.ts
 var PRICING_CATALOG = [
   {
@@ -1858,75 +1703,860 @@ function estimateCostUsd(provider, model, inputTokens, outputTokens) {
   return Number((inputCost + outputCost).toFixed(8));
 }
 
-// ../core/src/utils/records.ts
-function getNestedValue(input, paths) {
-  if (!input || typeof input !== "object") {
+// ../core/src/report/timeseries.ts
+function round5(value) {
+  return Number(value.toFixed(6));
+}
+function toUtcDay(timestamp) {
+  const candidate = new Date(timestamp);
+  if (Number.isNaN(candidate.getTime())) {
     return null;
   }
-  const record = input;
-  for (const path of paths) {
-    let current = record;
-    for (const segment of path) {
-      if (!current || typeof current !== "object" || !(segment in current)) {
-        current = void 0;
-        break;
-      }
-      current = current[segment];
-    }
-    if (current !== void 0) {
-      return current;
-    }
-  }
-  return null;
+  return candidate.toISOString().slice(0, 10);
 }
-function asNumber2(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    const numeric = Number(value);
-    return Number.isFinite(numeric) ? numeric : null;
-  }
-  return null;
+function incrementUtcDay(date) {
+  const candidate = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+  candidate.setUTCDate(candidate.getUTCDate() + 1);
+  return candidate.toISOString().slice(0, 10);
 }
-function asString(value) {
-  if (typeof value === "string" && value.trim() !== "") {
-    return value.trim();
+function buildObservedUtcDayRange(runs) {
+  const days = runs.flatMap((run2) => run2.calls).map((call) => toUtcDay(call.timestamp)).filter((day) => day !== null).sort();
+  if (days.length === 0) {
+    return [];
   }
-  return null;
+  const range = [];
+  let current = days[0];
+  const last = days[days.length - 1];
+  while (current <= last) {
+    range.push(current);
+    current = incrementUtcDay(current);
+  }
+  return range;
 }
-function asBoolean2(value) {
-  if (typeof value === "boolean") {
-    return value;
+function reconcileDailyTotal(rows, key, expected) {
+  if (rows.length === 0) {
+    return;
   }
-  if (typeof value === "string") {
-    return ["true", "1", "yes"].includes(value.trim().toLowerCase());
+  const actual = round5(
+    rows.reduce((sum, row) => sum + (typeof row[key] === "number" ? row[key] : 0), 0)
+  );
+  const delta = round5(expected - actual);
+  if (delta === 0) {
+    return;
   }
-  if (typeof value === "number") {
-    return value > 0;
+  const last = rows[rows.length - 1];
+  const current = last[key];
+  if (typeof current === "number") {
+    last[key] = round5(current + delta);
   }
-  return false;
 }
-function pickMetadata(input, keys) {
-  const output = {};
-  for (const key of keys) {
-    const value = input[key];
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      output[key] = value;
-    }
+function buildSpendByDay(runs) {
+  const days = buildObservedUtcDayRange(runs);
+  if (days.length === 0) {
+    return [];
   }
-  return output;
-}
-
-// ../core/src/normalize/openclaw.ts
-function parseJsonLines(path) {
-  const content = readFileSync2(path, "utf8");
-  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  const records = [];
-  for (const line of lines) {
-    try {
-      const parsed = JSON.parse(line);
-      records.push(parsed);
+  const byDay = new Map(
+    days.map((day) => [
+      day,
+      { date: day, observedSpendUsd: 0, estimatedSpendUsd: 0, callCount: 0 }
+    ])
+  );
+  for (const run2 of runs) {
+    for (const call of run2.calls) {
+      const day = toUtcDay(call.timestamp);
+      if (!day) {
+        continue;
+      }
+      const bucket = byDay.get(day);
+      if (!bucket) {
+        continue;
+      }
+      bucket.callCount += 1;
+      if (call.costSource === "observed") {
+        bucket.observedSpendUsd += call.costUsd;
+      } else if (call.costSource === "estimated") {
+        bucket.estimatedSpendUsd += call.costUsd;
+      }
+    }
+  }
+  const rows = days.map((day) => {
+    const bucket = byDay.get(day);
+    const observedSpendUsd = round5(bucket?.observedSpendUsd ?? 0);
+    const estimatedSpendUsd = round5(bucket?.estimatedSpendUsd ?? 0);
+    return {
+      date: day,
+      observedSpendUsd,
+      estimatedSpendUsd,
+      spendUsd: round5(observedSpendUsd + estimatedSpendUsd),
+      callCount: bucket?.callCount ?? 0
+    };
+  });
+  reconcileDailyTotal(
+    rows,
+    "observedSpendUsd",
+    round5(runs.reduce((sum, run2) => sum + run2.observedCostUsd, 0))
+  );
+  reconcileDailyTotal(
+    rows,
+    "estimatedSpendUsd",
+    round5(runs.reduce((sum, run2) => sum + run2.estimatedCostUsd, 0))
+  );
+  for (const row of rows) {
+    row.spendUsd = round5(row.observedSpendUsd + row.estimatedSpendUsd);
+  }
+  return rows;
+}
+function buildWasteByDay(wasteAttributions, days, expectedWasteUsd) {
+  if (days.length === 0) {
+    return [];
+  }
+  const byDay = new Map(days.map((day) => [day, 0]));
+  for (const attribution of wasteAttributions) {
+    const day = toUtcDay(attribution.timestamp);
+    if (!day || !byDay.has(day)) {
+      continue;
+    }
+    byDay.set(day, (byDay.get(day) ?? 0) + attribution.wasteUsd);
+  }
+  const rows = days.map((day) => ({
+    date: day,
+    wasteUsd: round5(byDay.get(day) ?? 0)
+  }));
+  reconcileDailyTotal(rows, "wasteUsd", round5(expectedWasteUsd));
+  return rows;
+}
+
+// ../core/src/report/summary.ts
+function buildBreakdown(items) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const current = buckets.get(item.key) ?? { spendUsd: 0, observedSpendUsd: 0, callCount: 0 };
+    current.spendUsd += item.spendUsd;
+    current.observedSpendUsd += item.observedSpendUsd;
+    current.callCount += 1;
+    buckets.set(item.key, current);
+  }
+  return Array.from(buckets.entries()).map(([key, value]) => {
+    const observedShare = value.spendUsd === 0 ? 0 : value.observedSpendUsd / value.spendUsd;
+    return {
+      key,
+      spendUsd: Number(value.spendUsd.toFixed(6)),
+      callCount: value.callCount,
+      observedShare: Number(observedShare.toFixed(4))
+    };
+  }).sort((left, right) => right.spendUsd - left.spendUsd);
+}
+function buildAuditSummary(input) {
+  const callCount = input.runs.reduce((sum, run2) => sum + run2.calls.length, 0);
+  const totalSpendUsd = input.runs.reduce((sum, run2) => sum + run2.totalCostUsd, 0);
+  const observedSpendUsd = input.runs.reduce((sum, run2) => sum + run2.observedCostUsd, 0);
+  const estimatedSpendUsd = input.runs.reduce((sum, run2) => sum + run2.estimatedCostUsd, 0);
+  const wasteSpendUsd = input.findings.filter((finding) => finding.classification === "waste").reduce((sum, finding) => sum + finding.costImpactUsd, 0);
+  const opportunitySpendUsd = input.findings.filter((finding) => finding.classification === "opportunity").reduce((sum, finding) => sum + finding.costImpactUsd, 0);
+  const generatedAt = isoNow();
+  const spendByDay = buildSpendByDay(input.runs);
+  const observedDays = buildObservedUtcDayRange(input.runs);
+  return {
+    auditId: sha1(
+      `${generatedAt}:${input.runs.length}:${input.sources.map((source) => source.path).join("|")}`
+    ),
+    generatedAt,
+    runtime: input.runtime,
+    comparisonKey: input.comparisonKeyOverride ?? buildComparisonKey({
+      runtime: input.runtime,
+      sources: input.sources,
+      since: input.since
+    }),
+    comparison: null,
+    since: input.since,
+    runCount: input.runs.length,
+    callCount,
+    totalSpendUsd: Number(totalSpendUsd.toFixed(6)),
+    observedSpendUsd: Number(observedSpendUsd.toFixed(6)),
+    estimatedSpendUsd: Number(estimatedSpendUsd.toFixed(6)),
+    wasteSpendUsd: Number(wasteSpendUsd.toFixed(6)),
+    opportunitySpendUsd: Number(opportunitySpendUsd.toFixed(6)),
+    structuralWasteRate: Number(
+      (totalSpendUsd === 0 ? 0 : wasteSpendUsd / totalSpendUsd).toFixed(4)
+    ),
+    wasteByKind: buildTaxonomyBuckets(input.findings, "waste"),
+    opportunityByKind: buildTaxonomyBuckets(input.findings, "opportunity"),
+    spendByWorkflow: buildBreakdown(
+      input.runs.map((run2) => ({
+        key: run2.workflow,
+        spendUsd: run2.totalCostUsd,
+        observedSpendUsd: run2.observedCostUsd
+      }))
+    ),
+    spendByModel: buildBreakdown(
+      input.runs.flatMap(
+        (run2) => run2.calls.map((call) => ({
+          key: `${call.provider}/${call.model}`,
+          spendUsd: call.costUsd,
+          observedSpendUsd: call.costSource === "observed" ? call.costUsd : 0
+        }))
+      )
+    ),
+    spendByDay,
+    wasteByDay: buildWasteByDay(input.wasteAttributions, observedDays, wasteSpendUsd),
+    findings: input.findings,
+    notes: [
+      "Cost per outcome is intentionally unavailable in v0. Xerg is measuring waste intelligence only.",
+      "Opportunity findings are directional recommendations, not proven waste."
+    ],
+    sourceFiles: input.sources,
+    dbPath: input.dbPath
+  };
+}
+
+// ../core/src/runtime.ts
+import { basename as basename4 } from "path";
+
+// ../core/src/detect/hermes.ts
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join3 } from "path";
+
+// ../core/src/normalize/hermes.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+
+// ../core/src/utils/records.ts
+function getNestedValue(input, paths) {
+  if (!input || typeof input !== "object") {
+    return null;
+  }
+  const record = input;
+  for (const path of paths) {
+    let current = record;
+    for (const segment of path) {
+      if (!current || typeof current !== "object" || !(segment in current)) {
+        current = void 0;
+        break;
+      }
+      current = current[segment];
+    }
+    if (current !== void 0) {
+      return current;
+    }
+  }
+  return null;
+}
+function asNumber2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : null;
+  }
+  return null;
+}
+function asString(value) {
+  if (typeof value === "string" && value.trim() !== "") {
+    return value.trim();
+  }
+  return null;
+}
+function asBoolean2(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return ["true", "1", "yes"].includes(value.trim().toLowerCase());
+  }
+  if (typeof value === "number") {
+    return value > 0;
+  }
+  return false;
+}
+function pickMetadata(input, keys) {
+  const output = {};
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      output[key] = value;
+    }
+  }
+  return output;
+}
+
+// ../core/src/normalize/hermes.ts
+var PRICING_PROVIDER_PREFIXES = /* @__PURE__ */ new Set(["anthropic", "openai", "google", "meta"]);
+function parseJsonLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  const jsonStart = trimmed.indexOf("{");
+  const jsonEnd = trimmed.lastIndexOf("}");
+  if (jsonStart < 0 || jsonEnd <= jsonStart) {
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed.slice(jsonStart, jsonEnd + 1));
+  } catch {
+    return null;
+  }
+}
+function parseJsonLines(path) {
+  const content = readFileSync2(path, "utf8");
+  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const records = [];
+  for (const line of lines) {
+    const parsed = parseJsonLine(line);
+    if (parsed) {
+      records.push(parsed);
+    }
+  }
+  return records;
+}
+function flattenSourceRecords(source) {
+  const records = parseJsonLines(source.path);
+  if (source.kind !== "sessions") {
+    return records;
+  }
+  return records.flatMap((record) => expandSessionRecord(record));
+}
+function expandSessionRecord(record) {
+  const messages = getNestedValue(record, [["messages"]]);
+  if (!Array.isArray(messages)) {
+    return [record];
+  }
+  return messages.filter((message) => Boolean(message) && typeof message === "object").map((message, index) => ({
+    ...record,
+    message,
+    timestamp: asString(
+      getNestedValue(message, [["timestamp"], ["created_at"], ["createdAt"], ["time"]])
+    ) ?? asString(
+      getNestedValue(record, [["timestamp"], ["created_at"], ["createdAt"], ["updated_at"]])
+    ) ?? `${sourceTimestampSeed(record)}:${index}`
+  }));
+}
+function sourceTimestampSeed(record) {
+  return asString(getNestedValue(record, [["updated_at"], ["created_at"], ["timestamp"], ["id"]])) ?? "session";
+}
+function normalizeProviderAndModel(record) {
+  const rawProvider = asString(
+    getNestedValue(record, [
+      ["provider"],
+      ["provider_name"],
+      ["runtime", "provider"],
+      ["usage", "provider"],
+      ["token_usage", "provider"],
+      ["message", "provider"],
+      ["message", "usage", "provider"]
+    ])
+  ) ?? "unknown";
+  const rawModel = asString(
+    getNestedValue(record, [
+      ["model"],
+      ["model_name"],
+      ["runtime", "model"],
+      ["usage", "model"],
+      ["token_usage", "model"],
+      ["message", "model"],
+      ["message", "usage", "model"]
+    ])
+  ) ?? "unknown-model";
+  if (rawModel.includes("/")) {
+    const [providerPrefix, ...rest] = rawModel.split("/");
+    if (PRICING_PROVIDER_PREFIXES.has(providerPrefix.toLowerCase()) && rest.length > 0) {
+      return {
+        provider: providerPrefix.toLowerCase(),
+        model: rest.join("/")
+      };
+    }
+  }
+  return {
+    provider: rawProvider.toLowerCase(),
+    model: rawModel
+  };
+}
+function inferWorkflow(record, sourcePath) {
+  return asString(
+    getNestedValue(record, [
+      ["workflow"],
+      ["job_name"],
+      ["task_class"],
+      ["taskClass"],
+      ["agent_name"],
+      ["agent", "name"],
+      ["source"],
+      ["session", "source"],
+      ["session_key"],
+      ["session_id"],
+      ["sessionId"],
+      ["title"]
+    ])
+  ) ?? basename(sourcePath).replace(/\.(jsonl|json|log)(\.\d+)?$/i, "");
+}
+function inferEnvironment(record) {
+  return asString(getNestedValue(record, [["environment"], ["env"], ["metadata", "environment"]])) ?? "local";
+}
+function inferRunKey(record, workflow, index, sourcePath) {
+  return asString(
+    getNestedValue(record, [
+      ["run_id"],
+      ["runId"],
+      ["session_id"],
+      ["sessionId"],
+      ["session_key"],
+      ["thread_id"],
+      ["threadId"],
+      ["trace_id"],
+      ["traceId"],
+      ["conversation_id"],
+      ["conversationId"],
+      ["id"]
+    ])
+  ) ?? `${sourcePath}:${workflow}:${index}`;
+}
+function inferTaskClass(record, workflow) {
+  return asString(
+    getNestedValue(record, [
+      ["task_class"],
+      ["taskClass"],
+      ["event"],
+      ["source"],
+      ["message", "source"]
+    ])
+  ) ?? workflow.toLowerCase();
+}
+function inferToolCalls(record) {
+  const direct = asNumber2(
+    getNestedValue(record, [
+      ["tool_calls"],
+      ["toolCalls"],
+      ["usage", "tool_calls"],
+      ["message", "usage", "tool_calls"]
+    ])
+  ) ?? null;
+  if (direct !== null) {
+    return direct;
+  }
+  const toolCalls = getNestedValue(record, [
+    ["tool_calls"],
+    ["toolCalls"],
+    ["message", "tool_calls"]
+  ]);
+  return Array.isArray(toolCalls) ? toolCalls.length : 0;
+}
+function extractUsage(record) {
+  const inputTokens = asNumber2(
+    getNestedValue(record, [
+      ["input_tokens"],
+      ["inputTokens"],
+      ["usage", "input_tokens"],
+      ["usage", "inputTokens"],
+      ["usage", "prompt_tokens"],
+      ["token_usage", "input_tokens"],
+      ["token_usage", "prompt_tokens"],
+      ["token_usage", "input"],
+      ["message", "usage", "input_tokens"],
+      ["message", "usage", "prompt_tokens"],
+      ["message", "token_usage", "input_tokens"]
+    ])
+  ) ?? 0;
+  const outputTokens = asNumber2(
+    getNestedValue(record, [
+      ["output_tokens"],
+      ["outputTokens"],
+      ["usage", "output_tokens"],
+      ["usage", "outputTokens"],
+      ["usage", "completion_tokens"],
+      ["token_usage", "output_tokens"],
+      ["token_usage", "completion_tokens"],
+      ["token_usage", "output"],
+      ["message", "usage", "output_tokens"],
+      ["message", "usage", "completion_tokens"],
+      ["message", "token_usage", "output_tokens"]
+    ])
+  ) ?? 0;
+  const observedCost = asNumber2(
+    getNestedValue(record, [
+      ["cost_usd"],
+      ["costUsd"],
+      ["estimated_cost_usd"],
+      ["estimatedCostUsd"],
+      ["total_cost_usd"],
+      ["usage", "cost_usd"],
+      ["usage", "costUsd"],
+      ["usage", "estimated_cost_usd"],
+      ["usage", "total_cost_usd"],
+      ["token_usage", "cost_usd"],
+      ["token_usage", "total_cost_usd"],
+      ["cost", "usd"],
+      ["cost", "total_usd"],
+      ["pricing", "total_usd"],
+      ["message", "usage", "cost_usd"],
+      ["message", "cost_usd"]
+    ])
+  ) ?? null;
+  return {
+    inputTokens,
+    outputTokens,
+    observedCost
+  };
+}
+function shouldTreatAsCall(record) {
+  const { inputTokens, outputTokens, observedCost } = extractUsage(record);
+  return inputTokens > 0 || outputTokens > 0 || observedCost !== null;
+}
+function buildCall2(source, record, runId, index) {
+  const { provider, model } = normalizeProviderAndModel(record);
+  const workflow = inferWorkflow(record, source.path);
+  const { inputTokens, outputTokens, observedCost } = extractUsage(record);
+  const estimatedCost = estimateCostUsd(provider, model, inputTokens, outputTokens);
+  const timestamp = toIsoOrNow(
+    getNestedValue(record, [
+      ["timestamp"],
+      ["createdAt"],
+      ["created_at"],
+      ["time"],
+      ["updated_at"]
+    ])
+  );
+  const attempt = asNumber2(
+    getNestedValue(record, [["attempt"], ["usage", "attempt"], ["metadata", "attempt"]])
+  ) ?? null;
+  const iteration = asNumber2(
+    getNestedValue(record, [["iteration"], ["loop_iteration"], ["metadata", "iteration"]])
+  ) ?? null;
+  const retries = asNumber2(getNestedValue(record, [["retries"], ["retry_count"], ["metadata", "retries"]])) ?? 0;
+  const costUsd = observedCost ?? estimatedCost ?? 0;
+  return {
+    id: sha1(`${runId}:${source.path}:${index}:${model}:${timestamp}:${costUsd}`),
+    runId,
+    timestamp,
+    provider,
+    model,
+    inputTokens,
+    outputTokens,
+    costUsd,
+    costSource: observedCost !== null ? "observed" : estimatedCost !== null ? "estimated" : "unpriced",
+    latencyMs: asNumber2(getNestedValue(record, [["latency_ms"], ["latencyMs"], ["usage", "latency_ms"]])) ?? null,
+    toolCalls: inferToolCalls(record),
+    retries,
+    attempt,
+    iteration,
+    status: asString(getNestedValue(record, [["status"], ["level"], ["result"], ["error", "type"]])) ?? null,
+    taskClass: inferTaskClass(record, workflow),
+    cacheHit: asBoolean2(
+      getNestedValue(record, [["cache_hit"], ["cacheHit"], ["usage", "cache_hit"]])
+    ),
+    cacheCostUsd: asNumber2(
+      getNestedValue(record, [["cache_cost_usd"], ["cacheCostUsd"], ["usage", "cache_cost_usd"]])
+    ) ?? null,
+    metadata: pickMetadata(record, [
+      "event",
+      "type",
+      "source",
+      "session_id",
+      "sessionId",
+      "thread_id",
+      "trace_id"
+    ])
+  };
+}
+function logFileHasBillableRecords(path) {
+  return flattenSourceRecords({
+    kind: "gateway",
+    runtime: "hermes",
+    path,
+    sizeBytes: 0,
+    mtimeMs: 0
+  }).some((record) => shouldTreatAsCall(record));
+}
+function normalizeHermesSources(sources, since) {
+  const cutoff = parseSince(since);
+  const runsById = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const records = flattenSourceRecords(source);
+    records.forEach((record, index) => {
+      if (!shouldTreatAsCall(record)) {
+        return;
+      }
+      const workflow = inferWorkflow(record, source.path);
+      const timestamp = toIsoOrNow(
+        getNestedValue(record, [
+          ["timestamp"],
+          ["createdAt"],
+          ["created_at"],
+          ["time"],
+          ["updated_at"]
+        ])
+      );
+      if (cutoff && new Date(timestamp).getTime() < cutoff) {
+        return;
+      }
+      const runKey = inferRunKey(record, workflow, index, source.path);
+      const runId = sha1(`${source.path}:${runKey}`);
+      const call = buildCall2(source, record, runId, index);
+      const existing = runsById.get(runId);
+      if (!existing) {
+        runsById.set(runId, {
+          id: runId,
+          sourceKind: source.kind,
+          sourcePath: source.path,
+          timestamp,
+          workflow,
+          environment: inferEnvironment(record),
+          tags: {
+            sourceKind: source.kind
+          },
+          calls: [call],
+          totalCostUsd: call.costUsd,
+          totalTokens: call.inputTokens + call.outputTokens,
+          observedCostUsd: call.costSource === "observed" ? call.costUsd : 0,
+          estimatedCostUsd: call.costSource === "estimated" ? call.costUsd : 0
+        });
+        return;
+      }
+      existing.calls.push(call);
+      existing.totalCostUsd = Number((existing.totalCostUsd + call.costUsd).toFixed(8));
+      existing.totalTokens += call.inputTokens + call.outputTokens;
+      existing.observedCostUsd += call.costSource === "observed" ? call.costUsd : 0;
+      existing.estimatedCostUsd += call.costSource === "estimated" ? call.costUsd : 0;
+      if (timestamp < existing.timestamp) {
+        existing.timestamp = timestamp;
+      }
+    });
+  }
+  return Array.from(runsById.values()).sort(
+    (left, right) => left.timestamp < right.timestamp ? -1 : 1
+  );
+}
+
+// ../core/src/utils/paths.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { platform } from "process";
+function getUserHome() {
+  return process.env.HOME ?? homedir();
+}
+function getAppPaths() {
+  const home = getUserHome();
+  return platform === "darwin" ? {
+    data: join(home, "Library", "Application Support", "xerg"),
+    config: join(home, "Library", "Preferences", "xerg"),
+    cache: join(home, "Library", "Caches", "xerg")
+  } : platform === "win32" ? {
+    data: join(process.env.LOCALAPPDATA ?? join(home, "AppData", "Local"), "xerg", "Data"),
+    config: join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "xerg", "Config"),
+    cache: join(process.env.LOCALAPPDATA ?? join(home, "AppData", "Local"), "xerg", "Cache")
+  } : {
+    data: join(process.env.XDG_DATA_HOME ?? join(home, ".local", "share"), "xerg"),
+    config: join(process.env.XDG_CONFIG_HOME ?? join(home, ".config"), "xerg"),
+    cache: join(process.env.XDG_CACHE_HOME ?? join(home, ".cache"), "xerg")
+  };
+}
+function getDefaultDbPath() {
+  return join(getAppPaths().data, "xerg.db");
+}
+function getDefaultOpenClawSessionsPattern() {
+  return join(getUserHome(), ".openclaw", "agents", "*", "sessions", "*.jsonl");
+}
+function getDefaultOpenClawGatewayPattern() {
+  return "/tmp/openclaw/openclaw-*.log";
+}
+function getDefaultHermesSessionsPattern() {
+  return join(getUserHome(), ".hermes", "sessions", "**", "*.{json,jsonl}");
+}
+function getDefaultHermesGatewayPattern() {
+  return join(getUserHome(), ".hermes", "logs", "agent.log* (fallback: gateway.log*)");
+}
+
+// ../core/src/detect/shared.ts
+import { readdirSync, statSync as statSync2 } from "fs";
+import { isAbsolute, join as join2, resolve as resolve2, sep } from "path";
+function toDetected(path, kind, runtime) {
+  try {
+    const stats = statSync2(path);
+    if (!stats.isFile()) {
+      return null;
+    }
+    return {
+      kind,
+      runtime,
+      path,
+      sizeBytes: stats.size,
+      mtimeMs: stats.mtimeMs
+    };
+  } catch {
+    return null;
+  }
+}
+async function collectGlobMatches(pattern, options) {
+  const baseDir = options?.cwd ? resolve2(options.cwd) : isAbsolute(pattern) ? sep : process.cwd();
+  const relativePattern = options?.cwd ? pattern : isAbsolute(pattern) ? pattern.slice(baseDir.length) : pattern;
+  const segments = relativePattern.split("/").filter(Boolean);
+  const matches = collectMatchesFromSegments(baseDir, segments);
+  return matches.map(
+    (match) => options?.resolveWith ? resolve2(options.resolveWith, match) : match
+  );
+}
+function collectMatchesFromSegments(currentPath, segments) {
+  if (segments.length === 0) {
+    return [currentPath];
+  }
+  const [segment, ...rest] = segments;
+  if (segment === "**") {
+    const matches2 = collectMatchesFromSegments(currentPath, rest);
+    for (const entry of readDirSafe(currentPath)) {
+      if (entry.isDirectory()) {
+        matches2.push(...collectMatchesFromSegments(join2(currentPath, entry.name), segments));
+      }
+    }
+    return matches2;
+  }
+  const matches = [];
+  const matcher = segmentToRegExp(segment);
+  for (const entry of readDirSafe(currentPath)) {
+    if (!matcher.test(entry.name)) {
+      continue;
+    }
+    const nextPath = join2(currentPath, entry.name);
+    if (rest.length === 0) {
+      matches.push(nextPath);
+      continue;
+    }
+    if (entry.isDirectory()) {
+      matches.push(...collectMatchesFromSegments(nextPath, rest));
+    }
+  }
+  return matches;
+}
+function readDirSafe(path) {
+  try {
+    return readdirSync(path, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function segmentToRegExp(segment) {
+  const escaped = segment.replaceAll(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
+  return new RegExp(`^${escaped}$`);
+}
+
+// ../core/src/detect/hermes.ts
+function getDefaultAgentLogPattern() {
+  return join3(process.env.HOME ?? homedir2(), ".hermes", "logs", "agent.log*");
+}
+function getDefaultGatewayLogPattern() {
+  return join3(process.env.HOME ?? homedir2(), ".hermes", "logs", "gateway.log*");
+}
+function getDefaultSessionsDirPattern() {
+  return join3(process.env.HOME ?? homedir2(), ".hermes", "sessions", "**", "*");
+}
+function isHermesSessionTranscript(path) {
+  const lowerName = basename2(path).toLowerCase();
+  if (lowerName === "sessions.json") {
+    return false;
+  }
+  return lowerName.endsWith(".jsonl") || lowerName.endsWith(".json");
+}
+async function collectHermesSessionMatches(baseDir) {
+  const matches = await collectGlobMatches("**/*", {
+    cwd: baseDir,
+    resolveWith: baseDir
+  });
+  return matches.filter((match) => isHermesSessionTranscript(match));
+}
+async function pickPreferredLogFamily() {
+  const [agentMatches, gatewayMatches] = await Promise.all([
+    collectGlobMatches(getDefaultAgentLogPattern()),
+    collectGlobMatches(getDefaultGatewayLogPattern())
+  ]);
+  if (agentMatches.some((path) => logFileHasBillableRecords(path))) {
+    return agentMatches;
+  }
+  if (gatewayMatches.some((path) => logFileHasBillableRecords(path))) {
+    return gatewayMatches;
+  }
+  return [...agentMatches, ...gatewayMatches];
+}
+async function detectHermesSources(options) {
+  const explicitSources = [];
+  if (options.logFile) {
+    const detected2 = toDetected(options.logFile, "gateway", "hermes");
+    if (detected2) {
+      explicitSources.push(detected2);
+    }
+  }
+  if (options.sessionsDir) {
+    const matches = await collectHermesSessionMatches(options.sessionsDir);
+    for (const match of matches) {
+      const detected2 = toDetected(match, "sessions", "hermes");
+      if (detected2) {
+        explicitSources.push(detected2);
+      }
+    }
+  }
+  if (explicitSources.length > 0) {
+    return explicitSources.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  }
+  const [gatewayMatches, sessionMatches] = await Promise.all([
+    pickPreferredLogFamily(),
+    collectGlobMatches(getDefaultSessionsDirPattern())
+  ]);
+  const detected = [
+    ...gatewayMatches.map((path) => toDetected(path, "gateway", "hermes")).filter(Boolean),
+    ...sessionMatches.filter((path) => isHermesSessionTranscript(path)).map((path) => toDetected(path, "sessions", "hermes")).filter(Boolean)
+  ];
+  return detected.sort((left, right) => right.mtimeMs - left.mtimeMs);
+}
+
+// ../core/src/detect/openclaw.ts
+async function detectOpenClawSources(options) {
+  const explicitSources = [];
+  if (options.logFile) {
+    const detected2 = toDetected(options.logFile, "gateway", "openclaw");
+    if (detected2) {
+      explicitSources.push(detected2);
+    }
+  }
+  if (options.sessionsDir) {
+    const matches = await collectGlobMatches("**/*.jsonl", {
+      cwd: options.sessionsDir,
+      resolveWith: options.sessionsDir
+    });
+    for (const match of matches) {
+      const detected2 = toDetected(match, "sessions", "openclaw");
+      if (detected2) {
+        explicitSources.push(detected2);
+      }
+    }
+  }
+  if (explicitSources.length > 0) {
+    return explicitSources.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  }
+  const [gatewayMatches, sessionMatches] = await Promise.all([
+    collectGlobMatches(getDefaultOpenClawGatewayPattern()),
+    collectGlobMatches(getDefaultOpenClawSessionsPattern())
+  ]);
+  const detected = [
+    ...gatewayMatches.map((path) => toDetected(path, "gateway", "openclaw")).filter(Boolean),
+    ...sessionMatches.map((path) => toDetected(path, "sessions", "openclaw")).filter(Boolean)
+  ];
+  return detected.sort((left, right) => right.mtimeMs - left.mtimeMs);
+}
+
+// ../core/src/normalize/openclaw.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { basename as basename3 } from "path";
+function parseJsonLines2(path) {
+  const content = readFileSync3(path, "utf8");
+  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const records = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      records.push(parsed);
     } catch {
     }
   }
@@ -1940,7 +2570,7 @@ function inferProvider2(record) {
 function inferModel(record) {
   return asString(getNestedValue(record, [["model"], ["message", "model"], ["usage", "model"]])) ?? "unknown-model";
 }
-function inferWorkflow(record, sourcePath) {
+function inferWorkflow2(record, sourcePath) {
   return asString(
     getNestedValue(record, [
       ["workflow"],
@@ -1950,12 +2580,12 @@ function inferWorkflow(record, sourcePath) {
       ["agentId"],
       ["sessionId"]
     ])
-  ) ?? basename(sourcePath, ".jsonl");
+  ) ?? basename3(sourcePath, ".jsonl");
 }
-function inferEnvironment(record) {
+function inferEnvironment2(record) {
   return asString(getNestedValue(record, [["environment"], ["env"], ["metadata", "environment"]])) ?? "local";
 }
-function inferRunKey(record, workflow, index, sourcePath) {
+function inferRunKey2(record, workflow, index, sourcePath) {
   return asString(
     getNestedValue(record, [
       ["run_id"],
@@ -1967,10 +2597,10 @@ function inferRunKey(record, workflow, index, sourcePath) {
     ])
   ) ?? `${sourcePath}:${workflow}:${index}`;
 }
-function inferTaskClass(record, workflow) {
+function inferTaskClass2(record, workflow) {
   return asString(getNestedValue(record, [["task_class"], ["taskClass"], ["metadata", "taskClass"]])) ?? workflow.toLowerCase();
 }
-function extractUsage(record) {
+function extractUsage2(record) {
   const inputTokens = asNumber2(
     getNestedValue(record, [
       ["input_tokens"],
@@ -2013,11 +2643,11 @@ function extractUsage(record) {
     observedCost
   };
 }
-function buildCall2(source, record, runId, index) {
+function buildCall3(source, record, runId, index) {
   const provider = inferProvider2(record);
   const model = inferModel(record);
-  const workflow = inferWorkflow(record, source.path);
-  const { inputTokens, outputTokens, observedCost } = extractUsage(record);
+  const workflow = inferWorkflow2(record, source.path);
+  const { inputTokens, outputTokens, observedCost } = extractUsage2(record);
   const estimatedCost = estimateCostUsd(provider, model, inputTokens, outputTokens);
   const timestamp = toIsoOrNow(
     getNestedValue(record, [["timestamp"], ["createdAt"], ["created_at"]])
@@ -2046,7 +2676,7 @@ function buildCall2(source, record, runId, index) {
     attempt,
     iteration,
     status: asString(getNestedValue(record, [["status"], ["level"], ["result"], ["error", "type"]])) ?? null,
-    taskClass: inferTaskClass(record, workflow),
+    taskClass: inferTaskClass2(record, workflow),
     cacheHit: asBoolean2(
       getNestedValue(record, [["cache_hit"], ["cacheHit"], ["usage", "cache_hit"]])
     ),
@@ -2056,29 +2686,29 @@ function buildCall2(source, record, runId, index) {
     metadata: pickMetadata(record, ["event", "type", "sessionId", "agentId"])
   };
 }
-function shouldTreatAsCall(record) {
-  const hasUsage = extractUsage(record).inputTokens > 0 || extractUsage(record).outputTokens > 0 || extractUsage(record).observedCost !== null;
+function shouldTreatAsCall2(record) {
+  const hasUsage = extractUsage2(record).inputTokens > 0 || extractUsage2(record).outputTokens > 0 || extractUsage2(record).observedCost !== null;
   return hasUsage;
 }
 function normalizeOpenClawSources(sources, since) {
   const cutoff = parseSince(since);
   const runsById = /* @__PURE__ */ new Map();
   for (const source of sources) {
-    const records = parseJsonLines(source.path);
+    const records = parseJsonLines2(source.path);
     records.forEach((record, index) => {
-      if (!shouldTreatAsCall(record)) {
+      if (!shouldTreatAsCall2(record)) {
         return;
       }
-      const workflow = inferWorkflow(record, source.path);
+      const workflow = inferWorkflow2(record, source.path);
       const timestamp = toIsoOrNow(
         getNestedValue(record, [["timestamp"], ["createdAt"], ["created_at"]])
       );
       if (cutoff && new Date(timestamp).getTime() < cutoff) {
         return;
       }
-      const runKey = inferRunKey(record, workflow, index, source.path);
+      const runKey = inferRunKey2(record, workflow, index, source.path);
       const runId = sha1(`${source.path}:${runKey}`);
-      const call = buildCall2(source, record, runId, index);
+      const call = buildCall3(source, record, runId, index);
       const existing = runsById.get(runId);
       if (!existing) {
         runsById.set(runId, {
@@ -2087,7 +2717,7 @@ function normalizeOpenClawSources(sources, since) {
           sourcePath: source.path,
           timestamp,
           workflow,
-          environment: inferEnvironment(record),
+          environment: inferEnvironment2(record),
           tags: {
             sourceKind: source.kind
           },
@@ -2111,214 +2741,281 @@ function normalizeOpenClawSources(sources, since) {
   });
 }
 
-// ../core/src/report/timeseries.ts
-function round5(value) {
-  return Number(value.toFixed(6));
-}
-function toUtcDay(timestamp) {
-  const candidate = new Date(timestamp);
-  if (Number.isNaN(candidate.getTime())) {
-    return null;
+// ../core/src/runtime.ts
+var RUNTIME_ADAPTERS = {
+  openclaw: {
+    runtime: "openclaw",
+    productName: "OpenClaw",
+    detectSources: detectOpenClawSources,
+    normalizeSources: normalizeOpenClawSources,
+    noSourceNotes: [
+      "No OpenClaw gateway logs or session files were detected.",
+      "Doctor checks local defaults by default. Use --log-file or --sessions-dir if your OpenClaw data lives outside the defaults.",
+      "Use --remote or --railway to inspect remote OpenClaw targets."
+    ],
+    gatewayNote: "Gateway logs detected. These are preferred when cost metadata is present.",
+    sessionNote: "Session transcript fallback detected. Xerg will extract usage metadata only.",
+    noDataError: (commandPrefix) => `No OpenClaw sources were detected. Run \`${commandPrefix} doctor --runtime openclaw\` or provide --log-file / --sessions-dir.`,
+    defaultPaths: () => ({
+      runtime: "openclaw",
+      gatewayPattern: getDefaultOpenClawGatewayPattern(),
+      sessionsPattern: getDefaultOpenClawSessionsPattern()
+    })
+  },
+  hermes: {
+    runtime: "hermes",
+    productName: "Hermes",
+    detectSources: detectHermesSources,
+    normalizeSources: normalizeHermesSources,
+    noSourceNotes: [
+      "No Hermes gateway logs or session files were detected.",
+      "Doctor checks local defaults by default. Use --log-file or --sessions-dir if your Hermes data lives outside the defaults.",
+      "Hermes remote transport is not part of this rollout yet."
+    ],
+    gatewayNote: "Hermes gateway logs detected. Xerg prefers agent.log entries when billable model-call records are present.",
+    sessionNote: "Hermes session transcripts detected. Xerg will extract usage metadata only.",
+    noDataError: (commandPrefix) => `No Hermes sources were detected. Run \`${commandPrefix} doctor --runtime hermes\` or provide --log-file / --sessions-dir.`,
+    defaultPaths: () => ({
+      runtime: "hermes",
+      gatewayPattern: getDefaultHermesGatewayPattern(),
+      sessionsPattern: getDefaultHermesSessionsPattern()
+    })
   }
-  return candidate.toISOString().slice(0, 10);
+};
+function getRuntimeAdapter(runtime) {
+  return RUNTIME_ADAPTERS[runtime];
 }
-function incrementUtcDay(date) {
-  const candidate = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
-  candidate.setUTCDate(candidate.getUTCDate() + 1);
-  return candidate.toISOString().slice(0, 10);
+function hasExplicitLocalPaths(options) {
+  return Boolean(options.logFile || options.sessionsDir);
 }
-function buildObservedUtcDayRange(runs) {
-  const days = runs.flatMap((run2) => run2.calls).map((call) => toUtcDay(call.timestamp)).filter((day) => day !== null).sort();
-  if (days.length === 0) {
-    return [];
+function inferRuntimeFromExplicitPaths(options) {
+  const paths = [options.logFile, options.sessionsDir].filter((path) => Boolean(path)).map((path) => path.replace(/\\/g, "/").toLowerCase());
+  if (paths.length === 0) {
+    return null;
   }
-  const range = [];
-  let current = days[0];
-  const last = days[days.length - 1];
-  while (current <= last) {
-    range.push(current);
-    current = incrementUtcDay(current);
+  const hints = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const name = basename4(path).toLowerCase();
+    if (path.includes("/.openclaw/") || path.includes("/openclaw/") || path.includes("/tmp/openclaw") || name.includes("openclaw")) {
+      hints.add("openclaw");
+    }
+    if (path.includes("/.hermes/") || path.includes("/hermes/") || path.includes("/.hermes") || name.includes("hermes") || name.startsWith("agent.log")) {
+      hints.add("hermes");
+    }
   }
-  return range;
+  return hints.size === 1 ? Array.from(hints)[0] : null;
 }
-function reconcileDailyTotal(rows, key, expected) {
-  if (rows.length === 0) {
-    return;
+async function probeRuntimeCandidate(adapter, options) {
+  const sources = await adapter.detectSources(options);
+  return {
+    adapter,
+    sources,
+    usable: sources.length > 0
+  };
+}
+function buildResolvedDoctorNotes(adapter, sources) {
+  if (sources.length === 0) {
+    return adapter.noSourceNotes;
   }
-  const actual = round5(
-    rows.reduce((sum, row) => sum + (typeof row[key] === "number" ? row[key] : 0), 0)
-  );
-  const delta = round5(expected - actual);
-  if (delta === 0) {
-    return;
+  const notes = [];
+  if (sources.some((source) => source.kind === "gateway")) {
+    notes.push(adapter.gatewayNote);
   }
-  const last = rows[rows.length - 1];
-  const current = last[key];
-  if (typeof current === "number") {
-    last[key] = round5(current + delta);
+  if (sources.some((source) => source.kind === "sessions")) {
+    notes.push(adapter.sessionNote);
   }
+  return notes;
 }
-function buildSpendByDay(runs) {
-  const days = buildObservedUtcDayRange(runs);
-  if (days.length === 0) {
-    return [];
-  }
-  const byDay = new Map(
-    days.map((day) => [
-      day,
-      { date: day, observedSpendUsd: 0, estimatedSpendUsd: 0, callCount: 0 }
-    ])
-  );
-  for (const run2 of runs) {
-    for (const call of run2.calls) {
-      const day = toUtcDay(call.timestamp);
-      if (!day) {
-        continue;
-      }
-      const bucket = byDay.get(day);
-      if (!bucket) {
-        continue;
-      }
-      bucket.callCount += 1;
-      if (call.costSource === "observed") {
-        bucket.observedSpendUsd += call.costUsd;
-      } else if (call.costSource === "estimated") {
-        bucket.estimatedSpendUsd += call.costUsd;
-      }
-    }
-  }
-  const rows = days.map((day) => {
-    const bucket = byDay.get(day);
-    const observedSpendUsd = round5(bucket?.observedSpendUsd ?? 0);
-    const estimatedSpendUsd = round5(bucket?.estimatedSpendUsd ?? 0);
+function buildResolvedDoctorReport(adapter, sources) {
+  return {
+    canAudit: sources.length > 0,
+    mode: sources.length > 0 ? "resolved" : "none",
+    runtime: sources.length > 0 ? adapter.runtime : null,
+    sources,
+    defaults: [adapter.defaultPaths()],
+    notes: buildResolvedDoctorNotes(adapter, sources)
+  };
+}
+function buildAutoNoDataDoctorReport(candidates) {
+  return {
+    canAudit: false,
+    mode: "none",
+    runtime: null,
+    sources: candidates.flatMap((candidate) => candidate.sources),
+    defaults: Object.values(RUNTIME_ADAPTERS).map((adapter) => adapter.defaultPaths()),
+    notes: [
+      "No supported local runtime sources were detected.",
+      "Auto-detection checked both OpenClaw and Hermes local defaults.",
+      "Use --runtime openclaw or --runtime hermes with --log-file / --sessions-dir when you want to point Xerg at explicit local paths."
+    ]
+  };
+}
+function buildAutoAmbiguousDoctorReport(candidates) {
+  return {
+    canAudit: false,
+    mode: "ambiguous",
+    runtime: null,
+    sources: candidates.flatMap((candidate) => candidate.sources),
+    defaults: Object.values(RUNTIME_ADAPTERS).map((adapter) => adapter.defaultPaths()),
+    notes: [
+      "Both OpenClaw and Hermes local sources were detected.",
+      "Re-run doctor with --runtime openclaw or --runtime hermes to choose the local runtime explicitly."
+    ]
+  };
+}
+function buildExplicitNoDataError(options, hintedRuntime) {
+  const commandPrefix = options.commandPrefix ?? "xerg";
+  if (hintedRuntime) {
+    return getRuntimeAdapter(hintedRuntime).noDataError(commandPrefix);
+  }
+  return `No supported local runtime sources were detected. Run \`${commandPrefix} doctor\`, or use --runtime openclaw / --runtime hermes with --log-file / --sessions-dir.`;
+}
+function buildExplicitNoDataDoctorReport(candidates, hintedRuntime) {
+  if (hintedRuntime) {
+    const adapter = getRuntimeAdapter(hintedRuntime);
     return {
-      date: day,
-      observedSpendUsd,
-      estimatedSpendUsd,
-      spendUsd: round5(observedSpendUsd + estimatedSpendUsd),
-      callCount: bucket?.callCount ?? 0
+      canAudit: false,
+      mode: "none",
+      runtime: null,
+      sources: [],
+      defaults: [adapter.defaultPaths()],
+      notes: [
+        `No ${adapter.productName} sources were detected from the provided local paths.`,
+        `Verify --log-file / --sessions-dir and re-run doctor with --runtime ${adapter.runtime} if needed.`
+      ]
     };
-  });
-  reconcileDailyTotal(
-    rows,
-    "observedSpendUsd",
-    round5(runs.reduce((sum, run2) => sum + run2.observedCostUsd, 0))
-  );
-  reconcileDailyTotal(
-    rows,
-    "estimatedSpendUsd",
-    round5(runs.reduce((sum, run2) => sum + run2.estimatedCostUsd, 0))
-  );
-  for (const row of rows) {
-    row.spendUsd = round5(row.observedSpendUsd + row.estimatedSpendUsd);
   }
-  return rows;
+  return {
+    canAudit: false,
+    mode: "none",
+    runtime: null,
+    sources: candidates.flatMap((candidate) => candidate.sources),
+    defaults: Object.values(RUNTIME_ADAPTERS).map((adapter) => adapter.defaultPaths()),
+    notes: [
+      "No supported local runtime sources were detected from the provided local paths.",
+      "Verify --log-file / --sessions-dir and re-run doctor with --runtime openclaw or --runtime hermes if needed."
+    ]
+  };
 }
-function buildWasteByDay(wasteAttributions, days, expectedWasteUsd) {
-  if (days.length === 0) {
-    return [];
+function getRuntimeProductName(runtime) {
+  return getRuntimeAdapter(runtime).productName;
+}
+async function resolveRuntimeCandidates(options) {
+  return Promise.all(
+    Object.values(RUNTIME_ADAPTERS).map(
+      (adapter) => probeRuntimeCandidate(adapter, options)
+    )
+  );
+}
+async function resolveLocalAgentRuntime(options) {
+  const requestedRuntime = options.runtime ?? "auto";
+  if (requestedRuntime !== "auto") {
+    const adapter = getRuntimeAdapter(requestedRuntime);
+    const sources = await adapter.detectSources(options);
+    return {
+      adapter,
+      sources
+    };
   }
-  const byDay = new Map(days.map((day) => [day, 0]));
-  for (const attribution of wasteAttributions) {
-    const day = toUtcDay(attribution.timestamp);
-    if (!day || !byDay.has(day)) {
-      continue;
+  const candidates = await resolveRuntimeCandidates(options);
+  const usableCandidates = candidates.filter((candidate) => candidate.usable);
+  if (hasExplicitLocalPaths(options)) {
+    const hintedRuntime = inferRuntimeFromExplicitPaths(options);
+    if (hintedRuntime) {
+      const hintedCandidate = usableCandidates.find(
+        (candidate) => candidate.adapter.runtime === hintedRuntime
+      );
+      if (hintedCandidate) {
+        return {
+          adapter: hintedCandidate.adapter,
+          sources: hintedCandidate.sources
+        };
+      }
     }
-    byDay.set(day, (byDay.get(day) ?? 0) + attribution.wasteUsd);
+    if (usableCandidates.length === 0) {
+      throw new Error(buildExplicitNoDataError(options, hintedRuntime));
+    }
+    if (usableCandidates.length === 1) {
+      return {
+        adapter: usableCandidates[0].adapter,
+        sources: usableCandidates[0].sources
+      };
+    }
+    throw new Error(
+      "Could not determine whether the provided local files belong to OpenClaw or Hermes. Re-run with --runtime openclaw or --runtime hermes."
+    );
   }
-  const rows = days.map((day) => ({
-    date: day,
-    wasteUsd: round5(byDay.get(day) ?? 0)
-  }));
-  reconcileDailyTotal(rows, "wasteUsd", round5(expectedWasteUsd));
-  return rows;
+  if (usableCandidates.length === 0) {
+    throw new Error(
+      `No supported local runtime sources were detected. Run \`${options.commandPrefix ?? "xerg"} doctor\`, or use --runtime openclaw / --runtime hermes with --log-file / --sessions-dir.`
+    );
+  }
+  if (usableCandidates.length > 1) {
+    throw new Error(
+      "Both OpenClaw and Hermes local sources were detected. Re-run with --runtime openclaw or --runtime hermes."
+    );
+  }
+  return {
+    adapter: usableCandidates[0].adapter,
+    sources: usableCandidates[0].sources
+  };
 }
-
-// ../core/src/report/summary.ts
-function buildBreakdown(items) {
-  const buckets = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const current = buckets.get(item.key) ?? { spendUsd: 0, observedSpendUsd: 0, callCount: 0 };
-    current.spendUsd += item.spendUsd;
-    current.observedSpendUsd += item.observedSpendUsd;
-    current.callCount += 1;
-    buckets.set(item.key, current);
+async function doctorAgentRuntime(options) {
+  const requestedRuntime = options.runtime ?? "auto";
+  if (requestedRuntime !== "auto") {
+    options.onProgress?.(`Checking local ${getRuntimeProductName(requestedRuntime)} defaults...`);
+    const adapter = getRuntimeAdapter(requestedRuntime);
+    const sources = await adapter.detectSources(options);
+    options.onProgress?.(
+      sources.length > 0 ? `Detected ${sources.length} local source file${sources.length === 1 ? "" : "s"}.` : `No local ${adapter.productName} source files were detected.`
+    );
+    return buildResolvedDoctorReport(adapter, sources);
   }
-  return Array.from(buckets.entries()).map(([key, value]) => {
-    const observedShare = value.spendUsd === 0 ? 0 : value.observedSpendUsd / value.spendUsd;
+  options.onProgress?.("Checking local runtime defaults...");
+  const candidates = await resolveRuntimeCandidates(options);
+  const usableCandidates = candidates.filter((candidate) => candidate.usable);
+  const detectedCount = candidates.reduce((sum, candidate) => sum + candidate.sources.length, 0);
+  options.onProgress?.(
+    detectedCount > 0 ? `Detected ${detectedCount} local source file${detectedCount === 1 ? "" : "s"} across supported runtimes.` : "No local runtime source files were detected."
+  );
+  if (hasExplicitLocalPaths(options)) {
+    const hintedRuntime = inferRuntimeFromExplicitPaths(options);
+    if (hintedRuntime) {
+      const hintedCandidate = usableCandidates.find(
+        (candidate) => candidate.adapter.runtime === hintedRuntime
+      );
+      if (hintedCandidate) {
+        return buildResolvedDoctorReport(hintedCandidate.adapter, hintedCandidate.sources);
+      }
+    }
+    if (usableCandidates.length === 0) {
+      return buildExplicitNoDataDoctorReport(candidates, hintedRuntime);
+    }
+    if (usableCandidates.length === 1) {
+      return buildResolvedDoctorReport(usableCandidates[0].adapter, usableCandidates[0].sources);
+    }
     return {
-      key,
-      spendUsd: Number(value.spendUsd.toFixed(6)),
-      callCount: value.callCount,
-      observedShare: Number(observedShare.toFixed(4))
+      canAudit: false,
+      mode: "ambiguous",
+      runtime: null,
+      sources: candidates.flatMap((candidate) => candidate.sources),
+      defaults: Object.values(RUNTIME_ADAPTERS).map((adapter) => adapter.defaultPaths()),
+      notes: [
+        "Could not determine whether the provided local files belong to OpenClaw or Hermes.",
+        "Re-run doctor with --runtime openclaw or --runtime hermes to choose the local runtime explicitly."
+      ]
     };
-  }).sort((left, right) => right.spendUsd - left.spendUsd);
-}
-function buildAuditSummary(input) {
-  const callCount = input.runs.reduce((sum, run2) => sum + run2.calls.length, 0);
-  const totalSpendUsd = input.runs.reduce((sum, run2) => sum + run2.totalCostUsd, 0);
-  const observedSpendUsd = input.runs.reduce((sum, run2) => sum + run2.observedCostUsd, 0);
-  const estimatedSpendUsd = input.runs.reduce((sum, run2) => sum + run2.estimatedCostUsd, 0);
-  const wasteSpendUsd = input.findings.filter((finding) => finding.classification === "waste").reduce((sum, finding) => sum + finding.costImpactUsd, 0);
-  const opportunitySpendUsd = input.findings.filter((finding) => finding.classification === "opportunity").reduce((sum, finding) => sum + finding.costImpactUsd, 0);
-  const generatedAt = isoNow();
-  const spendByDay = buildSpendByDay(input.runs);
-  const observedDays = buildObservedUtcDayRange(input.runs);
-  return {
-    auditId: sha1(
-      `${generatedAt}:${input.runs.length}:${input.sources.map((source) => source.path).join("|")}`
-    ),
-    generatedAt,
-    comparisonKey: input.comparisonKeyOverride ?? buildComparisonKey({
-      sources: input.sources,
-      since: input.since
-    }),
-    comparison: null,
-    since: input.since,
-    runCount: input.runs.length,
-    callCount,
-    totalSpendUsd: Number(totalSpendUsd.toFixed(6)),
-    observedSpendUsd: Number(observedSpendUsd.toFixed(6)),
-    estimatedSpendUsd: Number(estimatedSpendUsd.toFixed(6)),
-    wasteSpendUsd: Number(wasteSpendUsd.toFixed(6)),
-    opportunitySpendUsd: Number(opportunitySpendUsd.toFixed(6)),
-    structuralWasteRate: Number(
-      (totalSpendUsd === 0 ? 0 : wasteSpendUsd / totalSpendUsd).toFixed(4)
-    ),
-    wasteByKind: buildTaxonomyBuckets(input.findings, "waste"),
-    opportunityByKind: buildTaxonomyBuckets(input.findings, "opportunity"),
-    spendByWorkflow: buildBreakdown(
-      input.runs.map((run2) => ({
-        key: run2.workflow,
-        spendUsd: run2.totalCostUsd,
-        observedSpendUsd: run2.observedCostUsd
-      }))
-    ),
-    spendByModel: buildBreakdown(
-      input.runs.flatMap(
-        (run2) => run2.calls.map((call) => ({
-          key: `${call.provider}/${call.model}`,
-          spendUsd: call.costUsd,
-          observedSpendUsd: call.costSource === "observed" ? call.costUsd : 0
-        }))
-      )
-    ),
-    spendByDay,
-    wasteByDay: buildWasteByDay(input.wasteAttributions, observedDays, wasteSpendUsd),
-    findings: input.findings,
-    notes: [
-      "Cost per outcome is intentionally unavailable in v0. Xerg is measuring waste intelligence only.",
-      "Opportunity findings are directional recommendations, not proven waste."
-    ],
-    sourceFiles: input.sources,
-    dbPath: input.dbPath
-  };
+  }
+  if (usableCandidates.length === 0) {
+    return buildAutoNoDataDoctorReport(candidates);
+  }
+  if (usableCandidates.length > 1) {
+    return buildAutoAmbiguousDoctorReport(usableCandidates);
+  }
+  return buildResolvedDoctorReport(usableCandidates[0].adapter, usableCandidates[0].sources);
 }
 
 // ../core/src/audit.ts
-async function doctorOpenClaw(options) {
-  return inspectOpenClawSources(options);
-}
 async function doctorCursorUsageCsv(options) {
   return inspectCursorUsageCsv(options);
 }
@@ -2376,25 +3073,25 @@ function hasPricingCoverageChange(current, baseline) {
   }
   return (current?.pricedCallCount ?? 0) !== (baseline?.pricedCallCount ?? 0) || (current?.unpricedCallCount ?? 0) !== (baseline?.unpricedCallCount ?? 0) || (current?.pricedTokenCount ?? 0) !== (baseline?.pricedTokenCount ?? 0) || (current?.unpricedTokenCount ?? 0) !== (baseline?.unpricedTokenCount ?? 0);
 }
-async function auditOpenClaw(options) {
-  options.onProgress?.("Scanning for OpenClaw source files...");
+async function auditResolvedRuntime(runtime, options, detectedSources) {
+  const adapter = getRuntimeAdapter(runtime);
+  options.onProgress?.(`Scanning for ${adapter.productName} source files...`);
   validateCompareOptions(options);
-  const sources = await detectOpenClawSources(options);
+  const sources = detectedSources ?? await adapter.detectSources(options);
   if (sources.length === 0) {
-    options.onProgress?.("No OpenClaw source files were detected.");
-    throw new Error(
-      `No OpenClaw sources were detected. Run \`${options.commandPrefix ?? "xerg"} doctor\` or provide --log-file / --sessions-dir.`
-    );
+    options.onProgress?.(`No ${adapter.productName} source files were detected.`);
+    throw new Error(adapter.noDataError(options.commandPrefix ?? "xerg"));
   }
   options.onProgress?.(`Detected ${sources.length} source file${sources.length === 1 ? "" : "s"}.`);
-  options.onProgress?.("Normalizing OpenClaw source files...");
-  const runs = normalizeOpenClawSources(sources, options.since);
+  options.onProgress?.(`Normalizing ${adapter.productName} source files...`);
+  const runs = adapter.normalizeSources(sources, options.since);
   options.onProgress?.(`Normalized ${runs.length} run${runs.length === 1 ? "" : "s"}.`);
   options.onProgress?.("Computing waste and savings findings...");
   const { findings, wasteAttributions } = buildFindings(runs);
   const dbPath = options.noDb ? void 0 : options.dbPath ?? getDefaultDbPath();
   options.onProgress?.("Building audit summary...");
   const summary = buildAuditSummary({
+    runtime,
     runs,
     findings,
     wasteAttributions,
@@ -2407,6 +3104,14 @@ async function auditOpenClaw(options) {
   persistLocalSnapshot(summary, runs, dbPath, options.onProgress);
   return summary;
 }
+async function auditAgentRuntime(options) {
+  const runtime = options.runtime ?? "auto";
+  if (runtime !== "auto") {
+    return auditResolvedRuntime(runtime, options);
+  }
+  const resolved = await resolveLocalAgentRuntime(options);
+  return auditResolvedRuntime(resolved.adapter.runtime, options, resolved.sources);
+}
 async function auditCursorUsageCsv(options) {
   options.onProgress?.("Reading Cursor usage CSV...");
   validateCompareOptions(options);
@@ -2430,6 +3135,7 @@ async function auditCursorUsageCsv(options) {
   const dbPath = options.noDb ? void 0 : options.dbPath ?? getDefaultDbPath();
   options.onProgress?.("Building audit summary...");
   const summary = buildAuditSummary({
+    runtime: "cursor",
     runs: normalized.runs,
     findings,
     wasteAttributions,
@@ -2709,25 +3415,36 @@ function renderDailyTrendRows(spendByDay, wasteByDay) {
 }
 function renderDoctorReport(report, options) {
   const commandPrefix = options?.commandPrefix ?? "xerg";
-  const nextSteps = report.canAudit ? [] : [
+  const status = report.mode === "resolved" && report.runtime ? `${report.runtime === "hermes" ? "Hermes" : "OpenClaw"} sources detected.` : report.mode === "ambiguous" ? "Multiple supported local runtimes detected." : "No supported local sources detected.";
+  const nextSteps = report.canAudit ? [] : report.mode === "ambiguous" ? [
+    "",
+    "## Next steps",
+    `- Inspect OpenClaw only: ${commandPrefix} doctor --runtime openclaw`,
+    `- Inspect Hermes only: ${commandPrefix} doctor --runtime hermes`,
+    `- Try explicit local paths: ${commandPrefix} doctor --runtime hermes --log-file /path/to/log --sessions-dir /path/to/sessions`
+  ] : [
     "",
     "## Next steps",
-    `- Try explicit local paths: ${commandPrefix} doctor --log-file /path/to/openclaw.log --sessions-dir /path/to/sessions`,
-    `- Inspect an SSH host: ${commandPrefix} doctor --remote user@host`,
-    `- Inspect a Railway service: ${commandPrefix} doctor --railway`,
+    `- Inspect OpenClaw locally: ${commandPrefix} doctor --runtime openclaw`,
+    `- Inspect Hermes locally: ${commandPrefix} doctor --runtime hermes`,
+    `- Try explicit local paths: ${commandPrefix} doctor --runtime hermes --log-file /path/to/log --sessions-dir /path/to/sessions`,
+    `- Inspect an SSH host for OpenClaw: ${commandPrefix} doctor --remote user@host`,
+    `- Inspect a Railway service for OpenClaw: ${commandPrefix} doctor --railway`,
     "- Remote audits still analyze locally after Xerg pulls the source files to your machine."
   ];
   const sections = [
     "# Xerg doctor",
     "",
-    report.canAudit ? "OpenClaw sources detected." : "No OpenClaw sources detected.",
+    status,
     "",
     "## Defaults",
-    `- gateway logs: ${report.defaults.gatewayPattern}`,
-    `- session files: ${report.defaults.sessionsPattern}`,
+    ...report.defaults.flatMap((defaults) => [
+      `- ${defaults.runtime === "hermes" ? "Hermes" : "OpenClaw"} gateway logs: ${defaults.gatewayPattern}`,
+      `- ${defaults.runtime === "hermes" ? "Hermes" : "OpenClaw"} session files: ${defaults.sessionsPattern}`
+    ]),
     "",
     "## Sources",
-    ...report.sources.length > 0 ? report.sources.map((source) => `- [${source.kind}] ${source.path}`) : ["- none"],
+    ...report.sources.length > 0 ? report.sources.map((source) => `- [${source.runtime}/${source.kind}] ${source.path}`) : ["- none"],
     "",
     "## Notes",
     ...report.notes.map((note) => `- ${note}`),
@@ -3120,17 +3837,17 @@ async function pushAudit(payload, config) {
 }
 
 // src/push/config.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 
 // src/auth/credentials.ts
-import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
 function getCredentialsPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join3(homedir2(), ".config");
-  return join3(xdgConfig, "xerg", "credentials.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join4(homedir3(), ".config");
+  return join4(xdgConfig, "xerg", "credentials.json");
 }
 function storeCredentials(token) {
   const credPath = getCredentialsPath();
@@ -3143,7 +3860,7 @@ function loadStoredCredentials() {
   const credPath = getCredentialsPath();
   try {
     if (!existsSync(credPath)) return null;
-    const raw = readFileSync3(credPath, "utf8");
+    const raw = readFileSync4(credPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.token || null;
   } catch {
@@ -3163,7 +3880,7 @@ function clearCredentials() {
 
 // src/push/config.ts
 var DEFAULT_API_URL = "https://api.xerg.ai";
-var CONFIG_PATH = join4(homedir3(), ".xerg", "config.json");
+var CONFIG_PATH = join5(homedir4(), ".xerg", "config.json");
 function loadPushConfig() {
   const envKey = process.env.XERG_API_KEY;
   const envUrl = process.env.XERG_API_URL;
@@ -3174,7 +3891,7 @@ function loadPushConfig() {
     };
   }
   try {
-    const raw = readFileSync4(CONFIG_PATH, "utf8");
+    const raw = readFileSync5(CONFIG_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.apiKey) {
       return {
@@ -3204,8 +3921,8 @@ import { hostname } from "os";
 import { execSync, spawnSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { mkdirSync as mkdirSync4, rmSync as rmSync2 } from "fs";
-import { homedir as homedir4, tmpdir } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir5, tmpdir } from "os";
+import { join as join6 } from "path";
 var DEFAULT_GATEWAY_DIR = "/tmp/openclaw";
 var DEFAULT_SESSIONS_DIR = "~/.openclaw/agents";
 function hashString(input) {
@@ -3214,7 +3931,7 @@ function hashString(input) {
 function sshArgs(source) {
   const args = [];
   if (source.identityFile) {
-    const resolved = source.identityFile.replace(/^~/, homedir4());
+    const resolved = source.identityFile.replace(/^~/, homedir5());
     args.push("-i", resolved);
   }
   args.push("-o", "BatchMode=yes", "-o", "ConnectTimeout=10");
@@ -3223,7 +3940,7 @@ function sshArgs(source) {
 function rsyncSshCommand(source) {
   const parts = ["ssh"];
   if (source.identityFile) {
-    const resolved = source.identityFile.replace(/^~/, homedir4());
+    const resolved = source.identityFile.replace(/^~/, homedir5());
     parts.push(`-i "${resolved}"`);
   }
   parts.push("-o BatchMode=yes", "-o ConnectTimeout=10");
@@ -3311,7 +4028,7 @@ function rsyncPull(opts) {
       if (status !== 0 || !stdout) return false;
       const files = stdout.split("\n").filter(Boolean);
       if (files.length === 0) return false;
-      const tmpFile = join5(tmpdir(), `xerg-filelist-${hashString(opts.remotePath)}`);
+      const tmpFile = join6(tmpdir(), `xerg-filelist-${hashString(opts.remotePath)}`);
       const relativePaths = files.map(
         (f) => f.startsWith(opts.remotePath) ? f.slice(opts.remotePath.length).replace(/^\//, "") : f
       );
@@ -3360,12 +4077,12 @@ function pullDirectory(opts) {
 }
 function resolveLocalPath(source, keepFiles) {
   if (keepFiles) {
-    const cacheDir = join5(homedir4(), ".xerg", "remote-cache", source.name);
+    const cacheDir = join6(homedir5(), ".xerg", "remote-cache", source.name);
     mkdirSync4(cacheDir, { recursive: true });
     return cacheDir;
   }
   const hash = hashString(`${source.host}:${Date.now()}`);
-  const tmpPath = join5(tmpdir(), `xerg-remote-${hash}`);
+  const tmpPath = join6(tmpdir(), `xerg-remote-${hash}`);
   mkdirSync4(tmpPath, { recursive: true });
   return tmpPath;
 }
@@ -3417,8 +4134,8 @@ async function pullRemoteFiles(opts) {
     useRsync ? "Local rsync detected. Xerg will prefer rsync and fall back to tar over SSH if needed." : "Local rsync not detected. Xerg will pull files with tar over SSH."
   );
   const localBase = resolveLocalPath(source, keepFiles);
-  const gatewayDir = join5(localBase, "gateway");
-  const sessionsDir = join5(localBase, "sessions");
+  const gatewayDir = join6(localBase, "gateway");
+  const sessionsDir = join6(localBase, "sessions");
   const remoteLogPath = source.logFile ?? DEFAULT_GATEWAY_DIR;
   const remoteSessionsPath = source.sessionsDir ?? DEFAULT_SESSIONS_DIR;
   const { stdout: expandedSessions } = sshExec(source, `eval echo ${remoteSessionsPath}`);
@@ -3610,8 +4327,8 @@ function formatBytes(bytes) {
 import { execSync as execSync2, spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { mkdirSync as mkdirSync5, rmSync as rmSync3 } from "fs";
-import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
-import { join as join6 } from "path";
+import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
+import { join as join7 } from "path";
 var DEFAULT_GATEWAY_DIR2 = "/tmp/openclaw";
 var DEFAULT_SESSIONS_DIR2 = "~/.openclaw/agents";
 var ALTERNATE_SESSION_PATHS = ["/data/.clawdbot/agents/main/sessions"];
@@ -3684,13 +4401,13 @@ function tarRailwayPull(opts) {
 }
 function resolveLocalPath2(source, keepFiles) {
   if (keepFiles) {
-    const cacheDir = join6(homedir5(), ".xerg", "remote-cache", source.name);
+    const cacheDir = join7(homedir6(), ".xerg", "remote-cache", source.name);
     mkdirSync5(cacheDir, { recursive: true });
     return cacheDir;
   }
   const identity = source.railway ? `railway:${source.railway.projectId}:${Date.now()}` : `${source.name}:${Date.now()}`;
   const hash = hashString2(identity);
-  const tmpPath = join6(tmpdir2(), `xerg-remote-${hash}`);
+  const tmpPath = join7(tmpdir2(), `xerg-remote-${hash}`);
   mkdirSync5(tmpPath, { recursive: true });
   return tmpPath;
 }
@@ -3761,8 +4478,8 @@ async function pullRemoteFilesRailway(opts) {
   }
   onProgress?.("Railway service reachable.");
   const localBase = resolveLocalPath2(source, keepFiles);
-  const gatewayDir = join6(localBase, "gateway");
-  const sessionsDir = join6(localBase, "sessions");
+  const gatewayDir = join7(localBase, "gateway");
+  const sessionsDir = join7(localBase, "sessions");
   const remoteLogPath = source.logFile ?? DEFAULT_GATEWAY_DIR2;
   onProgress?.("Checking Railway default paths for gateway logs and sessions...");
   const logCheck = checkRemotePath(remoteLogPath, target);
@@ -3991,13 +4708,13 @@ function formatBytes2(bytes) {
 }
 
 // src/transport/config.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve3 } from "path";
 function loadRemoteConfig(configPath) {
   const resolved = resolve3(configPath);
   let raw;
   try {
-    raw = readFileSync5(resolved, "utf8");
+    raw = readFileSync6(resolved, "utf8");
   } catch {
     throw new Error(`Cannot read remote config at ${resolved}`);
   }
@@ -4071,9 +4788,10 @@ function validateRailwayEntry(entry) {
 // src/source-meta.ts
 var RAILWAY_SOURCE_ID = "OpenClaw - Railway";
 function buildLocalPushSourceMeta(kind, localHost = hostname()) {
+  const productName = kind === "cursor" ? "Cursor" : kind === "hermes" ? "Hermes" : "OpenClaw";
   return {
     environment: "local",
-    sourceId: `${kind === "cursor" ? "Cursor" : "OpenClaw"} - ${localHost}`,
+    sourceId: `${productName} - ${localHost}`,
     sourceHost: localHost
   };
 }
@@ -4092,6 +4810,9 @@ function buildRemotePushSourceMeta(source) {
   };
 }
 function buildCachedPushSourceMeta(summary, localHost = hostname()) {
+  if (summary.runtime === "cursor") {
+    return buildLocalPushSourceMeta("cursor", localHost);
+  }
   const sourceFiles = summary.sourceFiles ?? [];
   const comparisonKey = summary.comparisonKey ?? "";
   if (sourceFiles.some((sourceFile) => sourceFile.kind === "cursor-usage-csv")) {
@@ -4112,6 +4833,9 @@ function buildCachedPushSourceMeta(summary, localHost = hostname()) {
       sourceHost: remoteHost
     };
   }
+  if (summary.runtime === "hermes") {
+    return buildLocalPushSourceMeta("hermes", localHost);
+  }
   return buildLocalPushSourceMeta("openclaw", localHost);
 }
 function isGeneratedRailwayName(name) {
@@ -4136,11 +4860,23 @@ function resolveRemoteHost(target) {
   return parsed.host || target;
 }
 
+// src/version.ts
+import { readFileSync as readFileSync7 } from "fs";
+function getCliVersion() {
+  try {
+    const packageJsonPath = new URL("../package.json", import.meta.url);
+    const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
+    return packageJson.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
 // src/commands/audit.ts
-var NO_DATA_PATTERN = /no openclaw sources were detected/i;
+var NO_DATA_PATTERN = /no (openclaw|hermes|supported local runtime) sources? were detected/i;
 async function auditOrNoData(...args) {
   try {
-    return await auditOpenClaw(...args);
+    return await auditAgentRuntime(...args);
   } catch (err) {
     if (err instanceof Error && NO_DATA_PATTERN.test(err.message)) {
       throw new NoDataError(err.message);
@@ -4153,7 +4889,9 @@ async function runAuditCommand(options) {
   if (options.dryRun && !options.push) {
     throw new Error("--dry-run requires --push.");
   }
+  validateRuntimeOption(options.runtime);
   validateCursorUsageCsvOptions(options);
+  validateHermesLocalOnly(options);
   const remoteFlags = [options.remote, options.remoteConfig, options.railway].filter(
     Boolean
   ).length;
@@ -4218,7 +4956,9 @@ async function runLocalAudit(options, logger) {
     checkThresholds(summary2, options);
     return;
   }
-  logger.verbose("Running a local audit.");
+  logger.verbose(
+    options.runtime ? `Running a local ${options.runtime === "hermes" ? "Hermes" : "OpenClaw"} audit.` : "Running a local runtime audit with auto-detection."
+  );
   if (options.logFile) {
     logger.verbose(`Using explicit local log file: ${options.logFile}`);
   }
@@ -4226,6 +4966,7 @@ async function runLocalAudit(options, logger) {
     logger.verbose(`Using explicit local sessions directory: ${options.sessionsDir}`);
   }
   const summary = await auditOrNoData({
+    runtime: options.runtime ?? "auto",
     logFile: options.logFile,
     sessionsDir: options.sessionsDir,
     since: options.since,
@@ -4237,16 +4978,27 @@ async function runLocalAudit(options, logger) {
   });
   renderOutput(summary, options);
   if (options.push) {
-    const meta = buildMeta(buildLocalPushSourceMeta("openclaw"));
+    const meta = buildMeta(buildLocalPushSourceMeta(summary.runtime));
     await handlePush(summary, meta, options);
   }
   checkThresholds(summary, options);
 }
+function validateRuntimeOption(runtime) {
+  if (!runtime) {
+    return;
+  }
+  if (runtime !== "openclaw" && runtime !== "hermes") {
+    throw new Error(
+      `Unsupported runtime "${runtime}". Use --runtime openclaw or --runtime hermes.`
+    );
+  }
+}
 function validateCursorUsageCsvOptions(options) {
   if (!options.cursorUsageCsv) {
     return;
   }
   const conflicts = [
+    options.runtime ? "--runtime" : null,
     options.logFile ? "--log-file" : null,
     options.sessionsDir ? "--sessions-dir" : null,
     options.remote ? "--remote" : null,
@@ -4263,6 +5015,27 @@ function validateCursorUsageCsvOptions(options) {
     throw new Error(`The --cursor-usage-csv flag cannot be combined with ${conflicts.join(", ")}.`);
   }
 }
+function validateHermesLocalOnly(options) {
+  if (options.runtime !== "hermes") {
+    return;
+  }
+  const conflicts = [
+    options.remote ? "--remote" : null,
+    options.remoteLogFile ? "--remote-log-file" : null,
+    options.remoteSessionsDir ? "--remote-sessions-dir" : null,
+    options.remoteConfig ? "--remote-config" : null,
+    options.keepRemoteFiles ? "--keep-remote-files" : null,
+    options.railway ? "--railway" : null,
+    options.railwayProject ? "--project" : null,
+    options.railwayEnvironment ? "--environment" : null,
+    options.railwayService ? "--service" : null
+  ].filter((flag) => flag !== null);
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Hermes remote transport is not supported yet. Remove ${conflicts.join(", ")} or switch to --runtime openclaw.`
+    );
+  }
+}
 function getComparisonKey(source) {
   if (source.transport === "railway") {
     return buildComparisonKeyForRailway(source);
@@ -4293,6 +5066,7 @@ async function runSingleRemoteAudit(source, options, logger) {
   try {
     const comparisonKeyOverride = getComparisonKey(source);
     const summary = await auditOrNoData({
+      runtime: "openclaw",
       logFile: pullResult.logFile,
       sessionsDir: pullResult.sessionsDir,
       since: options.since,
@@ -4343,6 +5117,7 @@ ${errorMessages}`);
     for (const { source, pullResult } of results) {
       const comparisonKeyOverride = getComparisonKey(source);
       const summary = await auditOrNoData({
+        runtime: "openclaw",
         logFile: pullResult.logFile,
         sessionsDir: pullResult.sessionsDir,
         since: options.since,
@@ -4406,18 +5181,9 @@ ${"\u2550".repeat(60)}
     }
   }
 }
-function readCliVersion() {
-  try {
-    const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
 function buildMeta(input) {
   return {
-    cliVersion: readCliVersion(),
+    cliVersion: getCliVersion(),
     sourceId: input.sourceId,
     sourceHost: input.sourceHost,
     environment: input.environment
@@ -4492,7 +5258,9 @@ function cleanupPullResult(pullResult, keepFiles) {
 // src/commands/doctor.ts
 async function runDoctorCommand(options) {
   const logger = createCliLogger({ verbose: options.verbose });
+  validateRuntimeOption2(options.runtime);
   validateCursorUsageCsvOptions2(options);
+  validateHermesLocalOnly2(options);
   if (options.railway) {
     logger.verbose("Inspecting Railway audit readiness.");
     const railwayTarget = buildRailwayTarget2(options);
@@ -4529,14 +5297,17 @@ async function runDoctorCommand(options) {
 `);
     return;
   }
-  logger.verbose("Inspecting local OpenClaw audit readiness.");
+  logger.verbose(
+    options.runtime ? `Inspecting local ${options.runtime === "hermes" ? "Hermes" : "OpenClaw"} audit readiness.` : "Inspecting local runtime audit readiness."
+  );
   if (options.logFile) {
     logger.verbose(`Using explicit local log file: ${options.logFile}`);
   }
   if (options.sessionsDir) {
     logger.verbose(`Using explicit local sessions directory: ${options.sessionsDir}`);
   }
-  const report = await doctorOpenClaw({
+  const report = await doctorAgentRuntime({
+    runtime: options.runtime ?? "auto",
     logFile: options.logFile,
     sessionsDir: options.sessionsDir,
     onProgress: logger.verbose
@@ -4544,11 +5315,22 @@ async function runDoctorCommand(options) {
   process.stdout.write(`${renderDoctorReport(report, { commandPrefix: options.commandPrefix })}
 `);
 }
+function validateRuntimeOption2(runtime) {
+  if (!runtime) {
+    return;
+  }
+  if (runtime !== "openclaw" && runtime !== "hermes") {
+    throw new Error(
+      `Unsupported runtime "${runtime}". Use --runtime openclaw or --runtime hermes.`
+    );
+  }
+}
 function validateCursorUsageCsvOptions2(options) {
   if (!options.cursorUsageCsv) {
     return;
   }
   const conflicts = [
+    options.runtime ? "--runtime" : null,
     options.logFile ? "--log-file" : null,
     options.sessionsDir ? "--sessions-dir" : null,
     options.remote ? "--remote" : null,
@@ -4563,6 +5345,25 @@ function validateCursorUsageCsvOptions2(options) {
     throw new Error(`The --cursor-usage-csv flag cannot be combined with ${conflicts.join(", ")}.`);
   }
 }
+function validateHermesLocalOnly2(options) {
+  if (options.runtime !== "hermes") {
+    return;
+  }
+  const conflicts = [
+    options.remote ? "--remote" : null,
+    options.remoteLogFile ? "--remote-log-file" : null,
+    options.remoteSessionsDir ? "--remote-sessions-dir" : null,
+    options.railway ? "--railway" : null,
+    options.railwayProject ? "--project" : null,
+    options.railwayEnvironment ? "--environment" : null,
+    options.railwayService ? "--service" : null
+  ].filter((flag) => flag !== null);
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Hermes remote transport is not supported yet. Remove ${conflicts.join(", ")} or switch to --runtime openclaw.`
+    );
+  }
+}
 function buildRailwayTarget2(options) {
   if (options.railwayProject && options.railwayEnvironment && options.railwayService) {
     return {
@@ -4798,7 +5599,7 @@ function runLogoutCommand() {
 }
 
 // src/commands/push.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 async function runPushCommand(options) {
   const payload = options.file ? loadPayloadFromFile(options.file) : loadPayloadFromCache();
   if (options.dryRun) {
@@ -4822,7 +5623,7 @@ async function runPushCommand(options) {
 function loadPayloadFromFile(filePath) {
   let raw;
   try {
-    raw = readFileSync7(filePath, "utf8");
+    raw = readFileSync8(filePath, "utf8");
   } catch {
     throw new Error(`Cannot read file: ${filePath}`);
   }
@@ -4863,19 +5664,10 @@ function loadPayloadFromCache() {
   );
   return toWirePayload(latest, meta);
 }
-function readCliVersion2() {
-  try {
-    const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
 function buildMeta2(summary) {
   const sourceMeta = buildCachedPushSourceMeta(summary);
   return {
-    cliVersion: readCliVersion2(),
+    cliVersion: getCliVersion(),
     sourceId: sourceMeta.sourceId,
     sourceHost: sourceMeta.sourceHost,
     environment: sourceMeta.environment
@@ -4886,14 +5678,14 @@ function buildMeta2(summary) {
 function renderRootHelp(version, display) {
   return `${display.name} ${version}
 
-Waste intelligence for OpenClaw workflows and local Cursor usage CSVs.
+Waste intelligence for OpenClaw and Hermes workflows plus local Cursor usage CSVs.
 
 Usage:
   ${formatCommand("<command> [options]", display.prefix)}
 
 Commands:
-  audit    Analyze OpenClaw logs or a local Cursor usage CSV.
-  doctor   Inspect OpenClaw sources or a local Cursor usage CSV.
+  audit    Analyze OpenClaw or Hermes logs, or a local Cursor usage CSV.
+  doctor   Inspect OpenClaw or Hermes sources, or a local Cursor usage CSV.
   push     Push a cached audit snapshot to the Xerg API.
   login    Authenticate with the Xerg API via browser.
   logout   Remove stored Xerg API credentials.
@@ -4906,14 +5698,15 @@ Global options:
 function renderAuditHelp(commandPrefix) {
   return `${formatCommand("audit", commandPrefix)}
 
-Analyze OpenClaw logs or a local Cursor usage CSV and produce an audit report.
+Analyze OpenClaw or Hermes logs, or a local Cursor usage CSV, and produce an audit report.
 
 Usage:
   ${formatCommand("audit [options]", commandPrefix)}
 
 Options:
-  --log-file <path>           Explicit OpenClaw gateway log file to analyze
-  --sessions-dir <path>       Explicit OpenClaw sessions directory to analyze
+  --runtime <name>            Local runtime to inspect: openclaw or hermes
+  --log-file <path>           Explicit local gateway log file to analyze
+  --sessions-dir <path>       Explicit local sessions directory to analyze
   --cursor-usage-csv <path>   Local Cursor usage CSV export to analyze
   --since <duration>          Look back window such as 24h, 7d, or 30m
   --compare                   Compare this audit to the newest compatible prior local snapshot
@@ -4922,7 +5715,7 @@ Options:
   --db <path>                 Custom SQLite database path
   --no-db                     Skip local persistence
 
-Remote options (SSH):
+Remote options (SSH, OpenClaw only):
   --remote <user@host>        SSH target in user@host or user@host:port format
   --remote-log-file <path>    Override the default gateway log path on the remote host
   --remote-sessions-dir <path>  Override the default sessions directory on the remote host
@@ -4932,7 +5725,7 @@ Remote options (SSH):
 Prerequisites:
   SSH remote audits require ssh and rsync on your PATH.
 
-Railway options:
+Railway options (OpenClaw only):
   --railway                   Audit a Railway service (uses linked project by default)
   --project <id>              Railway project ID
   --environment <id>          Railway environment ID
@@ -4975,25 +5768,26 @@ Authentication:
 function renderDoctorHelp(commandPrefix) {
   return `${formatCommand("doctor", commandPrefix)}
 
-Inspect OpenClaw sources or a local Cursor usage CSV before you audit.
+Inspect OpenClaw or Hermes sources, or a local Cursor usage CSV, before you audit.
 
 Usage:
   ${formatCommand("doctor [options]", commandPrefix)}
 
 Options:
-  --log-file <path>           Explicit OpenClaw gateway log file to inspect
-  --sessions-dir <path>       Explicit OpenClaw sessions directory to inspect
+  --runtime <name>            Local runtime to inspect: openclaw or hermes
+  --log-file <path>           Explicit local gateway log file to inspect
+  --sessions-dir <path>       Explicit local sessions directory to inspect
   --cursor-usage-csv <path>   Local Cursor usage CSV export to inspect
   --verbose                   Print progress updates to stderr while doctor runs
 
-Remote options (SSH):
+Remote options (SSH, OpenClaw only):
   --remote <user@host>        SSH target in user@host or user@host:port format
   --remote-log-file <path>    Override the default gateway log path on the remote host
   --remote-sessions-dir <path>  Override the default sessions directory on the remote host
 
   SSH checks require ssh and rsync on your PATH.
 
-Railway options:
+Railway options (OpenClaw only):
   --railway                   Check a Railway service (uses linked project by default)
   --project <id>              Railway project ID
   --environment <id>          Railway environment ID
@@ -5006,7 +5800,7 @@ Railway options:
 }
 
 // src/index.ts
-var VERSION = readVersion();
+var VERSION = getCliVersion();
 var argv = process.argv.slice(2);
 var commandDisplay = resolveCommandDisplay();
 var command = argv[0];
@@ -5077,6 +5871,10 @@ function parseAuditOptions(raw) {
         options.logFile = readValue(arg, argv2[index + 1]);
         index += 1;
         break;
+      case "--runtime":
+        options.runtime = readValue(arg, argv2[index + 1]);
+        index += 1;
+        break;
       case "--sessions-dir":
         options.sessionsDir = readValue(arg, argv2[index + 1]);
         index += 1;
@@ -5205,6 +6003,10 @@ function parseDoctorOptions(raw) {
         options.logFile = readValue(arg, argv2[index + 1]);
         index += 1;
         break;
+      case "--runtime":
+        options.runtime = readValue(arg, argv2[index + 1]);
+        index += 1;
+        break;
       case "--sessions-dir":
         options.sessionsDir = readValue(arg, argv2[index + 1]);
         index += 1;
@@ -5280,9 +6082,4 @@ function readFloat(flag, value) {
 function colorError(message) {
   return process.stderr.isTTY ? styleText2("red", message) : message;
 }
-function readVersion() {
-  const packageJsonPath = new URL("../package.json", import.meta.url);
-  const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
-  return packageJson.version ?? "0.0.0";
-}
 //# sourceMappingURL=index.js.map