@xerg/cli 0.2.0 → 0.4.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;
-      }
-    }
+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);
   }
-  const rows = days.map((day) => {
-    const bucket = byDay.get(day);
-    const observedSpendUsd = round5(bucket?.observedSpendUsd ?? 0);
-    const estimatedSpendUsd = round5(bucket?.estimatedSpendUsd ?? 0);
+  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 [];
-  }
-  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;
+function getRuntimeProductName(runtime) {
+  return getRuntimeAdapter(runtime).productName;
 }
-
-// ../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;
+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 {
-      key,
-      spendUsd: Number(value.spendUsd.toFixed(6)),
-      callCount: value.callCount,
-      observedShare: Number(observedShare.toFixed(4))
+      adapter,
+      sources
     };
-  }).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
+  }
+  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
+        };
+      }
+    }
+    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."
+    );
+  }
+  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
   };
 }
+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);
+  }
+  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 {
+      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."
+      ]
+    };
+  }
+  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,23 +3880,25 @@ 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;
   if (envKey) {
     return {
       apiKey: envKey,
-      apiUrl: envUrl || DEFAULT_API_URL
+      apiUrl: envUrl || DEFAULT_API_URL,
+      source: "env"
     };
   }
   try {
-    const raw = readFileSync4(CONFIG_PATH, "utf8");
+    const raw = readFileSync5(CONFIG_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.apiKey) {
       return {
         apiKey: parsed.apiKey,
-        apiUrl: envUrl || parsed.apiUrl || DEFAULT_API_URL
+        apiUrl: envUrl || parsed.apiUrl || DEFAULT_API_URL,
+        source: "config"
       };
     }
   } catch {
@@ -3188,7 +3907,8 @@ function loadPushConfig() {
   if (storedToken) {
     return {
       apiKey: storedToken,
-      apiUrl: envUrl || DEFAULT_API_URL
+      apiUrl: envUrl || DEFAULT_API_URL,
+      source: "stored"
     };
   }
   throw new Error(
@@ -3204,8 +3924,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 +3934,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 +3943,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 +4031,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 +4080,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 +4137,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 +4330,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 +4404,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 +4481,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 +4711,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 +4791,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 +4813,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 +4836,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 +4863,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 +4892,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 +4959,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 +4969,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 +4981,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 +5018,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 +5069,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 +5120,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,
@@ -4390,48 +5168,274 @@ ${"\u2550".repeat(60)}
         process.stderr.write(`  ${source.name}: ${error}
 `);
       }
-    }
-    if (options.push) {
-      for (const { source, summary } of summaries) {
-        const meta = buildMeta(buildRemotePushSourceMeta(source));
-        await handlePush(summary, meta, options);
+    }
+    if (options.push) {
+      for (const { source, summary } of summaries) {
+        const meta = buildMeta(buildRemotePushSourceMeta(source));
+        await handlePush(summary, meta, options);
+      }
+    }
+    for (const { summary } of summaries) {
+      checkThresholds(summary, options);
+    }
+  } finally {
+    for (const { pullResult } of results) {
+      cleanupPullResult(pullResult, options.keepRemoteFiles);
+    }
+  }
+}
+function buildMeta(input) {
+  return {
+    cliVersion: getCliVersion(),
+    sourceId: input.sourceId,
+    sourceHost: input.sourceHost,
+    environment: input.environment
+  };
+}
+async function handlePush(summary, meta, options) {
+  const payload = toWirePayload(summary, meta);
+  if (options.dryRun) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return;
+  }
+  const config = loadPushConfig();
+  process.stderr.write(`Pushing audit ${summary.auditId} to ${config.apiUrl}...
+`);
+  const result = await pushAudit(payload, config);
+  if (result.ok) {
+    process.stderr.write(`Pushed successfully (audit: ${result.auditId}).
+`);
+  } else {
+    const statusInfo = result.status > 0 ? ` (HTTP ${result.status})` : "";
+    throw new Error(`Push failed${statusInfo}: ${result.message}`);
+  }
+}
+function renderOutput(summary, options) {
+  if (options.push && options.dryRun) {
+    return;
+  }
+  if (options.json) {
+    const recommendations = buildRecommendations(summary);
+    const output = { ...summary, recommendations };
+    process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+    return;
+  }
+  if (options.markdown) {
+    process.stdout.write(`${renderMarkdownSummary(summary)}
+`);
+    return;
+  }
+  process.stdout.write(`${renderTerminalSummary(summary)}
+`);
+}
+function checkThresholds(summary, options) {
+  const breaches = [];
+  if (options.failAboveWasteRate !== void 0 && summary.structuralWasteRate > options.failAboveWasteRate) {
+    breaches.push(
+      `Structural waste rate ${(summary.structuralWasteRate * 100).toFixed(1)}% exceeds threshold ${(options.failAboveWasteRate * 100).toFixed(1)}%`
+    );
+  }
+  if (options.failAboveWasteUsd !== void 0 && summary.wasteSpendUsd > options.failAboveWasteUsd) {
+    breaches.push(
+      `Waste spend $${summary.wasteSpendUsd.toFixed(2)} exceeds threshold $${options.failAboveWasteUsd.toFixed(2)}`
+    );
+  }
+  if (breaches.length > 0) {
+    process.stderr.write(`
+Threshold exceeded:
+${breaches.map((b) => `  ${b}`).join("\n")}
+`);
+    process.exitCode = 3;
+  }
+}
+function cleanupPullResult(pullResult, keepFiles) {
+  if (keepFiles) return;
+  try {
+    rmSync4(pullResult.localPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/commands/login.ts
+import { styleText } from "util";
+var DEFAULT_AUTH_URL = "https://xerg.ai/dashboard/settings";
+var DEFAULT_API_URL2 = "https://api.xerg.ai";
+var POLL_INTERVAL_MS = 2e3;
+var POLL_TIMEOUT_MS = 3e5;
+async function runLoginCommand() {
+  const existing = loadStoredCredentials();
+  if (existing) {
+    process.stderr.write(
+      `Already logged in. Credentials stored at ${getCredentialsPath()}.
+Run ${colorBold(formatCommand("logout"))} first to re-authenticate.
+`
+    );
+    return;
+  }
+  const data = await performDeviceLogin();
+  storeCredentials(data.token);
+  const teamInfo = data.teamName ? ` (team: ${data.teamName})` : "";
+  process.stderr.write(
+    `
+${colorSuccess("Authenticated successfully")}${teamInfo}.
+Credentials saved to ${getCredentialsPath()}.
+`
+  );
+}
+async function performDeviceLogin() {
+  const apiUrl = process.env.XERG_API_URL || DEFAULT_API_URL2;
+  const deviceCodeUrl = `${apiUrl}/v1/auth/device-code`;
+  let deviceResponse;
+  try {
+    const res = await fetch(deviceCodeUrl, { method: "POST" });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    }
+    deviceResponse = await res.json();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    throw new Error(
+      `Could not start device auth flow (${msg}).
+
+Alternative: create an API key at ${DEFAULT_AUTH_URL}
+and set XERG_API_KEY in your environment.`
+    );
+  }
+  const verifyUrl = deviceResponse.verificationUrl || DEFAULT_AUTH_URL;
+  const pollInterval = (deviceResponse.interval || 2) * 1e3;
+  process.stderr.write(
+    `
+Open this URL in your browser to authenticate:
+
+  ${colorBold(verifyUrl)}
+
+`
+  );
+  if (deviceResponse.userCode) {
+    process.stderr.write(`Your code: ${colorBold(deviceResponse.userCode)}
+
+`);
+  }
+  process.stderr.write("Waiting for authentication...\n");
+  await openBrowser(verifyUrl);
+  const tokenUrl = `${apiUrl}/v1/auth/device-token`;
+  const startTime = Date.now();
+  while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+    await sleep(Math.max(pollInterval, POLL_INTERVAL_MS));
+    try {
+      const res = await fetch(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode: deviceResponse.deviceCode })
+      });
+      if (res.status === 200) {
+        return await res.json();
+      }
+      if (res.status === 428) {
+        continue;
+      }
+      if (res.status === 410) {
+        throw new Error(`Device code expired. Please run \`${formatCommand("login")}\` again.`);
+      }
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error || `Unexpected response: HTTP ${res.status}`);
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("expired") || err.message.includes("Unexpected"))) {
+        throw err;
       }
     }
-    for (const { summary } of summaries) {
-      checkThresholds(summary, options);
-    }
-  } finally {
-    for (const { pullResult } of results) {
-      cleanupPullResult(pullResult, options.keepRemoteFiles);
-    }
   }
+  throw new Error(`Authentication timed out. Please run \`${formatCommand("login")}\` again.`);
+}
+async function openBrowser(url) {
+  const { exec } = await import("child_process");
+  const { platform: platform2 } = await import("os");
+  const commands = {
+    darwin: "open",
+    win32: "start",
+    linux: "xdg-open"
+  };
+  const cmd = commands[platform2()];
+  if (!cmd) return;
+  return new Promise((resolve4) => {
+    exec(`${cmd} ${JSON.stringify(url)}`, () => resolve4());
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function colorBold(text) {
+  return process.stderr.isTTY ? styleText("bold", text) : text;
+}
+function colorSuccess(text) {
+  return process.stderr.isTTY ? styleText("green", text) : text;
 }
-function readCliVersion() {
+
+// src/cloud.ts
+function loadPushConfigOrNull() {
   try {
-    const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
-    return pkg.version ?? "0.0.0";
+    return loadPushConfig();
   } catch {
-    return "0.0.0";
+    return null;
   }
 }
-function buildMeta(input) {
-  return {
-    cliVersion: readCliVersion(),
-    sourceId: input.sourceId,
-    sourceHost: input.sourceHost,
-    environment: input.environment
-  };
+async function authenticateAndLoadPushConfig() {
+  const data = await performDeviceLogin();
+  storeCredentials(data.token);
+  const teamInfo = data.teamName ? ` (team: ${data.teamName})` : "";
+  process.stderr.write(
+    `
+Authenticated successfully${teamInfo}.
+Credentials saved to ${getCredentialsPath()}.
+`
+  );
+  return loadPushConfig();
 }
-async function handlePush(summary, meta, options) {
-  const payload = toWirePayload(summary, meta);
+function renderCloudDisclaimer() {
+  return [
+    "Xerg Cloud sync and hosted MCP are optional paid workspace features.",
+    "Local audits and compare stay free, and you can keep using Xerg locally if you skip this step."
+  ].join("\n");
+}
+function renderMcpCredentialSourceMessage(config) {
+  if (config.source === "stored") {
+    return "Using your stored login token. If hosted MCP requires a workspace API key, create one at xerg.ai/dashboard/settings and set XERG_API_KEY.";
+  }
+  return "Using your workspace API key.";
+}
+
+// src/prompts.ts
+import { confirm, select } from "@inquirer/prompts";
+function hasPromptTty() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function promptConfirm(message, defaultValue = true) {
+  return confirm({
+    message,
+    default: defaultValue
+  });
+}
+async function promptSelect(message, choices) {
+  return select({
+    message,
+    choices
+  });
+}
+
+// src/commands/push.ts
+import { readFileSync as readFileSync8 } from "fs";
+async function runPushCommand(options) {
+  const payload = options.file ? loadPayloadFromFile(options.file) : loadLatestCachedAuditPayload();
   if (options.dryRun) {
     process.stdout.write(`${JSON.stringify(payload, null, 2)}
 `);
     return;
   }
   const config = loadPushConfig();
-  process.stderr.write(`Pushing audit ${summary.auditId} to ${config.apiUrl}...
+  const auditId = payload.summary.auditId;
+  process.stderr.write(`Pushing audit ${auditId} to ${config.apiUrl}...
 `);
   const result = await pushAudit(payload, config);
   if (result.ok) {
@@ -4442,57 +5446,166 @@ async function handlePush(summary, meta, options) {
     throw new Error(`Push failed${statusInfo}: ${result.message}`);
   }
 }
-function renderOutput(summary, options) {
-  if (options.push && options.dryRun) {
-    return;
+function loadPayloadFromFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync8(filePath, "utf8");
+  } catch {
+    throw new Error(`Cannot read file: ${filePath}`);
   }
-  if (options.json) {
-    const recommendations = buildRecommendations(summary);
-    const output = { ...summary, recommendations };
-    process.stdout.write(`${JSON.stringify(output, null, 2)}
-`);
-    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`File is not valid JSON: ${filePath}`);
   }
-  if (options.markdown) {
-    process.stdout.write(`${renderMarkdownSummary(summary)}
-`);
-    return;
+  const payload = parsed;
+  if (!payload.version || !payload.summary || !payload.meta) {
+    throw new Error(
+      `File does not look like an AuditPushPayload (missing version, summary, or meta): ${filePath}`
+    );
   }
-  process.stdout.write(`${renderTerminalSummary(summary)}
-`);
+  return payload;
 }
-function checkThresholds(summary, options) {
-  const breaches = [];
-  if (options.failAboveWasteRate !== void 0 && summary.structuralWasteRate > options.failAboveWasteRate) {
-    breaches.push(
-      `Structural waste rate ${(summary.structuralWasteRate * 100).toFixed(1)}% exceeds threshold ${(options.failAboveWasteRate * 100).toFixed(1)}%`
+function loadLatestCachedAuditPayload() {
+  const dbPath = getDefaultDbPath();
+  let summaries;
+  try {
+    summaries = listStoredAuditSummaries(dbPath);
+  } catch {
+    throw new NoDataError(
+      `No local audit database found. Run \`${formatCommand("audit")}\` first, or use \`${formatCommand("push --file <path>")}\`.`
     );
   }
-  if (options.failAboveWasteUsd !== void 0 && summary.wasteSpendUsd > options.failAboveWasteUsd) {
-    breaches.push(
-      `Waste spend $${summary.wasteSpendUsd.toFixed(2)} exceeds threshold $${options.failAboveWasteUsd.toFixed(2)}`
+  if (summaries.length === 0) {
+    throw new NoDataError(
+      `No cached audit snapshots found. Run \`${formatCommand("audit")}\` first, or use \`${formatCommand("push --file <path>")}\`.`
     );
   }
-  if (breaches.length > 0) {
-    process.stderr.write(`
-Threshold exceeded:
-${breaches.map((b) => `  ${b}`).join("\n")}
+  const latest = summaries[0];
+  const meta = buildMeta2(latest);
+  process.stderr.write(
+    `Using most recent cached audit: ${latest.auditId} (${latest.generatedAt})
+`
+  );
+  return toWirePayload(latest, meta);
+}
+function buildMeta2(summary) {
+  const sourceMeta = buildCachedPushSourceMeta(summary);
+  return {
+    cliVersion: getCliVersion(),
+    sourceId: sourceMeta.sourceId,
+    sourceHost: sourceMeta.sourceHost,
+    environment: sourceMeta.environment
+  };
+}
+
+// src/commands/connect.ts
+async function runConnectCommand() {
+  await runConnectFlow();
+}
+async function runConnectFlow(options) {
+  if (!options?.skipDisclaimer) {
+    process.stderr.write(`${renderCloudDisclaimer()}
 `);
-    process.exitCode = 3;
   }
+  let config = loadPushConfigOrNull();
+  if (config) {
+    process.stderr.write("Xerg authentication detected.\n");
+  } else {
+    if (!hasPromptTty()) {
+      process.stderr.write(
+        `No Xerg authentication is configured, and ${formatCommand("connect")} needs an interactive terminal before it can start browser login.
+Run ${formatCommand("login")} from a TTY, or keep using local audits for free.
+`
+      );
+      process.exitCode = 1;
+      return false;
+    }
+    const shouldLogin = await promptConfirm("Sign in to Xerg Cloud now?", true);
+    if (!shouldLogin) {
+      process.stderr.write(
+        "Skipped Xerg Cloud setup. You can keep using local audits and compare without connecting.\n"
+      );
+      return false;
+    }
+    config = await authenticateAndLoadPushConfig();
+  }
+  if (!hasPromptTty()) {
+    if (!options?.auditSummary) {
+      process.stderr.write(
+        `Non-interactive mode skips the push prompt. Run ${formatCommand("push")} when you want to sync a cached audit.
+`
+      );
+    } else {
+      process.stderr.write(
+        `Authentication is ready. Run ${formatCommand("push")} later if you want to sync this audit.
+`
+      );
+    }
+    return true;
+  }
+  const shouldPush = await promptConfirm(
+    options?.auditSummary ? "Push this audit to Xerg Cloud?" : "Push your latest cached audit to Xerg Cloud?",
+    true
+  );
+  if (!shouldPush) {
+    process.stderr.write(
+      options?.auditSummary ? `Skipped push. Run ${formatCommand("push")} later if you want to sync a cached audit.
+` : `Skipped push. Run ${formatCommand("push")} when you want to sync a cached audit.
+`
+    );
+    return true;
+  }
+  const payload = options?.auditSummary ? toWirePayload(options.auditSummary, buildLocalMeta(options.auditSummary)) : loadStandalonePayload();
+  if (!payload) {
+    return true;
+  }
+  await pushResolvedPayload(payload, config ?? loadPushConfig());
+  return true;
 }
-function cleanupPullResult(pullResult, keepFiles) {
-  if (keepFiles) return;
+function buildLocalMeta(summary) {
+  const sourceMeta = buildLocalPushSourceMeta(summary.runtime);
+  return {
+    cliVersion: getCliVersion(),
+    sourceId: sourceMeta.sourceId,
+    sourceHost: sourceMeta.sourceHost,
+    environment: sourceMeta.environment
+  };
+}
+function loadStandalonePayload() {
   try {
-    rmSync4(pullResult.localPath, { recursive: true, force: true });
-  } catch {
+    return loadLatestCachedAuditPayload();
+  } catch (error) {
+    if (error instanceof NoDataError || error instanceof Error && error.name === "NoDataError") {
+      process.stderr.write(
+        `${error instanceof Error ? error.message : "No cached audit snapshots found."}
+`
+      );
+      return null;
+    }
+    throw error;
+  }
+}
+async function pushResolvedPayload(payload, config) {
+  process.stderr.write(`Pushing audit ${payload.summary.auditId} to ${config.apiUrl}...
+`);
+  const result = await pushAudit(payload, config);
+  if (result.ok) {
+    process.stderr.write(`Pushed successfully (audit: ${result.auditId}).
+`);
+    return;
   }
+  const statusInfo = result.status > 0 ? ` (HTTP ${result.status})` : "";
+  throw new Error(`Push failed${statusInfo}: ${result.message}`);
 }
 
 // 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 +5642,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 +5660,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 +5690,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 {
@@ -4673,247 +5819,335 @@ function renderRailwayDoctorReport(report) {
   return sections.join("\n");
 }
 
-// src/commands/login.ts
-import { styleText } from "util";
-var DEFAULT_AUTH_URL = "https://xerg.ai/dashboard/settings";
-var DEFAULT_API_URL2 = "https://api.xerg.ai";
-var POLL_INTERVAL_MS = 2e3;
-var POLL_TIMEOUT_MS = 3e5;
-async function runLoginCommand() {
-  const existing = loadStoredCredentials();
-  if (existing) {
+// src/commands/mcp-setup.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join8 } from "path";
+var HOSTED_MCP_URL = "https://mcp.xerg.ai/mcp";
+async function runMcpSetupCommand() {
+  await runMcpSetupFlow();
+}
+async function runMcpSetupFlow() {
+  let config = loadPushConfigOrNull();
+  if (!config) {
+    process.stderr.write(`${renderCloudDisclaimer()}
+`);
+    process.stderr.write("Hosted MCP requires Xerg Cloud authentication before client setup.\n");
+  }
+  if (!hasPromptTty()) {
     process.stderr.write(
-      `Already logged in. Credentials stored at ${getCredentialsPath()}.
-Run ${colorBold(formatCommand("logout"))} first to re-authenticate.
+      `${formatCommand("mcp-setup")} needs an interactive terminal so it can ask which MCP client you want to configure.
 `
     );
+    process.exitCode = 1;
     return;
   }
-  const apiUrl = process.env.XERG_API_URL || DEFAULT_API_URL2;
-  const deviceCodeUrl = `${apiUrl}/v1/auth/device-code`;
-  let deviceResponse;
-  try {
-    const res = await fetch(deviceCodeUrl, { method: "POST" });
-    if (!res.ok) {
-      throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+  if (!config) {
+    const shouldLogin = await promptConfirm("Authenticate with Xerg Cloud now?", true);
+    if (!shouldLogin) {
+      process.stderr.write(
+        `Skipped hosted MCP setup. Run ${formatCommand("mcp-setup")} when you're ready.
+`
+      );
+      return;
     }
-    deviceResponse = await res.json();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : "Unknown error";
-    throw new Error(
-      `Could not start device auth flow (${msg}).
-
-Alternative: create an API key at ${DEFAULT_AUTH_URL}
-and set XERG_API_KEY in your environment.`
+    config = await authenticateAndLoadPushConfig();
+  }
+  process.stderr.write(`${renderMcpCredentialSourceMessage(config)}
+`);
+  const client = await promptSelect("Which MCP client do you want to configure?", [
+    {
+      name: "Cursor",
+      value: "cursor",
+      description: "Project-scoped or global Cursor MCP config"
+    },
+    {
+      name: "Claude Code",
+      value: "claude-code",
+      description: "Project-scoped Claude Code MCP config"
+    },
+    {
+      name: "Other",
+      value: "other",
+      description: "Print the hosted HTTP MCP snippet for another client"
+    }
+  ]);
+  const snippet = JSON.stringify(buildHostedMcpConfig(config), null, 2);
+  if (client === "cursor") {
+    await handleCursorSetup(snippet, config);
+    return;
+  }
+  process.stdout.write(`${snippet}
+`);
+  if (client === "claude-code") {
+    process.stderr.write(
+      "Add this to `.mcp.json` in your project root, or import the same `mcpServers.xerg` config through Claude Code MCP settings.\n"
     );
+    return;
   }
-  const verifyUrl = deviceResponse.verificationUrl || DEFAULT_AUTH_URL;
-  const pollInterval = (deviceResponse.interval || 2) * 1e3;
   process.stderr.write(
-    `
-Open this URL in your browser to authenticate:
-
-  ${colorBold(verifyUrl)}
-
+    `Add this as a remote HTTP MCP server in your client. Endpoint: ${HOSTED_MCP_URL}
 `
   );
-  if (deviceResponse.userCode) {
-    process.stderr.write(`Your code: ${colorBold(deviceResponse.userCode)}
-
+}
+async function handleCursorSetup(snippet, config) {
+  const cursorDir = join8(process.cwd(), ".cursor");
+  const cursorConfigPath = join8(cursorDir, "mcp.json");
+  if (existsSync2(cursorDir)) {
+    const shouldWrite = await promptConfirm(
+      "Write a project-scoped Cursor MCP config to .cursor/mcp.json?",
+      true
+    );
+    if (shouldWrite) {
+      writeCursorConfig(cursorConfigPath, config);
+      process.stderr.write(`Wrote hosted MCP config to ${cursorConfigPath}.
 `);
-  }
-  process.stderr.write("Waiting for authentication...\n");
-  await openBrowser(verifyUrl);
-  const tokenUrl = `${apiUrl}/v1/auth/device-token`;
-  const startTime = Date.now();
-  while (Date.now() - startTime < POLL_TIMEOUT_MS) {
-    await sleep(Math.max(pollInterval, POLL_INTERVAL_MS));
-    try {
-      const res = await fetch(tokenUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ deviceCode: deviceResponse.deviceCode })
-      });
-      if (res.status === 200) {
-        const data = await res.json();
-        storeCredentials(data.token);
-        const teamInfo = data.teamName ? ` (team: ${data.teamName})` : "";
-        process.stderr.write(
-          `
-${colorSuccess("Authenticated successfully")}${teamInfo}.
-Credentials saved to ${getCredentialsPath()}.
-`
-        );
-        return;
-      }
-      if (res.status === 428) {
-        continue;
-      }
-      if (res.status === 410) {
-        throw new Error(`Device code expired. Please run \`${formatCommand("login")}\` again.`);
-      }
-      const body = await res.json().catch(() => ({}));
-      throw new Error(body.error || `Unexpected response: HTTP ${res.status}`);
-    } catch (err) {
-      if (err instanceof Error && (err.message.includes("expired") || err.message.includes("Unexpected"))) {
-        throw err;
-      }
+      return;
     }
   }
-  throw new Error(`Authentication timed out. Please run \`${formatCommand("login")}\` again.`);
+  process.stdout.write(`${snippet}
+`);
+  process.stderr.write(
+    "Add this to `.cursor/mcp.json` for a project-scoped Cursor config, or `~/.cursor/mcp.json` for a global Cursor config.\n"
+  );
 }
-async function openBrowser(url) {
-  const { exec } = await import("child_process");
-  const { platform: platform2 } = await import("os");
-  const commands = {
-    darwin: "open",
-    win32: "start",
-    linux: "xdg-open"
+function buildHostedMcpConfig(config) {
+  return {
+    mcpServers: {
+      xerg: {
+        type: "http",
+        url: HOSTED_MCP_URL,
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`
+        }
+      }
+    }
   };
-  const cmd = commands[platform2()];
-  if (!cmd) return;
-  return new Promise((resolve4) => {
-    exec(`${cmd} ${JSON.stringify(url)}`, () => resolve4());
-  });
-}
-function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
-}
-function colorBold(text) {
-  return process.stderr.isTTY ? styleText("bold", text) : text;
-}
-function colorSuccess(text) {
-  return process.stderr.isTTY ? styleText("green", text) : text;
 }
-
-// src/commands/logout.ts
-function runLogoutCommand() {
-  const removed = clearCredentials();
-  if (removed) {
-    process.stderr.write(`Credentials removed from ${getCredentialsPath()}.
-`);
-  } else {
-    process.stderr.write("No stored credentials found. Already logged out.\n");
+function writeCursorConfig(filePath, config) {
+  mkdirSync6(dirname3(filePath), { recursive: true });
+  let parsed = {};
+  if (existsSync2(filePath)) {
+    try {
+      parsed = JSON.parse(readFileSync9(filePath, "utf8"));
+    } catch {
+      throw new Error(`Cursor config is not valid JSON: ${filePath}`);
+    }
+  }
+  const existingServers = parsed.mcpServers;
+  if (existingServers && typeof existingServers !== "object") {
+    throw new Error(`Cursor config has an invalid "mcpServers" value: ${filePath}`);
   }
+  parsed.mcpServers = {
+    ...existingServers ?? {},
+    xerg: buildHostedMcpConfig(config).mcpServers.xerg
+  };
+  writeFileSync2(filePath, `${JSON.stringify(parsed, null, 2)}
+`);
 }
 
-// src/commands/push.ts
-import { readFileSync as readFileSync7 } from "fs";
-async function runPushCommand(options) {
-  const payload = options.file ? loadPayloadFromFile(options.file) : loadPayloadFromCache();
-  if (options.dryRun) {
-    process.stdout.write(`${JSON.stringify(payload, null, 2)}
-`);
+// src/commands/init.ts
+async function runInitCommand() {
+  if (!hasPromptTty()) {
+    process.stderr.write(
+      `${formatCommand("init")} is interactive in this release. Run ${formatCommand("audit")} directly when you need a non-interactive audit.
+`
+    );
+    process.exitCode = 1;
     return;
   }
-  const config = loadPushConfig();
-  const auditId = payload.summary.auditId;
-  process.stderr.write(`Pushing audit ${auditId} to ${config.apiUrl}...
-`);
-  const result = await pushAudit(payload, config);
-  if (result.ok) {
-    process.stderr.write(`Pushed successfully (audit: ${result.auditId}).
-`);
-  } else {
-    const statusInfo = result.status > 0 ? ` (HTTP ${result.status})` : "";
-    throw new Error(`Push failed${statusInfo}: ${result.message}`);
+  const candidates = await resolveRuntimeCandidates({ runtime: "auto" });
+  const usable = candidates.filter((candidate) => candidate.usable);
+  if (usable.length === 0) {
+    renderNoDataGuidance();
+    return;
   }
-}
-function loadPayloadFromFile(filePath) {
-  let raw;
-  try {
-    raw = readFileSync7(filePath, "utf8");
-  } catch {
-    throw new Error(`Cannot read file: ${filePath}`);
+  const runtime = await chooseRuntime(usable);
+  if (!runtime) {
+    return;
   }
-  let parsed;
   try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`File is not valid JSON: ${filePath}`);
-  }
-  const payload = parsed;
-  if (!payload.version || !payload.summary || !payload.meta) {
-    throw new Error(
-      `File does not look like an AuditPushPayload (missing version, summary, or meta): ${filePath}`
+    const summary = await auditAgentRuntime({
+      runtime,
+      commandPrefix: formatCommand("")
+    });
+    process.stdout.write(`${renderTerminalSummary(summary)}
+`);
+    process.stderr.write(
+      `
+Next: after you make a fix, run ${formatCommand("audit --compare")} to measure the delta.
+`
     );
-  }
-  return payload;
-}
-function loadPayloadFromCache() {
-  const dbPath = getDefaultDbPath();
-  let summaries;
-  try {
-    summaries = listStoredAuditSummaries(dbPath);
-  } catch {
-    throw new NoDataError(
-      `No local audit database found. Run \`${formatCommand("audit")}\` first, or use \`${formatCommand("push --file <path>")}\`.`
+    const existingAuth = loadPushConfigOrNull();
+    process.stderr.write(
+      `${existingAuth ? "Xerg Cloud authentication is already configured. You can optionally push this audit and set up hosted MCP next." : renderCloudDisclaimer()}
+`
+    );
+    const shouldConnect = await promptConfirm("Continue with optional Xerg Cloud setup?", true);
+    if (!shouldConnect) {
+      process.stderr.write(
+        `Skipped Xerg Cloud setup. Run ${formatCommand("connect")} or ${formatCommand("mcp-setup")} whenever you want the hosted follow-up.
+`
+      );
+      return;
+    }
+    const connected = await runConnectFlow({
+      skipDisclaimer: true,
+      auditSummary: summary
+    });
+    if (!connected) {
+      return;
+    }
+    const shouldSetupMcp = await promptConfirm("Set up hosted MCP now?", true);
+    if (!shouldSetupMcp) {
+      process.stderr.write(
+        `Skipped hosted MCP setup. Run ${formatCommand("mcp-setup")} when you're ready.
+`
+      );
+      return;
+    }
+    await runMcpSetupFlow();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    const productName = getRuntimeAdapter(runtime).productName;
+    process.stderr.write(
+      `${[
+        `${productName} audit failed: ${message}`,
+        `Try ${formatCommand(["doctor", "--runtime", runtime])} to inspect the detected paths first.`,
+        `Re-run ${formatCommand("audit --verbose")} for more detail.`
+      ].join("\n")}
+`
     );
+    process.exitCode = 1;
   }
-  if (summaries.length === 0) {
-    throw new NoDataError(
-      `No cached audit snapshots found. Run \`${formatCommand("audit")}\` first, or use \`${formatCommand("push --file <path>")}\`.`
+}
+async function chooseRuntime(candidates) {
+  if (candidates.length === 1) {
+    const candidate = candidates[0];
+    process.stderr.write(`${describeCandidate(candidate)}
+`);
+    const shouldAudit = await promptConfirm(
+      `Run your first ${candidate.adapter.productName} audit now?`,
+      true
     );
+    if (!shouldAudit) {
+      process.stderr.write(
+        `Skipped the first audit. Run ${formatCommand(["audit", "--runtime", candidate.adapter.runtime])} when you're ready.
+`
+      );
+      return null;
+    }
+    return candidate.adapter.runtime;
   }
-  const latest = summaries[0];
-  const meta = buildMeta2(latest);
+  return promptSelect("Choose the local runtime to audit first.", [
+    ...candidates.map((candidate) => ({
+      name: candidate.adapter.productName,
+      value: candidate.adapter.runtime,
+      description: describeSources(candidate)
+    }))
+  ]);
+}
+function describeCandidate(candidate) {
+  return `Found local ${candidate.adapter.productName} data (${describeSources(candidate)}).`;
+}
+function describeSources(candidate) {
+  const kinds = new Set(candidate.sources.map((source) => source.kind));
+  const details = [
+    kinds.has("gateway") ? "gateway logs" : null,
+    kinds.has("sessions") ? "session transcripts" : null
+  ].filter((detail) => detail !== null);
+  return details.join(" and ");
+}
+function renderNoDataGuidance() {
+  const openclawDefaults = getRuntimeAdapter("openclaw").defaultPaths();
+  const hermesDefaults = getRuntimeAdapter("hermes").defaultPaths();
   process.stderr.write(
-    `Using most recent cached audit: ${latest.auditId} (${latest.generatedAt})
+    `${[
+      "No local OpenClaw or Hermes data was detected in the default locations Xerg checked.",
+      "",
+      "Checked defaults:",
+      `- OpenClaw gateway logs: ${openclawDefaults.gatewayPattern}`,
+      `- OpenClaw session transcripts: ${openclawDefaults.sessionsPattern}`,
+      `- Hermes gateway logs: ${hermesDefaults.gatewayPattern}`,
+      `- Hermes session transcripts: ${hermesDefaults.sessionsPattern}`,
+      "",
+      "Next steps:",
+      `- Local OpenClaw paths: ${formatCommand("audit --runtime openclaw --log-file /path/to/openclaw.log")} or ${formatCommand("audit --runtime openclaw --sessions-dir /path/to/sessions")}`,
+      `- Local Hermes paths: ${formatCommand("audit --runtime hermes --log-file ~/.hermes/logs/agent.log")} or ${formatCommand("audit --runtime hermes --sessions-dir ~/.hermes/sessions")}`,
+      `- Remote OpenClaw only: ${formatCommand("audit --remote user@host")}`,
+      `- Railway OpenClaw only: ${formatCommand("audit --railway")}`
+    ].join("\n")}
 `
   );
-  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";
+
+// src/commands/logout.ts
+function runLogoutCommand() {
+  const removed = clearCredentials();
+  if (removed) {
+    process.stderr.write(`Credentials removed from ${getCredentialsPath()}.
+`);
+  } else {
+    process.stderr.write("No stored credentials found. Already logged out.\n");
   }
 }
-function buildMeta2(summary) {
-  const sourceMeta = buildCachedPushSourceMeta(summary);
-  return {
-    cliVersion: readCliVersion2(),
-    sourceId: sourceMeta.sourceId,
-    sourceHost: sourceMeta.sourceHost,
-    environment: sourceMeta.environment
-  };
-}
 
 // src/help.ts
 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.
 
 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.
+Getting started:
+  init       Detect local runtimes, run a first audit, and offer optional cloud follow-up.
+
+Audit and inspect:
+  audit    Analyze OpenClaw or Hermes logs, or a local Cursor usage CSV.
+  doctor   Inspect OpenClaw or Hermes sources, or a local Cursor usage CSV.
+
+Cloud:
+  connect    Authenticate and optionally push your latest audit to Xerg Cloud.
   push     Push a cached audit snapshot to the Xerg API.
   login    Authenticate with the Xerg API via browser.
   logout   Remove stored Xerg API credentials.
+  mcp-setup  Generate hosted MCP client configuration.
 
 Global options:
   -h, --help     Show help
   -v, --version  Show version
 `;
 }
+function renderInitHelp(commandPrefix) {
+  return `${formatCommand("init", commandPrefix)}
+
+Detect local OpenClaw or Hermes runtimes, run a first audit, and offer optional cloud follow-up.
+
+Usage:
+  ${formatCommand("init", commandPrefix)}
+
+Notes:
+  - Interactive only in v1
+  - Uses local runtime auto-detection
+  - Runs a first local audit with snapshot persistence enabled
+  - Offers optional Xerg Cloud connect and hosted MCP setup after a successful audit
+
+  -h, --help                  Show help
+`;
+}
 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 +6156,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 +6166,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
@@ -4968,32 +6202,33 @@ Options:
 
 Authentication:
   Set XERG_API_KEY in your environment, add "apiKey" to ~/.xerg/config.json,
-  or run \`${formatCommand("login", commandPrefix)}\` to authenticate via browser.
+  or run \`${formatCommand("connect", commandPrefix)}\` / \`${formatCommand("login", commandPrefix)}\` to authenticate via browser.
   Browser login stores a token at ~/.config/xerg/credentials.json by default.
 `;
 }
 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
@@ -5004,9 +6239,43 @@ Railway options:
   -h, --help                  Show help
 `;
 }
+function renderConnectHelp(commandPrefix) {
+  return `${formatCommand("connect", commandPrefix)}
+
+Authenticate with Xerg Cloud and optionally push the latest audit.
+
+Usage:
+  ${formatCommand("connect", commandPrefix)}
+
+Notes:
+  - Shows paid-workspace disclosure before hosted setup
+  - Reuses existing auth from XERG_API_KEY, ~/.xerg/config.json, or stored browser login
+  - Standalone non-interactive mode reports auth status and skips the push prompt
+  - When called after ${formatCommand("init", commandPrefix)}, it can push the in-memory audit directly
+
+  -h, --help                  Show help
+`;
+}
+function renderMcpSetupHelp(commandPrefix) {
+  return `${formatCommand("mcp-setup", commandPrefix)}
+
+Generate hosted MCP client configuration for Cursor, Claude Code, or another MCP client.
+
+Usage:
+  ${formatCommand("mcp-setup", commandPrefix)}
+
+Notes:
+  - Interactive in v1 because client selection is prompt-driven
+  - Uses the hosted MCP endpoint at https://mcp.xerg.ai/mcp
+  - Can write a project-scoped Cursor config when .cursor/ already exists
+  - Local audits and compare stay available even if you skip hosted MCP setup
+
+  -h, --help                  Show help
+`;
+}
 
 // src/index.ts
-var VERSION = readVersion();
+var VERSION = getCliVersion();
 var argv = process.argv.slice(2);
 var commandDisplay = resolveCommandDisplay();
 var command = argv[0];
@@ -5037,6 +6306,11 @@ async function run() {
     });
     return;
   }
+  if (command === "init") {
+    parseBareCommandOptions(argv.slice(1), renderInitHelp(commandDisplay.prefix), "init");
+    await runInitCommand();
+    return;
+  }
   if (command === "doctor") {
     const options = parseDoctorOptions(argv.slice(1));
     await runDoctorCommand({
@@ -5050,6 +6324,11 @@ async function run() {
     await runPushCommand(options);
     return;
   }
+  if (command === "connect") {
+    parseBareCommandOptions(argv.slice(1), renderConnectHelp(commandDisplay.prefix), "connect");
+    await runConnectCommand();
+    return;
+  }
   if (command === "login") {
     await runLoginCommand();
     return;
@@ -5058,10 +6337,31 @@ async function run() {
     runLogoutCommand();
     return;
   }
+  if (command === "mcp-setup") {
+    parseBareCommandOptions(argv.slice(1), renderMcpSetupHelp(commandDisplay.prefix), "mcp-setup");
+    await runMcpSetupCommand();
+    return;
+  }
   throw new Error(
     `Unknown command "${command}". Run \`${formatCommand("--help", commandDisplay.prefix)}\` to see available commands.`
   );
 }
+function parseBareCommandOptions(raw, helpText, commandName) {
+  const argv2 = expandEqualsArgs(raw);
+  for (const arg of argv2) {
+    switch (arg) {
+      case "--help":
+      case "-h":
+        process.stdout.write(helpText);
+        process.exit(0);
+        break;
+      default:
+        throw new Error(
+          `Unknown ${commandName} option "${arg}". Run \`${formatCommand([commandName, "--help"], commandDisplay.prefix)}\` for usage.`
+        );
+    }
+  }
+}
 function parseAuditOptions(raw) {
   const argv2 = expandEqualsArgs(raw);
   const options = {};
@@ -5077,6 +6377,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 +6509,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 +6588,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