@xerg/cli 0.1.10 → 0.3.0

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync7 } from "fs";
 import { styleText as styleText2 } from "util";
 
 // src/command-display.ts
@@ -111,9 +110,11 @@ function normalizeSignal(value) {
 }
 
 // src/commands/audit.ts
-import { readFileSync as readFileSync5 } from "fs";
 import { rmSync as rmSync4 } from "fs";
-import { hostname } from "os";
+
+// ../core/src/cursor/usage-csv.ts
+import { readFileSync, statSync } from "fs";
+import { resolve } from "path";
 
 // ../core/src/utils/hash.ts
 import { createHash } from "crypto";
@@ -177,6 +178,563 @@ function toIsoOrNow(value) {
   return isoNow();
 }
 
+// ../core/src/cursor/usage-csv.ts
+var REQUIRED_HEADERS = [
+  "Date",
+  "Kind",
+  "Model",
+  "Max Mode",
+  "Input (w/ Cache Write)",
+  "Input (w/o Cache Write)",
+  "Cache Read",
+  "Output Tokens",
+  "Total Tokens",
+  "Cost"
+];
+var CURSOR_ALIAS_PRICING = {
+  "claude-4.6-opus-high-thinking": {
+    provider: "anthropic",
+    canonicalModel: "claude-opus-4",
+    inputPer1m: 15,
+    outputPer1m: 75,
+    cacheWritePer1m: 18.75,
+    cachedInputPer1m: 1.5
+  },
+  "claude-4.5-sonnet": {
+    provider: "anthropic",
+    canonicalModel: "claude-sonnet-4-5",
+    inputPer1m: 3,
+    outputPer1m: 15,
+    cacheWritePer1m: 3.75,
+    cachedInputPer1m: 0.3
+  },
+  "claude-4.5-sonnet-thinking": {
+    provider: "anthropic",
+    canonicalModel: "claude-sonnet-4-5",
+    inputPer1m: 3,
+    outputPer1m: 15,
+    cacheWritePer1m: 3.75,
+    cachedInputPer1m: 0.3
+  },
+  "claude-4.5-opus-high-thinking": {
+    provider: "anthropic",
+    canonicalModel: "claude-opus-4-5",
+    inputPer1m: 5,
+    outputPer1m: 25,
+    cacheWritePer1m: 6.25,
+    cachedInputPer1m: 0.5
+  },
+  "gpt-5.1-codex": {
+    provider: "openai",
+    canonicalModel: "gpt-5.1-codex",
+    inputPer1m: 1.25,
+    outputPer1m: 10,
+    cacheWritePer1m: 1.25,
+    cachedInputPer1m: 0.125
+  },
+  "gpt-5-high-fast": {
+    provider: "openai",
+    canonicalModel: "gpt-5-high-fast",
+    inputPer1m: 1.25,
+    outputPer1m: 10,
+    cacheWritePer1m: 1.25,
+    cachedInputPer1m: 0.125
+  },
+  "gpt-5": {
+    provider: "openai",
+    canonicalModel: "gpt-5",
+    inputPer1m: 1.25,
+    outputPer1m: 10,
+    cacheWritePer1m: 1.25,
+    cachedInputPer1m: 0.125
+  }
+};
+function round(value) {
+  return Number(value.toFixed(6));
+}
+function parseCsvLine(line) {
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === '"') {
+      const next = line[index + 1];
+      if (inQuotes && next === '"') {
+        current += '"';
+        index += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values.map((value) => value.trim());
+}
+function parseInteger(raw, column, rowNumber) {
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`Invalid ${column} value "${raw}" on row ${rowNumber}.`);
+  }
+  return parsed;
+}
+function parseTimestamp(raw, rowNumber) {
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(`Invalid Date value "${raw}" on row ${rowNumber}.`);
+  }
+  return parsed.toISOString();
+}
+function parseMaxMode(raw) {
+  return raw.trim().toLowerCase() === "yes";
+}
+function parseObservedCost(raw) {
+  const value = raw.trim();
+  if (value.length === 0 || value === "-" || value.toLowerCase() === "included") {
+    return null;
+  }
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function createDetectedSource(path) {
+  const resolvedPath = resolve(path);
+  try {
+    const stats = statSync(resolvedPath);
+    if (!stats.isFile()) {
+      throw new Error(`Cursor usage CSV path is not a file: ${resolvedPath}`);
+    }
+    return {
+      kind: "cursor-usage-csv",
+      runtime: "cursor",
+      path: resolvedPath,
+      sizeBytes: stats.size,
+      mtimeMs: stats.mtimeMs
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : `Cursor usage CSV not found: ${path}`;
+    throw new Error(message);
+  }
+}
+function validateHeaders(headers) {
+  const missing = REQUIRED_HEADERS.filter((header) => !headers.includes(header));
+  if (missing.length > 0) {
+    throw new Error(`Cursor usage CSV is missing required headers: ${missing.join(", ")}.`);
+  }
+}
+function parseRow(values, headers, rowNumber) {
+  const record = Object.fromEntries(headers.map((header, index) => [header, values[index] ?? ""]));
+  const costLabel = record.Cost ?? "";
+  return {
+    timestamp: parseTimestamp(record.Date ?? "", rowNumber),
+    kind: record.Kind ?? "",
+    modelAlias: record.Model ?? "",
+    maxMode: parseMaxMode(record["Max Mode"] ?? ""),
+    inputWithCacheWriteTokens: parseInteger(
+      record["Input (w/ Cache Write)"] ?? "",
+      "Input (w/ Cache Write)",
+      rowNumber
+    ),
+    inputWithoutCacheWriteTokens: parseInteger(
+      record["Input (w/o Cache Write)"] ?? "",
+      "Input (w/o Cache Write)",
+      rowNumber
+    ),
+    cacheReadTokens: parseInteger(record["Cache Read"] ?? "", "Cache Read", rowNumber),
+    outputTokens: parseInteger(record["Output Tokens"] ?? "", "Output Tokens", rowNumber),
+    totalTokens: parseInteger(record["Total Tokens"] ?? "", "Total Tokens", rowNumber),
+    costLabel,
+    observedCostUsd: parseObservedCost(costLabel)
+  };
+}
+function parseRows(lines, headers) {
+  const rows = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.trim()) {
+      continue;
+    }
+    rows.push(parseRow(parseCsvLine(line), headers, index + 2));
+  }
+  return rows;
+}
+function readCursorUsageCsv(path) {
+  const source = createDetectedSource(path);
+  const content = readFileSync(source.path, "utf8");
+  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) {
+    throw new Error(`Cursor usage CSV is empty: ${source.path}`);
+  }
+  const headers = parseCsvLine(lines[0]);
+  validateHeaders(headers);
+  const rows = parseRows(lines.slice(1), headers);
+  return {
+    source,
+    rows,
+    headers,
+    hasObservedCostRows: rows.some((row) => row.observedCostUsd !== null)
+  };
+}
+function isErroredNoCharge(kind) {
+  const normalized = kind.trim().toLowerCase();
+  return normalized.includes("errored") && normalized.includes("no charge") || normalized.includes("not charged");
+}
+function inferProvider(modelAlias) {
+  const normalized = modelAlias.trim().toLowerCase();
+  if (normalized.startsWith("claude-")) {
+    return "anthropic";
+  }
+  if (normalized.startsWith("gpt-")) {
+    return "openai";
+  }
+  return "cursor";
+}
+function buildModelKey(modelAlias, pricing) {
+  if (pricing) {
+    return `${pricing.provider}/${pricing.canonicalModel}`;
+  }
+  return `${inferProvider(modelAlias)}/${modelAlias}`;
+}
+function getWorkflowKey(row) {
+  const kind = row.kind.trim().toLowerCase();
+  if (kind.includes("on-demand")) {
+    return row.maxMode ? "on-demand / max mode" : "on-demand / standard mode";
+  }
+  if (kind.includes("included")) {
+    return row.maxMode ? "included / max mode" : "included / standard mode";
+  }
+  if (kind.includes("error") || kind.includes("not charged")) {
+    return "not charged / failed or aborted";
+  }
+  return row.maxMode ? "other / max mode" : "other / standard mode";
+}
+function estimateCursorRowCost(row, options) {
+  const pricing = CURSOR_ALIAS_PRICING[row.modelAlias.trim().toLowerCase()] ?? null;
+  if (isErroredNoCharge(row.kind)) {
+    return {
+      costUsd: 0,
+      costSource: "observed",
+      cacheCostUsd: 0,
+      cacheWriteCostUsd: 0,
+      pricing,
+      canonicalModelKey: buildModelKey(row.modelAlias, pricing)
+    };
+  }
+  if (options.preferObservedCost) {
+    if (row.observedCostUsd !== null) {
+      const cacheCost2 = row.cacheReadTokens > 0 && pricing?.cachedInputPer1m !== void 0 ? round(row.cacheReadTokens / 1e6 * pricing.cachedInputPer1m) : null;
+      const cacheWriteCost2 = row.inputWithCacheWriteTokens > 0 && pricing ? round(
+        row.inputWithCacheWriteTokens / 1e6 * (pricing.cacheWritePer1m ?? pricing.inputPer1m)
+      ) : null;
+      return {
+        costUsd: row.observedCostUsd,
+        costSource: "observed",
+        cacheCostUsd: cacheCost2,
+        cacheWriteCostUsd: cacheWriteCost2,
+        pricing,
+        canonicalModelKey: buildModelKey(row.modelAlias, pricing)
+      };
+    }
+    return {
+      costUsd: 0,
+      costSource: "observed",
+      cacheCostUsd: 0,
+      cacheWriteCostUsd: 0,
+      pricing,
+      canonicalModelKey: buildModelKey(row.modelAlias, pricing)
+    };
+  }
+  if (!pricing) {
+    return {
+      costUsd: 0,
+      costSource: "unpriced",
+      cacheCostUsd: null,
+      cacheWriteCostUsd: null,
+      pricing: null,
+      canonicalModelKey: buildModelKey(row.modelAlias, pricing)
+    };
+  }
+  if (row.cacheReadTokens > 0 && pricing.cachedInputPer1m === void 0) {
+    return {
+      costUsd: 0,
+      costSource: "unpriced",
+      cacheCostUsd: null,
+      cacheWriteCostUsd: null,
+      pricing: null,
+      canonicalModelKey: buildModelKey(row.modelAlias, pricing)
+    };
+  }
+  const inputCost = row.inputWithoutCacheWriteTokens / 1e6 * pricing.inputPer1m;
+  const cacheWriteCost = row.inputWithCacheWriteTokens / 1e6 * (pricing.cacheWritePer1m ?? pricing.inputPer1m);
+  const outputCost = row.outputTokens / 1e6 * pricing.outputPer1m;
+  const cacheCost = row.cacheReadTokens > 0 && pricing.cachedInputPer1m !== void 0 ? row.cacheReadTokens / 1e6 * pricing.cachedInputPer1m : 0;
+  return {
+    costUsd: round(inputCost + cacheWriteCost + outputCost + cacheCost),
+    costSource: "estimated",
+    cacheCostUsd: round(cacheCost),
+    cacheWriteCostUsd: round(cacheWriteCost),
+    pricing,
+    canonicalModelKey: buildModelKey(row.modelAlias, pricing)
+  };
+}
+function buildCall(row, source, runId, index, options) {
+  const cost = estimateCursorRowCost(row, options);
+  const totalInputTokens = Math.max(row.totalTokens - row.outputTokens, 0);
+  return {
+    cost,
+    call: {
+      id: sha1(`${runId}:${source.path}:${index}:${row.modelAlias}:${row.timestamp}`),
+      runId,
+      timestamp: row.timestamp,
+      provider: cost.pricing?.provider ?? inferProvider(row.modelAlias),
+      model: cost.pricing?.canonicalModel ?? row.modelAlias,
+      inputTokens: totalInputTokens,
+      outputTokens: row.outputTokens,
+      costUsd: cost.costUsd,
+      costSource: cost.costSource,
+      latencyMs: null,
+      toolCalls: 0,
+      retries: 0,
+      attempt: null,
+      iteration: null,
+      status: isErroredNoCharge(row.kind) ? "error" : null,
+      taskClass: null,
+      cacheHit: row.cacheReadTokens > 0,
+      cacheCostUsd: cost.cacheCostUsd,
+      metadata: {
+        source: "cursor-usage-csv",
+        kind: row.kind,
+        maxMode: row.maxMode,
+        modelAlias: row.modelAlias,
+        costLabel: row.costLabel,
+        totalTokens: row.totalTokens,
+        inputWithCacheWriteTokens: row.inputWithCacheWriteTokens,
+        inputWithoutCacheWriteTokens: row.inputWithoutCacheWriteTokens,
+        cacheReadTokens: row.cacheReadTokens,
+        pricingProvider: cost.pricing?.provider ?? null,
+        pricingModel: cost.pricing?.canonicalModel ?? null,
+        canonicalModelKey: cost.canonicalModelKey,
+        observedCostUsd: row.observedCostUsd,
+        cacheWriteCostUsd: cost.cacheWriteCostUsd
+      }
+    }
+  };
+}
+function normalizeCursorUsageCsv(input) {
+  const cutoff = parseSince(input.since);
+  const runs = [];
+  const modelCoverage = /* @__PURE__ */ new Map();
+  const modes = /* @__PURE__ */ new Map();
+  const models = /* @__PURE__ */ new Map();
+  let pricedCallCount = 0;
+  let unpricedCallCount = 0;
+  let pricedTokenCount = 0;
+  let unpricedTokenCount = 0;
+  let totalTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalInputWithCacheWriteTokens = 0;
+  let totalInputWithoutCacheWriteTokens = 0;
+  input.rows.forEach((row, index) => {
+    const timestampMs = new Date(row.timestamp).getTime();
+    if (cutoff && timestampMs < cutoff) {
+      return;
+    }
+    const workflow = getWorkflowKey(row);
+    const runId = sha1(`${input.source.path}:${row.timestamp}:${row.modelAlias}:${index}`);
+    const { call, cost } = buildCall(row, input.source, runId, index, {
+      preferObservedCost: input.hasObservedCostRows ?? false
+    });
+    const run2 = {
+      id: runId,
+      sourceKind: input.source.kind,
+      sourcePath: input.source.path,
+      timestamp: row.timestamp,
+      workflow,
+      environment: "local",
+      tags: {
+        sourceKind: input.source.kind,
+        maxMode: row.maxMode,
+        kind: row.kind
+      },
+      calls: [call],
+      totalCostUsd: call.costUsd,
+      totalTokens: row.totalTokens,
+      observedCostUsd: call.costSource === "observed" ? call.costUsd : 0,
+      estimatedCostUsd: call.costSource === "estimated" ? call.costUsd : 0
+    };
+    runs.push(run2);
+    totalTokens += row.totalTokens;
+    totalOutputTokens += row.outputTokens;
+    totalCacheReadTokens += row.cacheReadTokens;
+    totalInputWithCacheWriteTokens += row.inputWithCacheWriteTokens;
+    totalInputWithoutCacheWriteTokens += row.inputWithoutCacheWriteTokens;
+    const totalRowTokens = row.totalTokens;
+    if (cost.costSource === "unpriced") {
+      unpricedCallCount += 1;
+      unpricedTokenCount += totalRowTokens;
+      const current = modelCoverage.get(row.modelAlias) ?? { callCount: 0, totalTokens: 0 };
+      current.callCount += 1;
+      current.totalTokens += totalRowTokens;
+      modelCoverage.set(row.modelAlias, current);
+    } else {
+      pricedCallCount += 1;
+      pricedTokenCount += totalRowTokens;
+    }
+    const modeBucket = modes.get(workflow) ?? {
+      callCount: 0,
+      totalTokens: 0,
+      estimatedSpendUsd: 0
+    };
+    modeBucket.callCount += 1;
+    modeBucket.totalTokens += totalRowTokens;
+    modeBucket.estimatedSpendUsd = round(modeBucket.estimatedSpendUsd + call.costUsd);
+    modes.set(workflow, modeBucket);
+    const modelBucket = models.get(cost.canonicalModelKey) ?? {
+      callCount: 0,
+      totalTokens: 0,
+      estimatedSpendUsd: 0,
+      pricedCallCount: 0,
+      unpricedCallCount: 0
+    };
+    modelBucket.callCount += 1;
+    modelBucket.totalTokens += totalRowTokens;
+    modelBucket.estimatedSpendUsd = round(modelBucket.estimatedSpendUsd + call.costUsd);
+    if (cost.costSource === "unpriced") {
+      modelBucket.unpricedCallCount += 1;
+    } else {
+      modelBucket.pricedCallCount += 1;
+    }
+    models.set(cost.canonicalModelKey, modelBucket);
+  });
+  runs.sort(
+    (left, right) => new Date(left.timestamp).getTime() - new Date(right.timestamp).getTime()
+  );
+  return {
+    runs,
+    pricingCoverage: {
+      pricedCallCount,
+      unpricedCallCount,
+      pricedTokenCount,
+      unpricedTokenCount,
+      topUnpricedModels: Array.from(modelCoverage.entries()).map(([key, value]) => ({
+        key,
+        callCount: value.callCount,
+        totalTokens: value.totalTokens
+      })).sort((left, right) => right.totalTokens - left.totalTokens).slice(0, 5)
+    },
+    cursorUsage: {
+      totalTokens,
+      totalInputTokens: Math.max(totalTokens - totalOutputTokens, 0),
+      totalOutputTokens,
+      totalCacheReadTokens,
+      totalInputWithCacheWriteTokens,
+      totalInputWithoutCacheWriteTokens,
+      modes: Array.from(modes.entries()).map(([key, value]) => ({
+        key,
+        callCount: value.callCount,
+        totalTokens: value.totalTokens,
+        estimatedSpendUsd: value.estimatedSpendUsd
+      })).sort((left, right) => right.totalTokens - left.totalTokens),
+      models: Array.from(models.entries()).map(([key, value]) => ({
+        key,
+        callCount: value.callCount,
+        totalTokens: value.totalTokens,
+        estimatedSpendUsd: value.estimatedSpendUsd,
+        pricedCallCount: value.pricedCallCount,
+        unpricedCallCount: value.unpricedCallCount
+      })).sort((left, right) => right.totalTokens - left.totalTokens)
+    }
+  };
+}
+function buildDoctorNotes(report) {
+  const notes = ["Cursor usage CSV headers validated."];
+  if (report.rowCount === 0) {
+    notes.push("The CSV contains no usage rows.");
+  }
+  if (report.pricingCoverage.unpricedCallCount > 0) {
+    const aliases = report.pricingCoverage.topUnpricedModels.map((model) => model.key).join(", ");
+    notes.push(
+      `Some Cursor aliases do not have full local pricing coverage: ${aliases || "unknown aliases"}.`
+    );
+  } else {
+    notes.push("All rows in this CSV have local pricing coverage.");
+  }
+  notes.push("Cursor CSV audits use exported usage rows rather than raw session transcripts.");
+  return notes;
+}
+async function inspectCursorUsageCsv(options) {
+  const filePath = options.cursorUsageCsv ? resolve(options.cursorUsageCsv) : "";
+  options.onProgress?.("Inspecting Cursor usage CSV...");
+  if (!filePath) {
+    return {
+      canAudit: false,
+      filePath,
+      source: null,
+      rowCount: 0,
+      dateRange: null,
+      pricingCoverage: {
+        pricedCallCount: 0,
+        unpricedCallCount: 0,
+        pricedTokenCount: 0,
+        unpricedTokenCount: 0,
+        topUnpricedModels: []
+      },
+      notes: ["No Cursor usage CSV path was provided."]
+    };
+  }
+  try {
+    const parsed = readCursorUsageCsv(filePath);
+    const normalized = normalizeCursorUsageCsv({
+      source: parsed.source,
+      rows: parsed.rows,
+      hasObservedCostRows: parsed.hasObservedCostRows
+    });
+    const dateRange = parsed.rows.length === 0 ? null : {
+      start: parsed.rows.map((row) => row.timestamp).sort((left, right) => new Date(left).getTime() - new Date(right).getTime())[0],
+      end: parsed.rows.map((row) => row.timestamp).sort((left, right) => new Date(left).getTime() - new Date(right).getTime()).at(-1)
+    };
+    const report = {
+      canAudit: true,
+      filePath: parsed.source.path,
+      source: parsed.source,
+      rowCount: parsed.rows.length,
+      dateRange,
+      pricingCoverage: normalized.pricingCoverage,
+      notes: []
+    };
+    report.notes = buildDoctorNotes(report);
+    options.onProgress?.(
+      `Cursor usage CSV is ready (${report.rowCount} row${report.rowCount === 1 ? "" : "s"}).`
+    );
+    return report;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    options.onProgress?.(`Cursor usage CSV is not ready: ${message}`);
+    return {
+      canAudit: false,
+      filePath,
+      source: null,
+      rowCount: 0,
+      dateRange: null,
+      pricingCoverage: {
+        pricedCallCount: 0,
+        unpricedCallCount: 0,
+        pricedTokenCount: 0,
+        unpricedTokenCount: 0,
+        topUnpricedModels: []
+      },
+      notes: [message]
+    };
+  }
+}
+
 // ../core/src/db/client.ts
 import { mkdirSync } from "fs";
 import { dirname } from "path";
@@ -536,7 +1094,7 @@ var FINDING_KIND_LABELS = {
   "candidate-downgrade": "Downgrade candidates",
   "idle-spend": "Idle waste"
 };
-function round(value) {
+function round2(value) {
   return Number(value.toFixed(6));
 }
 function normalizeSinceValue(since) {
@@ -581,6 +1139,7 @@ function buildComparisonKey(input) {
   ).sort();
   return sha1(
     JSON.stringify({
+      runtime: input.runtime,
       kinds,
       roots,
       since: normalizeSinceValue(input.since)
@@ -600,7 +1159,7 @@ function buildTaxonomyBuckets(findings, classification) {
       spendUsd: 0,
       findingCount: 0
     };
-    current.spendUsd = round(current.spendUsd + finding.costImpactUsd);
+    current.spendUsd = round2(current.spendUsd + finding.costImpactUsd);
     current.findingCount += 1;
     buckets.set(finding.kind, current);
   }
@@ -618,9 +1177,9 @@ function buildTopSpendDeltas(currentRows, baselineRows) {
     const currentSpendUsd = currentMap.get(key) ?? 0;
     return {
       key,
-      baselineSpendUsd: round(baselineSpendUsd),
-      currentSpendUsd: round(currentSpendUsd),
-      deltaSpendUsd: round(currentSpendUsd - baselineSpendUsd)
+      baselineSpendUsd: round2(baselineSpendUsd),
+      currentSpendUsd: round2(currentSpendUsd),
+      deltaSpendUsd: round2(currentSpendUsd - baselineSpendUsd)
     };
   }).filter((row) => row.deltaSpendUsd !== 0).sort((left, right) => Math.abs(right.deltaSpendUsd) - Math.abs(left.deltaSpendUsd)).slice(0, 3);
 }
@@ -655,11 +1214,11 @@ function buildFindingChanges(currentFindings, baselineFindings) {
         scope: current.scope,
         scopeId: current.scopeId,
         currentCostImpactUsd: current.costImpactUsd,
-        deltaCostImpactUsd: round(current.costImpactUsd)
+        deltaCostImpactUsd: round2(current.costImpactUsd)
       });
       continue;
     }
-    const deltaCostImpactUsd = round(current.costImpactUsd - baseline.costImpactUsd);
+    const deltaCostImpactUsd = round2(current.costImpactUsd - baseline.costImpactUsd);
     if (deltaCostImpactUsd > 0) {
       worsenedHighConfidenceWaste.push({
         kind: current.kind,
@@ -682,7 +1241,7 @@ function buildFindingChanges(currentFindings, baselineFindings) {
       scope: baseline.scope,
       scopeId: baseline.scopeId,
       baselineCostImpactUsd: baseline.costImpactUsd,
-      deltaCostImpactUsd: round(-baseline.costImpactUsd)
+      deltaCostImpactUsd: round2(-baseline.costImpactUsd)
     });
   }
   return {
@@ -691,17 +1250,39 @@ 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"),
-    notes: summary.notes ?? []
+    spendByDay: summary.spendByDay ?? [],
+    wasteByDay: summary.wasteByDay ?? [],
+    notes: summary.notes ?? [],
+    pricingCoverage: summary.pricingCoverage ?? null,
+    cursorUsage: summary.cursorUsage ?? null
   };
 }
 function buildAuditComparison(current, baseline) {
@@ -718,12 +1299,12 @@ function buildAuditComparison(current, baseline) {
     baselineWasteSpendUsd: baseline.wasteSpendUsd,
     baselineOpportunitySpendUsd: baseline.opportunitySpendUsd,
     baselineStructuralWasteRate: baseline.structuralWasteRate,
-    deltaTotalSpendUsd: round(current.totalSpendUsd - baseline.totalSpendUsd),
-    deltaObservedSpendUsd: round(current.observedSpendUsd - baseline.observedSpendUsd),
-    deltaEstimatedSpendUsd: round(current.estimatedSpendUsd - baseline.estimatedSpendUsd),
-    deltaWasteSpendUsd: round(current.wasteSpendUsd - baseline.wasteSpendUsd),
-    deltaOpportunitySpendUsd: round(current.opportunitySpendUsd - baseline.opportunitySpendUsd),
-    deltaStructuralWasteRate: round(current.structuralWasteRate - baseline.structuralWasteRate),
+    deltaTotalSpendUsd: round2(current.totalSpendUsd - baseline.totalSpendUsd),
+    deltaObservedSpendUsd: round2(current.observedSpendUsd - baseline.observedSpendUsd),
+    deltaEstimatedSpendUsd: round2(current.estimatedSpendUsd - baseline.estimatedSpendUsd),
+    deltaWasteSpendUsd: round2(current.wasteSpendUsd - baseline.wasteSpendUsd),
+    deltaOpportunitySpendUsd: round2(current.opportunitySpendUsd - baseline.opportunitySpendUsd),
+    deltaStructuralWasteRate: round2(current.structuralWasteRate - baseline.structuralWasteRate),
     deltaRunCount: current.runCount - baseline.runCount,
     deltaCallCount: current.callCount - baseline.callCount,
     workflowDeltas,
@@ -767,189 +1348,137 @@ function readLatestComparableAuditSummary(input) {
   });
 }
 
-// ../core/src/detect/openclaw.ts
-import { readdirSync, statSync } from "fs";
-import { isAbsolute, join as join2, resolve, 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");
+// ../core/src/findings/cursor.ts
+function round3(value) {
+  return Number(value.toFixed(6));
 }
-function getDefaultSessionsPattern() {
-  return join(homedir(), ".openclaw", "agents", "*", "sessions", "*.jsonl");
+function createFinding(input) {
+  return {
+    ...input,
+    id: sha1(
+      `${input.kind}:${input.scope}:${input.scopeId}:${input.title}:${input.costImpactUsd}:${input.summary}`
+    )
+  };
 }
-function getDefaultGatewayPattern() {
-  return "/tmp/openclaw/openclaw-*.log";
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-
-// ../core/src/detect/openclaw.ts
-function toDetected(path, kind) {
-  try {
-    const stats = statSync(path);
-    if (!stats.isFile()) {
-      return null;
-    }
-    return {
-      kind,
-      path,
-      sizeBytes: stats.size,
-      mtimeMs: stats.mtimeMs
-    };
-  } catch {
-    return null;
-  }
+function asBoolean(value) {
+  return value === true;
 }
-async function detectOpenClawSources(options) {
-  const explicitSources = [];
-  if (options.logFile) {
-    const detected2 = toDetected(options.logFile, "gateway");
-    if (detected2) {
-      explicitSources.push(detected2);
-    }
+function buildCursorUsageFindings(runs) {
+  const calls = runs.flatMap((run2) => run2.calls);
+  const billableCalls = calls.filter((call) => call.costUsd > 0);
+  if (billableCalls.length === 0) {
+    return { findings: [], wasteAttributions: [] };
   }
-  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);
+  const cacheAwareCalls = billableCalls.filter((call) => {
+    return asNumber(call.metadata.cacheReadTokens) > 0;
+  });
+  if (cacheAwareCalls.length === 0) {
+    return { findings: [], wasteAttributions: [] };
+  }
+  const totalSpendUsd = billableCalls.reduce((sum, call) => sum + call.costUsd, 0);
+  const totalInputTokens = billableCalls.reduce((sum, call) => sum + call.inputTokens, 0);
+  const totalCacheReadTokens = cacheAwareCalls.reduce(
+    (sum, call) => sum + asNumber(call.metadata.cacheReadTokens),
+    0
+  );
+  const totalCacheWriteTokens = billableCalls.reduce(
+    (sum, call) => sum + asNumber(call.metadata.inputWithCacheWriteTokens),
+    0
+  );
+  const cacheSpendUsd = cacheAwareCalls.reduce((sum, call) => sum + (call.cacheCostUsd ?? 0), 0);
+  const cacheWriteSpendUsd = billableCalls.reduce(
+    (sum, call) => sum + asNumber(call.metadata.cacheWriteCostUsd),
+    0
+  );
+  const coveredSpendUsd = billableCalls.filter((call) => call.cacheCostUsd !== null).reduce((sum, call) => sum + call.costUsd, 0);
+  const maxModeSpendUsd = billableCalls.filter((call) => asBoolean(call.metadata.maxMode)).reduce((sum, call) => sum + call.costUsd, 0);
+  const cacheReadShare = totalInputTokens === 0 ? 0 : totalCacheReadTokens / totalInputTokens;
+  const cacheCoverageShare = totalSpendUsd === 0 ? 0 : coveredSpendUsd / totalSpendUsd;
+  const maxModeSpendShare = totalSpendUsd === 0 ? 0 : maxModeSpendUsd / totalSpendUsd;
+  const cacheImpactUsd = round3(cacheSpendUsd + cacheWriteSpendUsd);
+  const meetsWasteBar = cacheImpactUsd >= 25 && cacheReadShare >= 0.6 && cacheAwareCalls.length >= 20 && cacheCoverageShare >= 0.4;
+  const meetsOpportunityBar = cacheImpactUsd >= 5 && cacheReadShare >= 0.35 && cacheAwareCalls.length >= 10 && cacheCoverageShare >= 0.25;
+  if (!meetsWasteBar && !meetsOpportunityBar) {
+    return { findings: [], wasteAttributions: [] };
+  }
+  const classification = meetsWasteBar ? "waste" : "opportunity";
+  const confidence = cacheReadShare >= 0.8 && cacheAwareCalls.length >= 50 && cacheCoverageShare >= 0.5 ? "high" : cacheReadShare >= 0.5 && cacheAwareCalls.length >= 20 ? "medium" : "low";
+  const summary = classification === "waste" ? `Xerg estimated ${cacheImpactUsd.toFixed(2)} USD of billed spend was driven by repeatedly replaying cached context across ${cacheAwareCalls.length} paid row${cacheAwareCalls.length === 1 ? "" : "s"}. This pattern is consistent with long chats carrying more history than needed.` : `Xerg estimated ${cacheImpactUsd.toFixed(2)} USD of billed spend was tied to cached context replay across ${cacheAwareCalls.length} paid row${cacheAwareCalls.length === 1 ? "" : "s"}. Summarizing and resetting long chats could reduce this carryover cost.`;
+  const findings = [
+    createFinding({
+      classification,
+      confidence,
+      kind: "cache-carryover",
+      title: classification === "waste" ? "Cached context carryover is driving avoidable spend" : "Cached context carryover looks like a strong cost-reduction opportunity",
+      summary,
+      scope: "global",
+      scopeId: "all",
+      costImpactUsd: cacheImpactUsd,
+      details: {
+        cacheReadShare: round3(cacheReadShare),
+        cacheCoverageShare: round3(cacheCoverageShare),
+        totalCacheReadTokens,
+        totalCacheWriteTokens,
+        billableCallCount: billableCalls.length,
+        cacheAwareCallCount: cacheAwareCalls.length,
+        maxModeSpendShare: round3(maxModeSpendShare),
+        estimatedCacheReadSpendUsd: round3(cacheSpendUsd),
+        estimatedCacheWriteSpendUsd: round3(cacheWriteSpendUsd)
       }
-    }
-  }
-  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);
+  const maxModeCalls = billableCalls.filter((call) => asBoolean(call.metadata.maxMode));
+  const maxModeCallShare = billableCalls.length === 0 ? 0 : maxModeCalls.length / billableCalls.length;
+  if (maxModeSpendShare >= 0.6 && maxModeSpendUsd >= 25 && maxModeCalls.length >= 10) {
+    const maxModeConfidence = maxModeSpendShare >= 0.85 && maxModeCalls.length >= 50 ? "high" : maxModeSpendShare >= 0.7 && maxModeCalls.length >= 20 ? "medium" : "low";
+    findings.push(
+      createFinding({
+        classification: "opportunity",
+        confidence: maxModeConfidence,
+        kind: "max-mode-concentration",
+        title: "Max mode is concentrated in the billed spend mix",
+        summary: `Max mode accounts for ${(maxModeSpendShare * 100).toFixed(0)}% of billed spend across ${maxModeCalls.length} paid row${maxModeCalls.length === 1 ? "" : "s"}. This is a strong candidate for splitting work between premium and standard passes.`,
+        scope: "global",
+        scopeId: "all",
+        costImpactUsd: round3(maxModeSpendUsd * 0.2),
+        details: {
+          maxModeSpendUsd: round3(maxModeSpendUsd),
+          maxModeSpendShare: round3(maxModeSpendShare),
+          maxModeCallCount: maxModeCalls.length,
+          maxModeCallShare: round3(maxModeCallShare)
+        }
+      })
+    );
+  }
+  const wasteAttributions = classification === "waste" ? billableCalls.map((call) => ({
+    kind: "cache-carryover",
+    timestamp: call.timestamp,
+    wasteUsd: round3((call.cacheCostUsd ?? 0) + asNumber(call.metadata.cacheWriteCostUsd))
+  })).filter((attribution) => attribution.wasteUsd > 0) : [];
+  return {
+    findings: findings.sort((left, right) => right.costImpactUsd - left.costImpactUsd),
+    wasteAttributions
+  };
 }
-async function collectGlobMatches(pattern, options) {
-  const baseDir = options?.cwd ? resolve(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 ? resolve(options.resolveWith, match) : match
-  );
+
+// ../core/src/findings/engine.ts
+function createFinding2(input) {
+  return {
+    ...input,
+    id: sha1(
+      `${input.kind}:${input.scope}:${input.scopeId}:${input.title}:${input.costImpactUsd}:${input.summary}`
+    )
+  };
 }
-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/engine.ts
-function createFinding(input) {
-  return {
-    ...input,
-    id: sha1(
-      `${input.kind}:${input.scope}:${input.scopeId}:${input.title}:${input.costImpactUsd}:${input.summary}`
-    )
-  };
-}
-function round2(value) {
+function round4(value) {
   return Number(value.toFixed(6));
 }
 function buildFindings(runs) {
   const findings = [];
+  const wasteAttributions = [];
   const allCalls = runs.flatMap((run2) => run2.calls.map((call) => ({ run: run2, call })));
   const retryCandidates = allCalls.filter(({ call }) => {
     const status = (call.status ?? "").toLowerCase();
@@ -957,8 +1486,15 @@ function buildFindings(runs) {
   });
   const retryCost = retryCandidates.reduce((sum, item) => sum + item.call.costUsd, 0);
   if (retryCost > 0) {
+    wasteAttributions.push(
+      ...retryCandidates.map(({ call }) => ({
+        kind: "retry-waste",
+        timestamp: call.timestamp,
+        wasteUsd: call.costUsd
+      }))
+    );
     findings.push(
-      createFinding({
+      createFinding2({
         classification: "waste",
         confidence: "high",
         kind: "retry-waste",
@@ -966,7 +1502,7 @@ function buildFindings(runs) {
         summary: `${retryCandidates.length} failed call${retryCandidates.length === 1 ? "" : "s"} were followed by additional work, making their spend pure retry overhead.`,
         scope: "global",
         scopeId: "all",
-        costImpactUsd: round2(retryCost),
+        costImpactUsd: round4(retryCost),
         details: {
           failedCallCount: retryCandidates.length
         }
@@ -978,8 +1514,15 @@ function buildFindings(runs) {
     if (maxIteration >= 7) {
       const loopCalls = run2.calls.filter((call) => (call.iteration ?? 0) > 5);
       const loopCost = loopCalls.reduce((sum, call) => sum + call.costUsd, 0);
+      wasteAttributions.push(
+        ...loopCalls.map((call) => ({
+          kind: "loop-waste",
+          timestamp: call.timestamp,
+          wasteUsd: call.costUsd
+        }))
+      );
       findings.push(
-        createFinding({
+        createFinding2({
           classification: "waste",
           confidence: "high",
           kind: "loop-waste",
@@ -987,7 +1530,7 @@ function buildFindings(runs) {
           summary: `This run reached ${maxIteration} iterations. Xerg treats the spend after iteration 5 as likely loop waste.`,
           scope: "run",
           scopeId: run2.id,
-          costImpactUsd: round2(loopCost),
+          costImpactUsd: round4(loopCost),
           details: {
             workflow: run2.workflow,
             maxIteration
@@ -1015,7 +1558,7 @@ function buildFindings(runs) {
       if (outlierRuns.length > 0) {
         const outlierCost = outlierRuns.reduce((sum, run2) => sum + run2.totalCostUsd, 0);
         findings.push(
-          createFinding({
+          createFinding2({
             classification: "opportunity",
             confidence: "medium",
             kind: "context-outlier",
@@ -1023,10 +1566,10 @@ function buildFindings(runs) {
             summary: `Xerg found ${outlierRuns.length} run${outlierRuns.length === 1 ? "" : "s"} in this workflow with input token volume far above the workflow average.`,
             scope: "workflow",
             scopeId: workflow,
-            costImpactUsd: round2(outlierCost),
+            costImpactUsd: round4(outlierCost),
             details: {
               workflow,
-              averageInputTokens: round2(average),
+              averageInputTokens: round4(average),
               outlierRunCount: outlierRuns.length
             }
           })
@@ -1039,7 +1582,7 @@ function buildFindings(runs) {
     if (idleRuns.length > 0) {
       const idleCost = idleRuns.reduce((sum, run2) => sum + run2.totalCostUsd, 0);
       findings.push(
-        createFinding({
+        createFinding2({
           classification: "opportunity",
           confidence: "medium",
           kind: "idle-spend",
@@ -1047,7 +1590,7 @@ function buildFindings(runs) {
           summary: "This workflow name looks like a recurring heartbeat or monitoring loop. Review whether the cadence and model tier are justified.",
           scope: "workflow",
           scopeId: workflow,
-          costImpactUsd: round2(idleCost),
+          costImpactUsd: round4(idleCost),
           details: {
             workflow
           }
@@ -1060,7 +1603,7 @@ function buildFindings(runs) {
     if (downgradeCalls.length > 0) {
       const spend = downgradeCalls.reduce((sum, call) => sum + call.costUsd, 0);
       findings.push(
-        createFinding({
+        createFinding2({
           classification: "opportunity",
           confidence: "low",
           kind: "candidate-downgrade",
@@ -1068,23 +1611,22 @@ function buildFindings(runs) {
           summary: "An expensive model is being used on a workflow that looks operationally simple. Treat this as an A/B test candidate, not proven waste.",
           scope: "workflow",
           scopeId: workflow,
-          costImpactUsd: round2(spend * 0.3),
+          costImpactUsd: round4(spend * 0.3),
           details: {
             workflow,
             expensiveCallCount: downgradeCalls.length,
-            inspectedSpendUsd: round2(spend)
+            inspectedSpendUsd: round4(spend)
           }
         })
       );
     }
   }
-  return findings.sort((left, right) => right.costImpactUsd - left.costImpactUsd);
+  return {
+    findings: findings.sort((left, right) => right.costImpactUsd - left.costImpactUsd),
+    wasteAttributions
+  };
 }
 
-// ../core/src/normalize/openclaw.ts
-import { readFileSync } from "fs";
-import { basename } from "path";
-
 // ../core/src/pricing-catalog.ts
 var PRICING_CATALOG = [
   {
@@ -1161,6 +1703,223 @@ function estimateCostUsd(provider, model, inputTokens, outputTokens) {
   return Number((inputCost + outputCost).toFixed(8));
 }
 
+// ../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;
+  }
+  return candidate.toISOString().slice(0, 10);
+}
+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 buildObservedUtcDayRange(runs) {
+  const days = runs.flatMap((run2) => run2.calls).map((call) => toUtcDay(call.timestamp)).filter((day) => day !== null).sort();
+  if (days.length === 0) {
+    return [];
+  }
+  const range = [];
+  let current = days[0];
+  const last = days[days.length - 1];
+  while (current <= last) {
+    range.push(current);
+    current = incrementUtcDay(current);
+  }
+  return range;
+}
+function reconcileDailyTotal(rows, key, expected) {
+  if (rows.length === 0) {
+    return;
+  }
+  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 last = rows[rows.length - 1];
+  const current = last[key];
+  if (typeof current === "number") {
+    last[key] = round5(current + delta);
+  }
+}
+function buildSpendByDay(runs) {
+  const days = buildObservedUtcDayRange(runs);
+  if (days.length === 0) {
+    return [];
+  }
+  const byDay = new Map(
+    days.map((day) => [
+      day,
+      { date: day, observedSpendUsd: 0, estimatedSpendUsd: 0, callCount: 0 }
+    ])
+  );
+  for (const run2 of runs) {
+    for (const call of run2.calls) {
+      const day = toUtcDay(call.timestamp);
+      if (!day) {
+        continue;
+      }
+      const bucket = byDay.get(day);
+      if (!bucket) {
+        continue;
+      }
+      bucket.callCount += 1;
+      if (call.costSource === "observed") {
+        bucket.observedSpendUsd += call.costUsd;
+      } else if (call.costSource === "estimated") {
+        bucket.estimatedSpendUsd += call.costUsd;
+      }
+    }
+  }
+  const rows = days.map((day) => {
+    const bucket = byDay.get(day);
+    const observedSpendUsd = round5(bucket?.observedSpendUsd ?? 0);
+    const estimatedSpendUsd = round5(bucket?.estimatedSpendUsd ?? 0);
+    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") {
@@ -1182,7 +1941,7 @@ function getNestedValue(input, paths) {
   }
   return null;
 }
-function asNumber(value) {
+function asNumber2(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
   }
@@ -1198,7 +1957,7 @@ function asString(value) {
   }
   return null;
 }
-function asBoolean(value) {
+function asBoolean2(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -1221,39 +1980,119 @@ function pickMetadata(input, keys) {
   return output;
 }
 
-// ../core/src/normalize/openclaw.ts
+// ../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 = readFileSync(path, "utf8");
+  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);
+    const parsed = parseJsonLine(line);
+    if (parsed) {
       records.push(parsed);
-    } catch {
     }
   }
   return records;
 }
-function inferProvider(record) {
-  return asString(
-    getNestedValue(record, [["provider"], ["message", "provider"], ["usage", "provider"]])
-  ) ?? "unknown";
+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 inferModel(record) {
-  return asString(getNestedValue(record, [["model"], ["message", "model"], ["usage", "model"]])) ?? "unknown-model";
+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"],
-      ["session", "workflow"],
-      ["metadata", "workflow"],
+      ["job_name"],
+      ["task_class"],
+      ["taskClass"],
+      ["agent_name"],
       ["agent", "name"],
-      ["agentId"],
-      ["sessionId"]
+      ["source"],
+      ["session", "source"],
+      ["session_key"],
+      ["session_id"],
+      ["sessionId"],
+      ["title"]
     ])
-  ) ?? basename(sourcePath, ".jsonl");
+  ) ?? basename(sourcePath).replace(/\.(jsonl|json|log)(\.\d+)?$/i, "");
 }
 function inferEnvironment(record) {
   return asString(getNestedValue(record, [["environment"], ["env"], ["metadata", "environment"]])) ?? "local";
@@ -1263,18 +2102,506 @@ function inferRunKey(record, workflow, index, sourcePath) {
     getNestedValue(record, [
       ["run_id"],
       ["runId"],
+      ["session_id"],
+      ["sessionId"],
+      ["session_key"],
+      ["thread_id"],
+      ["threadId"],
       ["trace_id"],
       ["traceId"],
-      ["sessionId"],
-      ["thread_id"]
+      ["conversation_id"],
+      ["conversationId"],
+      ["id"]
     ])
   ) ?? `${sourcePath}:${workflow}:${index}`;
 }
 function inferTaskClass(record, workflow) {
-  return asString(getNestedValue(record, [["task_class"], ["taskClass"], ["metadata", "taskClass"]])) ?? workflow.toLowerCase();
+  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 = asNumber(
+  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 {
+    }
+  }
+  return records;
+}
+function inferProvider2(record) {
+  return asString(
+    getNestedValue(record, [["provider"], ["message", "provider"], ["usage", "provider"]])
+  ) ?? "unknown";
+}
+function inferModel(record) {
+  return asString(getNestedValue(record, [["model"], ["message", "model"], ["usage", "model"]])) ?? "unknown-model";
+}
+function inferWorkflow2(record, sourcePath) {
+  return asString(
+    getNestedValue(record, [
+      ["workflow"],
+      ["session", "workflow"],
+      ["metadata", "workflow"],
+      ["agent", "name"],
+      ["agentId"],
+      ["sessionId"]
+    ])
+  ) ?? basename3(sourcePath, ".jsonl");
+}
+function inferEnvironment2(record) {
+  return asString(getNestedValue(record, [["environment"], ["env"], ["metadata", "environment"]])) ?? "local";
+}
+function inferRunKey2(record, workflow, index, sourcePath) {
+  return asString(
+    getNestedValue(record, [
+      ["run_id"],
+      ["runId"],
+      ["trace_id"],
+      ["traceId"],
+      ["sessionId"],
+      ["thread_id"]
+    ])
+  ) ?? `${sourcePath}:${workflow}:${index}`;
+}
+function inferTaskClass2(record, workflow) {
+  return asString(getNestedValue(record, [["task_class"], ["taskClass"], ["metadata", "taskClass"]])) ?? workflow.toLowerCase();
+}
+function extractUsage2(record) {
+  const inputTokens = asNumber2(
     getNestedValue(record, [
       ["input_tokens"],
       ["inputTokens"],
@@ -1286,7 +2613,7 @@ function extractUsage(record) {
       ["message", "usage", "prompt_tokens"]
     ])
   ) ?? 0;
-  const outputTokens = asNumber(
+  const outputTokens = asNumber2(
     getNestedValue(record, [
       ["output_tokens"],
       ["outputTokens"],
@@ -1298,7 +2625,7 @@ function extractUsage(record) {
       ["message", "usage", "completion_tokens"]
     ])
   ) ?? 0;
-  const observedCost = asNumber(
+  const observedCost = asNumber2(
     getNestedValue(record, [
       ["cost_usd"],
       ["costUsd"],
@@ -1316,22 +2643,22 @@ function extractUsage(record) {
     observedCost
   };
 }
-function buildCall(source, record, runId, index) {
-  const provider = inferProvider(record);
+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"]])
   );
-  const attempt = asNumber(
+  const attempt = asNumber2(
     getNestedValue(record, [["attempt"], ["usage", "attempt"], ["metadata", "attempt"]])
   ) ?? null;
-  const iteration = asNumber(
+  const iteration = asNumber2(
     getNestedValue(record, [["iteration"], ["loop_iteration"], ["metadata", "iteration"]])
   ) ?? null;
-  const retries = asNumber(getNestedValue(record, [["retries"], ["retry_count"], ["metadata", "retries"]])) ?? 0;
+  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}`),
@@ -1343,45 +2670,45 @@ function buildCall(source, record, runId, index) {
     outputTokens,
     costUsd,
     costSource: observedCost !== null ? "observed" : "estimated",
-    latencyMs: asNumber(getNestedValue(record, [["latency_ms"], ["latencyMs"], ["usage", "latency_ms"]])) ?? null,
-    toolCalls: asNumber(getNestedValue(record, [["tool_calls"], ["toolCalls"], ["usage", "tool_calls"]])) ?? 0,
+    latencyMs: asNumber2(getNestedValue(record, [["latency_ms"], ["latencyMs"], ["usage", "latency_ms"]])) ?? null,
+    toolCalls: asNumber2(getNestedValue(record, [["tool_calls"], ["toolCalls"], ["usage", "tool_calls"]])) ?? 0,
     retries,
     attempt,
     iteration,
     status: asString(getNestedValue(record, [["status"], ["level"], ["result"], ["error", "type"]])) ?? null,
-    taskClass: inferTaskClass(record, workflow),
-    cacheHit: asBoolean(
+    taskClass: inferTaskClass2(record, workflow),
+    cacheHit: asBoolean2(
       getNestedValue(record, [["cache_hit"], ["cacheHit"], ["usage", "cache_hit"]])
     ),
-    cacheCostUsd: asNumber(
+    cacheCostUsd: asNumber2(
       getNestedValue(record, [["cache_cost_usd"], ["cacheCostUsd"], ["usage", "cache_cost_usd"]])
     ) ?? null,
     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 = buildCall(source, record, runId, index);
+      const call = buildCall3(source, record, runId, index);
       const existing = runsById.get(runId);
       if (!existing) {
         runsById.set(runId, {
@@ -1390,7 +2717,7 @@ function normalizeOpenClawSources(sources, since) {
           sourcePath: source.path,
           timestamp,
           workflow,
-          environment: inferEnvironment(record),
+          environment: inferEnvironment2(record),
           tags: {
             sourceKind: source.kind
           },
@@ -1414,147 +2741,431 @@ function normalizeOpenClawSources(sources, since) {
   });
 }
 
-// ../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);
+// ../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 Array.from(buckets.entries()).map(([key, value]) => {
-    const observedShare = value.spendUsd === 0 ? 0 : value.observedSpendUsd / value.spendUsd;
+};
+function getRuntimeAdapter(runtime) {
+  return RUNTIME_ADAPTERS[runtime];
+}
+function hasExplicitLocalPaths(options) {
+  return Boolean(options.logFile || options.sessionsDir);
+}
+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 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 hints.size === 1 ? Array.from(hints)[0] : null;
+}
+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 notes = [];
+  if (sources.some((source) => source.kind === "gateway")) {
+    notes.push(adapter.gatewayNote);
+  }
+  if (sources.some((source) => source.kind === "sessions")) {
+    notes.push(adapter.sessionNote);
+  }
+  return notes;
+}
+function buildResolvedDoctorReport(adapter, sources) {
+  return {
+    canAudit: sources.length > 0,
+    mode: sources.length > 0 ? "resolved" : "none",
+    runtime: sources.length > 0 ? adapter.runtime : null,
+    sources,
+    defaults: [adapter.defaultPaths()],
+    notes: buildResolvedDoctorNotes(adapter, sources)
+  };
+}
+function buildAutoNoDataDoctorReport(candidates) {
+  return {
+    canAudit: false,
+    mode: "none",
+    runtime: null,
+    sources: candidates.flatMap((candidate) => candidate.sources),
+    defaults: Object.values(RUNTIME_ADAPTERS).map((adapter) => adapter.defaultPaths()),
+    notes: [
+      "No supported local runtime sources were detected.",
+      "Auto-detection checked both OpenClaw and Hermes local defaults.",
+      "Use --runtime openclaw or --runtime hermes with --log-file / --sessions-dir when you want to point Xerg at explicit local paths."
+    ]
+  };
+}
+function buildAutoAmbiguousDoctorReport(candidates) {
+  return {
+    canAudit: false,
+    mode: "ambiguous",
+    runtime: null,
+    sources: candidates.flatMap((candidate) => candidate.sources),
+    defaults: Object.values(RUNTIME_ADAPTERS).map((adapter) => adapter.defaultPaths()),
+    notes: [
+      "Both OpenClaw and Hermes local sources were detected.",
+      "Re-run doctor with --runtime openclaw or --runtime hermes to choose the local runtime explicitly."
+    ]
+  };
+}
+function buildExplicitNoDataError(options, hintedRuntime) {
+  const commandPrefix = options.commandPrefix ?? "xerg";
+  if (hintedRuntime) {
+    return getRuntimeAdapter(hintedRuntime).noDataError(commandPrefix);
+  }
+  return `No supported local runtime sources were detected. Run \`${commandPrefix} doctor\`, or use --runtime openclaw / --runtime hermes with --log-file / --sessions-dir.`;
+}
+function buildExplicitNoDataDoctorReport(candidates, hintedRuntime) {
+  if (hintedRuntime) {
+    const adapter = getRuntimeAdapter(hintedRuntime);
     return {
-      key,
-      spendUsd: Number(value.spendUsd.toFixed(6)),
-      callCount: value.callCount,
-      observedShare: Number(observedShare.toFixed(4))
+      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.`
+      ]
     };
-  }).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();
+  }
   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
-        }))
-      )
-    ),
-    findings: input.findings,
+    canAudit: false,
+    mode: "none",
+    runtime: null,
+    sources: candidates.flatMap((candidate) => candidate.sources),
+    defaults: Object.values(RUNTIME_ADAPTERS).map((adapter) => adapter.defaultPaths()),
     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
+      "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 getRuntimeProductName(runtime) {
+  return getRuntimeAdapter(runtime).productName;
+}
+async function resolveRuntimeCandidates(options) {
+  return Promise.all(
+    Object.values(RUNTIME_ADAPTERS).map(
+      (adapter) => probeRuntimeCandidate(adapter, options)
+    )
+  );
+}
+async function resolveLocalAgentRuntime(options) {
+  const requestedRuntime = options.runtime ?? "auto";
+  if (requestedRuntime !== "auto") {
+    const adapter = getRuntimeAdapter(requestedRuntime);
+    const sources = await adapter.detectSources(options);
+    return {
+      adapter,
+      sources
+    };
+  }
+  const 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);
 }
-async function auditOpenClaw(options) {
-  options.onProgress?.("Scanning for OpenClaw source files...");
+function validateCompareOptions(options) {
   if (options.compare && options.noDb) {
     throw new Error(
       "The --compare flag needs local snapshot history. Remove --no-db or provide --db <path>."
     );
   }
-  const sources = await detectOpenClawSources(options);
+}
+function maybeAttachComparison(options, dbPath, summary) {
+  if (!options.compare || !dbPath) {
+    return;
+  }
+  options.onProgress?.("Looking for a comparable baseline audit...");
+  const baseline = readLatestComparableAuditSummary({
+    dbPath,
+    comparisonKey: summary.comparisonKey,
+    currentAuditId: summary.auditId
+  });
+  if (!baseline) {
+    summary.notes = [
+      ...summary.notes,
+      "No prior comparable audit was found. Run the same audit again after a fix to unlock before/after deltas."
+    ];
+    return;
+  }
+  summary.comparison = buildAuditComparison(summary, baseline);
+  if (hasPricingCoverageChange(summary.pricingCoverage, baseline.pricingCoverage)) {
+    summary.notes = [
+      ...summary.notes,
+      "Pricing coverage changed versus the baseline audit. Spend deltas are directional because different Cursor aliases were priced in each run."
+    ];
+  }
+}
+function persistLocalSnapshot(summary, runs, dbPath, onProgress) {
+  if (!dbPath) {
+    onProgress?.("Skipping local snapshot persistence (--no-db).");
+    return;
+  }
+  onProgress?.(`Persisting local snapshot to ${dbPath}...`);
+  persistAudit(
+    {
+      summary,
+      runs,
+      pricingCatalog: PRICING_CATALOG
+    },
+    dbPath
+  );
+  onProgress?.("Local snapshot stored.");
+}
+function hasPricingCoverageChange(current, baseline) {
+  if (!current && !baseline) {
+    return false;
+  }
+  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 auditResolvedRuntime(runtime, options, detectedSources) {
+  const adapter = getRuntimeAdapter(runtime);
+  options.onProgress?.(`Scanning for ${adapter.productName} source files...`);
+  validateCompareOptions(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 = buildFindings(runs);
+  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,
     sources,
     since: options.since,
     dbPath,
     comparisonKeyOverride: options.comparisonKeyOverride
   });
-  if (options.compare && dbPath) {
-    options.onProgress?.("Looking for a comparable baseline audit...");
-    const baseline = readLatestComparableAuditSummary({
-      dbPath,
-      comparisonKey: summary.comparisonKey,
-      currentAuditId: summary.auditId
-    });
-    if (baseline) {
-      summary.comparison = buildAuditComparison(summary, baseline);
-    } else {
-      summary.notes = [
-        ...summary.notes,
-        "No prior comparable audit was found. Run the same audit again after a fix to unlock before/after deltas."
-      ];
-    }
-  }
-  if (dbPath) {
-    options.onProgress?.(`Persisting local snapshot to ${dbPath}...`);
-    persistAudit(
-      {
-        summary,
-        runs,
-        pricingCatalog: PRICING_CATALOG
-      },
-      dbPath
-    );
-    options.onProgress?.("Local snapshot stored.");
-  } else {
-    options.onProgress?.("Skipping local snapshot persistence (--no-db).");
-  }
+  maybeAttachComparison(options, dbPath, summary);
+  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);
+  if (!options.cursorUsageCsv) {
+    throw new Error("No Cursor usage CSV was provided. Use --cursor-usage-csv <path>.");
+  }
+  const parsed = readCursorUsageCsv(options.cursorUsageCsv);
+  options.onProgress?.(`Loaded Cursor usage CSV: ${parsed.source.path}`);
+  options.onProgress?.("Normalizing Cursor usage rows...");
+  const normalized = normalizeCursorUsageCsv({
+    source: parsed.source,
+    rows: parsed.rows,
+    hasObservedCostRows: parsed.hasObservedCostRows,
+    since: options.since
+  });
+  options.onProgress?.(
+    `Normalized ${normalized.runs.length} usage row${normalized.runs.length === 1 ? "" : "s"}.`
+  );
+  options.onProgress?.("Computing Cursor-specific findings...");
+  const { findings, wasteAttributions } = buildCursorUsageFindings(normalized.runs);
+  const dbPath = options.noDb ? void 0 : options.dbPath ?? getDefaultDbPath();
+  options.onProgress?.("Building audit summary...");
+  const summary = buildAuditSummary({
+    runtime: "cursor",
+    runs: normalized.runs,
+    findings,
+    wasteAttributions,
+    sources: [parsed.source],
+    since: options.since,
+    dbPath,
+    comparisonKeyOverride: options.comparisonKeyOverride
+  });
+  summary.pricingCoverage = normalized.pricingCoverage;
+  summary.cursorUsage = normalized.cursorUsage;
+  summary.notes = [
+    "Cursor CSV audits analyze exported usage rows rather than raw session transcripts.",
+    "OpenClaw-specific retry, loop, and session-level workflow findings are still unavailable for Cursor CSV inputs because the export does not include retries, iterations, or real workflow IDs.",
+    parsed.hasObservedCostRows ? "Numeric Cost values were used as observed spend. Included rows are treated as zero billed spend in this export mode." : "This CSV did not include numeric Cost values, so spend was estimated from local model pricing where possible."
+  ];
+  if (parsed.rows.length > 0 && normalized.runs.length === 0 && options.since) {
+    summary.notes = [
+      ...summary.notes,
+      `No Cursor usage rows matched the --since window (${options.since}).`
+    ];
+  }
+  if (normalized.pricingCoverage.unpricedCallCount > 0) {
+    const aliases = normalized.pricingCoverage.topUnpricedModels.map((model) => model.key).join(", ");
+    summary.notes = [
+      ...summary.notes,
+      `Some Cursor aliases do not have full local pricing coverage: ${aliases || "unknown aliases"}.`
+    ];
+  }
+  maybeAttachComparison(options, dbPath, summary);
+  persistLocalSnapshot(summary, normalized.runs, dbPath, options.onProgress);
   return summary;
 }
 
@@ -1605,6 +3216,26 @@ var templatesByKind = {
     suggestedChangeFn: () => ({
       strategy: "cadence-review"
     })
+  },
+  "cache-carryover": {
+    actionType: "prompt-trim",
+    titleFn: () => "Summarize and reset long Cursor chats",
+    descriptionFn: (f) => `${f.summary} Create a compact recall summary, start a fresh chat, and carry forward only the facts the model actually needs.`,
+    suggestedChangeFn: (f) => ({
+      strategy: "conversation-reset",
+      cacheReadShare: f.details.cacheReadShare,
+      totalCacheReadTokens: f.details.totalCacheReadTokens
+    })
+  },
+  "max-mode-concentration": {
+    actionType: "model-switch",
+    titleFn: () => "Reserve max mode for the hardest Cursor turns",
+    descriptionFn: (f) => `${f.summary} Try a two-pass workflow: standard mode first, then escalate only the prompts that truly need max mode.`,
+    suggestedChangeFn: (f) => ({
+      strategy: "tiered-routing",
+      maxModeSpendShare: f.details.maxModeSpendShare,
+      maxModeCallCount: f.details.maxModeCallCount
+    })
   }
 };
 function extractWorkflow(finding) {
@@ -1658,10 +3289,16 @@ function formatPercentDelta(value) {
   const sign = points > 0 ? "+" : "";
   return `${sign}${points.toFixed(0)} pts`;
 }
+function formatCount(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
 function formatUsdDelta(value) {
   const sign = value > 0 ? "+" : "";
   return `${sign}${formatUsd(value)}`;
 }
+function isCursorUsageSummary(summary) {
+  return summary.sourceFiles.some((source) => source.kind === "cursor-usage-csv");
+}
 function topRows(rows, limit = 5) {
   return rows.slice(0, limit).map((row) => {
     return `- ${row.key}: ${formatUsd(row.spendUsd)} (${formatPercent(row.observedShare)} observed)`;
@@ -1763,27 +3400,51 @@ function renderCompareBlock(summary) {
     ...findingChanges.length > 0 ? findingChanges : ["- High-confidence waste changes: none"]
   ];
 }
+function renderDailyTrendRows(spendByDay, wasteByDay) {
+  if (spendByDay.length <= 1) {
+    return [];
+  }
+  const wasteByDate = new Map(wasteByDay.map((row) => [row.date, row.wasteUsd]));
+  return [
+    "## Daily trend",
+    ...spendByDay.map((row) => {
+      const wasteUsd = wasteByDate.get(row.date) ?? 0;
+      return `- ${row.date}: ${formatUsd(row.spendUsd)} spend, ${formatUsd(wasteUsd)} waste`;
+    })
+  ];
+}
 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}`),
@@ -1791,7 +3452,177 @@ function renderDoctorReport(report, options) {
   ];
   return sections.join("\n");
 }
+function renderCursorDoctorReport(report) {
+  const status = report.canAudit ? "Cursor usage CSV detected." : "Cursor usage CSV is not ready.";
+  return [
+    "# Xerg doctor [cursor csv]",
+    "",
+    status,
+    "",
+    `File: ${report.filePath || "(not provided)"}`,
+    `Rows: ${formatCount(report.rowCount)}`,
+    `Date range: ${report.dateRange ? `${report.dateRange.start} -> ${report.dateRange.end}` : "unavailable"}`,
+    "",
+    "## Pricing coverage",
+    `- Priced rows: ${formatCount(report.pricingCoverage.pricedCallCount)}`,
+    `- Unpriced rows: ${formatCount(report.pricingCoverage.unpricedCallCount)}`,
+    `- Priced tokens: ${formatCount(report.pricingCoverage.pricedTokenCount)}`,
+    `- Unpriced tokens: ${formatCount(report.pricingCoverage.unpricedTokenCount)}`,
+    ...report.pricingCoverage.topUnpricedModels.length > 0 ? report.pricingCoverage.topUnpricedModels.map(
+      (model) => `- Unpriced model: ${model.key} (${formatCount(model.totalTokens)} tokens across ${formatCount(model.callCount)} row${model.callCount === 1 ? "" : "s"})`
+    ) : ["- Unpriced model: none"],
+    "",
+    "## Notes",
+    ...report.notes.map((note) => `- ${note}`)
+  ].join("\n");
+}
+function renderCursorModeRows(rows) {
+  if (rows.length === 0) {
+    return ["- none"];
+  }
+  return rows.map((row) => {
+    return `- ${row.key}: ${formatCount(row.callCount)} row${row.callCount === 1 ? "" : "s"}, ${formatCount(row.totalTokens)} tokens, ${formatUsd(row.estimatedSpendUsd)} spend`;
+  });
+}
+function renderCursorModelRows(rows) {
+  if (rows.length === 0) {
+    return ["- none"];
+  }
+  return rows.slice(0, 8).map((row) => {
+    const coverage = row.unpricedCallCount === 0 ? `${formatUsd(row.estimatedSpendUsd)} spend` : row.pricedCallCount === 0 ? "unpriced" : `${formatUsd(row.estimatedSpendUsd)} spend, ${formatCount(row.unpricedCallCount)} unpriced row${row.unpricedCallCount === 1 ? "" : "s"}`;
+    return `- ${row.key}: ${formatCount(row.callCount)} row${row.callCount === 1 ? "" : "s"}, ${formatCount(row.totalTokens)} tokens, ${coverage}`;
+  });
+}
+function renderCursorPricingCoverage(summary) {
+  const coverage = summary.pricingCoverage;
+  if (!coverage) {
+    return ["- Pricing coverage unavailable"];
+  }
+  return [
+    `- Priced rows: ${formatCount(coverage.pricedCallCount)}`,
+    `- Unpriced rows: ${formatCount(coverage.unpricedCallCount)}`,
+    `- Priced tokens: ${formatCount(coverage.pricedTokenCount)}`,
+    `- Unpriced tokens: ${formatCount(coverage.unpricedTokenCount)}`,
+    ...coverage.topUnpricedModels.length > 0 ? coverage.topUnpricedModels.map(
+      (model) => `- Unpriced model: ${model.key} (${formatCount(model.totalTokens)} tokens across ${formatCount(model.callCount)} row${model.callCount === 1 ? "" : "s"})`
+    ) : ["- Unpriced model: none"]
+  ];
+}
+function renderCursorCompareBlock(summary) {
+  if (!summary.comparison) {
+    return [];
+  }
+  const comparison = summary.comparison;
+  const modeSwing = comparison.workflowDeltas[0];
+  const modelSwing = comparison.modelDeltas[0];
+  return [
+    "## Before / after",
+    `Compared against ${comparison.baselineGeneratedAt}`,
+    `- Total spend: ${formatUsd(comparison.baselineTotalSpendUsd)} -> ${formatUsd(summary.totalSpendUsd)} (${formatUsdDelta(comparison.deltaTotalSpendUsd)})`,
+    `- Rows analyzed: ${formatCount(comparison.baselineRunCount)} -> ${formatCount(summary.runCount)} (${comparison.deltaRunCount > 0 ? "+" : ""}${comparison.deltaRunCount})`,
+    `- Usage rows with pricing: ${formatCount(summary.pricingCoverage?.pricedCallCount ?? 0)}`,
+    modeSwing ? `- Mode swing to inspect: ${describeSpendDelta(modeSwing)}` : "- Mode swing to inspect: none",
+    modelSwing ? `- Model swing to inspect: ${describeSpendDelta(modelSwing)}` : "- Model swing to inspect: none"
+  ];
+}
+function renderCursorTerminalSummary(summary) {
+  const usage = summary.cursorUsage;
+  return [
+    "# Xerg audit [cursor csv]",
+    "",
+    `Total spend: ${formatUsd(summary.totalSpendUsd)}`,
+    `Observed spend: ${formatUsd(summary.observedSpendUsd)}`,
+    `Estimated spend: ${formatUsd(summary.estimatedSpendUsd)}`,
+    `Rows analyzed: ${formatCount(summary.runCount)}`,
+    `Usage rows with pricing: ${formatCount(summary.pricingCoverage?.pricedCallCount ?? 0)} / ${formatCount(summary.runCount)}`,
+    `Total tokens: ${formatCount(usage?.totalTokens ?? 0)}`,
+    `Structural waste identified: ${formatUsd(summary.wasteSpendUsd)} (${formatPercent(summary.structuralWasteRate)})`,
+    `Potential impact surfaced: ${formatUsd(summary.opportunitySpendUsd)}`,
+    "",
+    "## Token mix",
+    `- Input tokens: ${formatCount(usage?.totalInputTokens ?? 0)}`,
+    `- Output tokens: ${formatCount(usage?.totalOutputTokens ?? 0)}`,
+    `- Cache read tokens: ${formatCount(usage?.totalCacheReadTokens ?? 0)}`,
+    `- Input (cache write): ${formatCount(usage?.totalInputWithCacheWriteTokens ?? 0)}`,
+    `- Input (no cache write): ${formatCount(usage?.totalInputWithoutCacheWriteTokens ?? 0)}`,
+    "",
+    "## Max mode usage",
+    ...renderCursorModeRows(usage?.modes ?? []),
+    "",
+    "## Model mix",
+    ...renderCursorModelRows(usage?.models ?? []),
+    "",
+    "## Pricing coverage",
+    ...renderCursorPricingCoverage(summary),
+    "",
+    ...renderDailyTrendRows(summary.spendByDay, summary.wasteByDay),
+    ...summary.spendByDay.length > 1 ? [""] : [],
+    "## Waste taxonomy",
+    "Structural waste",
+    ...renderTaxonomyRows(summary.wasteByKind, "No confirmed waste buckets detected."),
+    "Savings opportunities",
+    ...renderTaxonomyRows(
+      summary.opportunityByKind,
+      "No opportunity buckets detected.",
+      "(directional)"
+    ),
+    "",
+    "## Findings",
+    ...renderFindingList(summary.findings, "none detected"),
+    "",
+    ...renderCursorCompareBlock(summary),
+    ...summary.comparison ? [""] : [],
+    "## Notes",
+    ...summary.notes.map((note) => `- ${note}`)
+  ].join("\n");
+}
+function renderCursorMarkdownSummary(summary) {
+  const usage = summary.cursorUsage;
+  return [
+    "# Xerg Cursor CSV Audit",
+    "",
+    `- Generated: ${summary.generatedAt}`,
+    `- Total spend: ${formatUsd(summary.totalSpendUsd)}`,
+    `- Observed spend: ${formatUsd(summary.observedSpendUsd)}`,
+    `- Estimated spend: ${formatUsd(summary.estimatedSpendUsd)}`,
+    `- Structural waste identified: ${formatUsd(summary.wasteSpendUsd)} (${formatPercent(summary.structuralWasteRate)})`,
+    `- Potential impact surfaced: ${formatUsd(summary.opportunitySpendUsd)}`,
+    `- Rows analyzed: ${formatCount(summary.runCount)}`,
+    `- Usage rows with pricing: ${formatCount(summary.pricingCoverage?.pricedCallCount ?? 0)} / ${formatCount(summary.runCount)}`,
+    `- Total tokens: ${formatCount(usage?.totalTokens ?? 0)}`,
+    "",
+    "## Token mix",
+    `- Input tokens: ${formatCount(usage?.totalInputTokens ?? 0)}`,
+    `- Output tokens: ${formatCount(usage?.totalOutputTokens ?? 0)}`,
+    `- Cache read tokens: ${formatCount(usage?.totalCacheReadTokens ?? 0)}`,
+    "",
+    "## Max mode usage",
+    ...renderCursorModeRows(usage?.modes ?? []),
+    "",
+    "## Model mix",
+    ...renderCursorModelRows(usage?.models ?? []),
+    "",
+    "## Pricing coverage",
+    ...renderCursorPricingCoverage(summary),
+    "",
+    ...renderDailyTrendRows(summary.spendByDay, summary.wasteByDay),
+    ...summary.spendByDay.length > 1 ? [""] : [],
+    ...renderTaxonomyBlock(summary),
+    "",
+    "## Findings",
+    ...summary.findings.slice(0, 10).map((finding) => {
+      return `- **${finding.title}** (${finding.classification}, ${finding.confidence}) \u2014 ${finding.summary} Estimated impact: ${formatUsd(finding.costImpactUsd)}.`;
+    }),
+    ...summary.comparison ? ["", ...renderCursorCompareBlock(summary)] : [],
+    "",
+    "## Notes",
+    ...summary.notes.map((note) => `- ${note}`)
+  ].join("\n");
+}
 function renderTerminalSummary(summary) {
+  if (isCursorUsageSummary(summary)) {
+    return renderCursorTerminalSummary(summary);
+  }
   const wasteFindings = summary.findings.filter((finding) => finding.classification === "waste");
   const opportunityFindings = summary.findings.filter(
     (finding) => finding.classification === "opportunity"
@@ -1817,6 +3648,8 @@ function renderTerminalSummary(summary) {
     "## Top models",
     ...topRows(summary.spendByModel),
     "",
+    ...renderDailyTrendRows(summary.spendByDay, summary.wasteByDay),
+    ...summary.spendByDay.length > 1 ? [""] : [],
     "## High-confidence waste",
     ...renderFindingList(wasteFindings, "none detected"),
     "",
@@ -1838,6 +3671,9 @@ function renderTerminalSummary(summary) {
   ].join("\n");
 }
 function renderMarkdownSummary(summary) {
+  if (isCursorUsageSummary(summary)) {
+    return renderCursorMarkdownSummary(summary);
+  }
   const lines = [
     "# Xerg Audit Report",
     "",
@@ -1855,6 +3691,9 @@ function renderMarkdownSummary(summary) {
     "## Top workflows",
     ...topRows(summary.spendByWorkflow),
     "",
+    ...renderDailyTrendRows(summary.spendByDay, summary.wasteByDay),
+    ...summary.spendByDay.length > 1 ? [""] : [],
+    "",
     "## Findings",
     ...summary.findings.slice(0, 10).map((finding) => {
       return `- **${finding.title}** (${finding.classification}, ${finding.confidence}) \u2014 ${finding.summary} Estimated impact: ${formatUsd(finding.costImpactUsd)}.`;
@@ -1924,6 +3763,8 @@ function toWirePayload(summary, meta) {
       opportunityByKind: summary.opportunityByKind,
       spendByWorkflow: summary.spendByWorkflow,
       spendByModel: summary.spendByModel,
+      spendByDay: summary.spendByDay,
+      wasteByDay: summary.wasteByDay,
       findings: summary.findings.map(toWireFinding),
       notes: summary.notes,
       comparison: summary.comparison ? toWireComparison(summary.comparison) : null
@@ -1996,17 +3837,17 @@ async function pushAudit(payload, config) {
 }
 
 // src/push/config.ts
-import { readFileSync as readFileSync3 } 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 readFileSync2, 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();
@@ -2019,7 +3860,7 @@ function loadStoredCredentials() {
   const credPath = getCredentialsPath();
   try {
     if (!existsSync(credPath)) return null;
-    const raw = readFileSync2(credPath, "utf8");
+    const raw = readFileSync4(credPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.token || null;
   } catch {
@@ -2039,7 +3880,7 @@ function clearCredentials() {
 
 // src/push/config.ts
 var DEFAULT_API_URL = "https://api.xerg.ai";
-var CONFIG_PATH = join4(homedir3(), ".xerg", "config.json");
+var CONFIG_PATH = join5(homedir4(), ".xerg", "config.json");
 function loadPushConfig() {
   const envKey = process.env.XERG_API_KEY;
   const envUrl = process.env.XERG_API_URL;
@@ -2050,7 +3891,7 @@ function loadPushConfig() {
     };
   }
   try {
-    const raw = readFileSync3(CONFIG_PATH, "utf8");
+    const raw = readFileSync5(CONFIG_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.apiKey) {
       return {
@@ -2073,12 +3914,15 @@ Get your key at https://xerg.ai/dashboard/settings`
   );
 }
 
+// src/source-meta.ts
+import { hostname } from "os";
+
 // src/transport/ssh.ts
 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) {
@@ -2087,7 +3931,7 @@ function hashString(input) {
 function sshArgs(source) {
   const args = [];
   if (source.identityFile) {
-    const resolved = source.identityFile.replace(/^~/, homedir4());
+    const resolved = source.identityFile.replace(/^~/, homedir5());
     args.push("-i", resolved);
   }
   args.push("-o", "BatchMode=yes", "-o", "ConnectTimeout=10");
@@ -2096,7 +3940,7 @@ function sshArgs(source) {
 function rsyncSshCommand(source) {
   const parts = ["ssh"];
   if (source.identityFile) {
-    const resolved = source.identityFile.replace(/^~/, homedir4());
+    const resolved = source.identityFile.replace(/^~/, homedir5());
     parts.push(`-i "${resolved}"`);
   }
   parts.push("-o BatchMode=yes", "-o ConnectTimeout=10");
@@ -2184,7 +4028,7 @@ function rsyncPull(opts) {
       if (status !== 0 || !stdout) return false;
       const files = stdout.split("\n").filter(Boolean);
       if (files.length === 0) return false;
-      const tmpFile = join5(tmpdir(), `xerg-filelist-${hashString(opts.remotePath)}`);
+      const tmpFile = join6(tmpdir(), `xerg-filelist-${hashString(opts.remotePath)}`);
       const relativePaths = files.map(
         (f) => f.startsWith(opts.remotePath) ? f.slice(opts.remotePath.length).replace(/^\//, "") : f
       );
@@ -2233,12 +4077,12 @@ function pullDirectory(opts) {
 }
 function resolveLocalPath(source, keepFiles) {
   if (keepFiles) {
-    const cacheDir = join5(homedir4(), ".xerg", "remote-cache", source.name);
+    const cacheDir = join6(homedir5(), ".xerg", "remote-cache", source.name);
     mkdirSync4(cacheDir, { recursive: true });
     return cacheDir;
   }
   const hash = hashString(`${source.host}:${Date.now()}`);
-  const tmpPath = join5(tmpdir(), `xerg-remote-${hash}`);
+  const tmpPath = join6(tmpdir(), `xerg-remote-${hash}`);
   mkdirSync4(tmpPath, { recursive: true });
   return tmpPath;
 }
@@ -2290,8 +4134,8 @@ async function pullRemoteFiles(opts) {
     useRsync ? "Local rsync detected. Xerg will prefer rsync and fall back to tar over SSH if needed." : "Local rsync not detected. Xerg will pull files with tar over SSH."
   );
   const localBase = resolveLocalPath(source, keepFiles);
-  const gatewayDir = join5(localBase, "gateway");
-  const sessionsDir = join5(localBase, "sessions");
+  const gatewayDir = join6(localBase, "gateway");
+  const sessionsDir = join6(localBase, "sessions");
   const remoteLogPath = source.logFile ?? DEFAULT_GATEWAY_DIR;
   const remoteSessionsPath = source.sessionsDir ?? DEFAULT_SESSIONS_DIR;
   const { stdout: expandedSessions } = sshExec(source, `eval echo ${remoteSessionsPath}`);
@@ -2483,8 +4327,8 @@ function formatBytes(bytes) {
 import { execSync as execSync2, spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { mkdirSync as mkdirSync5, rmSync as rmSync3 } from "fs";
-import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
-import { join as join6 } from "path";
+import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
+import { join as join7 } from "path";
 var DEFAULT_GATEWAY_DIR2 = "/tmp/openclaw";
 var DEFAULT_SESSIONS_DIR2 = "~/.openclaw/agents";
 var ALTERNATE_SESSION_PATHS = ["/data/.clawdbot/agents/main/sessions"];
@@ -2557,13 +4401,13 @@ function tarRailwayPull(opts) {
 }
 function resolveLocalPath2(source, keepFiles) {
   if (keepFiles) {
-    const cacheDir = join6(homedir5(), ".xerg", "remote-cache", source.name);
+    const cacheDir = join7(homedir6(), ".xerg", "remote-cache", source.name);
     mkdirSync5(cacheDir, { recursive: true });
     return cacheDir;
   }
   const identity = source.railway ? `railway:${source.railway.projectId}:${Date.now()}` : `${source.name}:${Date.now()}`;
   const hash = hashString2(identity);
-  const tmpPath = join6(tmpdir2(), `xerg-remote-${hash}`);
+  const tmpPath = join7(tmpdir2(), `xerg-remote-${hash}`);
   mkdirSync5(tmpPath, { recursive: true });
   return tmpPath;
 }
@@ -2634,8 +4478,8 @@ async function pullRemoteFilesRailway(opts) {
   }
   onProgress?.("Railway service reachable.");
   const localBase = resolveLocalPath2(source, keepFiles);
-  const gatewayDir = join6(localBase, "gateway");
-  const sessionsDir = join6(localBase, "sessions");
+  const gatewayDir = join7(localBase, "gateway");
+  const sessionsDir = join7(localBase, "sessions");
   const remoteLogPath = source.logFile ?? DEFAULT_GATEWAY_DIR2;
   onProgress?.("Checking Railway default paths for gateway logs and sessions...");
   const logCheck = checkRemotePath(remoteLogPath, target);
@@ -2864,13 +4708,13 @@ function formatBytes2(bytes) {
 }
 
 // src/transport/config.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve3 } from "path";
 function loadRemoteConfig(configPath) {
-  const resolved = resolve2(configPath);
+  const resolved = resolve3(configPath);
   let raw;
   try {
-    raw = readFileSync4(resolved, "utf8");
+    raw = readFileSync6(resolved, "utf8");
   } catch {
     throw new Error(`Cannot read remote config at ${resolved}`);
   }
@@ -2941,11 +4785,98 @@ 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: `${productName} - ${localHost}`,
+    sourceHost: localHost
+  };
+}
+function buildRemotePushSourceMeta(source) {
+  if (source.transport === "railway") {
+    return {
+      environment: "railway",
+      sourceId: isGeneratedRailwayName(source.name) ? RAILWAY_SOURCE_ID : `OpenClaw - ${source.name}`,
+      sourceHost: isGeneratedRailwayName(source.host) ? "Railway" : source.host
+    };
+  }
+  return {
+    environment: "remote",
+    sourceId: `OpenClaw - ${source.name}`,
+    sourceHost: resolveRemoteHost(source.host)
+  };
+}
+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")) {
+    return buildLocalPushSourceMeta("cursor", localHost);
+  }
+  if (isRailwayComparisonKey(comparisonKey)) {
+    return {
+      environment: "railway",
+      sourceId: RAILWAY_SOURCE_ID,
+      sourceHost: "Railway"
+    };
+  }
+  const remoteHost = parseRemoteHostFromComparisonKey(comparisonKey);
+  if (remoteHost) {
+    return {
+      environment: "remote",
+      sourceId: `OpenClaw - ${remoteHost}`,
+      sourceHost: remoteHost
+    };
+  }
+  if (summary.runtime === "hermes") {
+    return buildLocalPushSourceMeta("hermes", localHost);
+  }
+  return buildLocalPushSourceMeta("openclaw", localHost);
+}
+function isGeneratedRailwayName(name) {
+  return name === "railway-linked" || /^railway-[a-z0-9]{8}$/i.test(name);
+}
+function isRailwayComparisonKey(comparisonKey) {
+  return comparisonKey.startsWith("railway:") || comparisonKey.startsWith("railway-linked:");
+}
+function parseRemoteHostFromComparisonKey(comparisonKey) {
+  const parts = comparisonKey.split(":");
+  if (parts.length < 3) {
+    return null;
+  }
+  const target = parts.slice(0, -2).join(":");
+  if (!target) {
+    return null;
+  }
+  return resolveRemoteHost(target);
+}
+function resolveRemoteHost(target) {
+  const parsed = parseRemoteTarget(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);
@@ -2958,6 +4889,9 @@ async function runAuditCommand(options) {
   if (options.dryRun && !options.push) {
     throw new Error("--dry-run requires --push.");
   }
+  validateRuntimeOption(options.runtime);
+  validateCursorUsageCsvOptions(options);
+  validateHermesLocalOnly(options);
   const remoteFlags = [options.remote, options.remoteConfig, options.railway].filter(
     Boolean
   ).length;
@@ -3002,7 +4936,29 @@ function buildRailwayTarget(options) {
   return void 0;
 }
 async function runLocalAudit(options, logger) {
-  logger.verbose("Running a local audit.");
+  if (options.cursorUsageCsv) {
+    logger.verbose("Running a local Cursor usage CSV audit.");
+    logger.verbose(`Using Cursor usage CSV: ${options.cursorUsageCsv}`);
+    const summary2 = await auditCursorUsageCsv({
+      cursorUsageCsv: options.cursorUsageCsv,
+      since: options.since,
+      compare: options.compare,
+      dbPath: options.db,
+      noDb: options.noDb,
+      commandPrefix: options.commandPrefix,
+      onProgress: logger.verbose
+    });
+    renderOutput(summary2, options);
+    if (options.push) {
+      const meta = buildMeta(buildLocalPushSourceMeta("cursor"));
+      await handlePush(summary2, meta, options);
+    }
+    checkThresholds(summary2, options);
+    return;
+  }
+  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}`);
   }
@@ -3010,6 +4966,7 @@ async function runLocalAudit(options, logger) {
     logger.verbose(`Using explicit local sessions directory: ${options.sessionsDir}`);
   }
   const summary = await auditOrNoData({
+    runtime: options.runtime ?? "auto",
     logFile: options.logFile,
     sessionsDir: options.sessionsDir,
     since: options.since,
@@ -3021,10 +4978,63 @@ async function runLocalAudit(options, logger) {
   });
   renderOutput(summary, options);
   if (options.push) {
-    const meta = buildMeta({ environment: "local", sourceId: hostname(), sourceHost: hostname() });
+    const meta = buildMeta(buildLocalPushSourceMeta(summary.runtime));
     await handlePush(summary, meta, options);
   }
-  checkThresholds(summary, 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,
+    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(`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") {
@@ -3044,9 +5054,6 @@ function describeSource(source) {
   }
   return source.host;
 }
-function sourceEnvironment(source) {
-  return source.transport === "railway" ? "railway" : "remote";
-}
 async function runSingleRemoteAudit(source, options, logger) {
   logger.info(`Pulling files from ${describeSource(source)}...`);
   const pullResult = await pullFiles(
@@ -3059,6 +5066,7 @@ async function runSingleRemoteAudit(source, options, logger) {
   try {
     const comparisonKeyOverride = getComparisonKey(source);
     const summary = await auditOrNoData({
+      runtime: "openclaw",
       logFile: pullResult.logFile,
       sessionsDir: pullResult.sessionsDir,
       since: options.since,
@@ -3071,11 +5079,7 @@ async function runSingleRemoteAudit(source, options, logger) {
     });
     renderOutput(summary, options);
     if (options.push) {
-      const meta = buildMeta({
-        environment: sourceEnvironment(source),
-        sourceId: source.name,
-        sourceHost: source.host
-      });
+      const meta = buildMeta(buildRemotePushSourceMeta(source));
       await handlePush(summary, meta, options);
     }
     checkThresholds(summary, options);
@@ -3113,6 +5117,7 @@ ${errorMessages}`);
     for (const { source, pullResult } of results) {
       const comparisonKeyOverride = getComparisonKey(source);
       const summary = await auditOrNoData({
+        runtime: "openclaw",
         logFile: pullResult.logFile,
         sessionsDir: pullResult.sessionsDir,
         since: options.since,
@@ -3163,11 +5168,7 @@ ${"\u2550".repeat(60)}
     }
     if (options.push) {
       for (const { source, summary } of summaries) {
-        const meta = buildMeta({
-          environment: sourceEnvironment(source),
-          sourceId: source.name,
-          sourceHost: source.host
-        });
+        const meta = buildMeta(buildRemotePushSourceMeta(source));
         await handlePush(summary, meta, options);
       }
     }
@@ -3180,18 +5181,9 @@ ${"\u2550".repeat(60)}
     }
   }
 }
-function readCliVersion() {
-  try {
-    const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
 function buildMeta(input) {
   return {
-    cliVersion: readCliVersion(),
+    cliVersion: getCliVersion(),
     sourceId: input.sourceId,
     sourceHost: input.sourceHost,
     environment: input.environment
@@ -3266,6 +5258,9 @@ function cleanupPullResult(pullResult, keepFiles) {
 // src/commands/doctor.ts
 async function runDoctorCommand(options) {
   const logger = createCliLogger({ verbose: options.verbose });
+  validateRuntimeOption2(options.runtime);
+  validateCursorUsageCsvOptions2(options);
+  validateHermesLocalOnly2(options);
   if (options.railway) {
     logger.verbose("Inspecting Railway audit readiness.");
     const railwayTarget = buildRailwayTarget2(options);
@@ -3291,14 +5286,28 @@ async function runDoctorCommand(options) {
 `);
     return;
   }
-  logger.verbose("Inspecting local OpenClaw audit readiness.");
+  if (options.cursorUsageCsv) {
+    logger.verbose("Inspecting local Cursor usage CSV audit readiness.");
+    logger.verbose(`Using Cursor usage CSV: ${options.cursorUsageCsv}`);
+    const report2 = await doctorCursorUsageCsv({
+      cursorUsageCsv: options.cursorUsageCsv,
+      onProgress: logger.verbose
+    });
+    process.stdout.write(`${renderCursorDoctorReport(report2)}
+`);
+    return;
+  }
+  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
@@ -3306,6 +5315,55 @@ 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,
+    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(`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 {
@@ -3515,12 +5573,12 @@ async function openBrowser(url) {
   };
   const cmd = commands[platform2()];
   if (!cmd) return;
-  return new Promise((resolve3) => {
-    exec(`${cmd} ${JSON.stringify(url)}`, () => resolve3());
+  return new Promise((resolve4) => {
+    exec(`${cmd} ${JSON.stringify(url)}`, () => resolve4());
   });
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function colorBold(text) {
   return process.stderr.isTTY ? styleText("bold", text) : text;
@@ -3541,8 +5599,7 @@ function runLogoutCommand() {
 }
 
 // src/commands/push.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { hostname as hostname2 } from "os";
+import { readFileSync as readFileSync8 } from "fs";
 async function runPushCommand(options) {
   const payload = options.file ? loadPayloadFromFile(options.file) : loadPayloadFromCache();
   if (options.dryRun) {
@@ -3566,7 +5623,7 @@ async function runPushCommand(options) {
 function loadPayloadFromFile(filePath) {
   let raw;
   try {
-    raw = readFileSync6(filePath, "utf8");
+    raw = readFileSync8(filePath, "utf8");
   } catch {
     throw new Error(`Cannot read file: ${filePath}`);
   }
@@ -3600,38 +5657,155 @@ function loadPayloadFromCache() {
     );
   }
   const latest = summaries[0];
-  const meta = buildMeta2();
+  const meta = buildMeta2(latest);
   process.stderr.write(
     `Using most recent cached audit: ${latest.auditId} (${latest.generatedAt})
 `
   );
   return toWirePayload(latest, meta);
 }
-function readCliVersion2() {
-  try {
-    const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-function buildMeta2() {
+function buildMeta2(summary) {
+  const sourceMeta = buildCachedPushSourceMeta(summary);
   return {
-    cliVersion: readCliVersion2(),
-    sourceId: hostname2(),
-    sourceHost: hostname2(),
-    environment: "local"
+    cliVersion: getCliVersion(),
+    sourceId: sourceMeta.sourceId,
+    sourceHost: sourceMeta.sourceHost,
+    environment: sourceMeta.environment
   };
 }
 
+// src/help.ts
+function renderRootHelp(version, display) {
+  return `${display.name} ${version}
+
+Waste intelligence for OpenClaw and Hermes workflows plus local Cursor usage CSVs.
+
+Usage:
+  ${formatCommand("<command> [options]", display.prefix)}
+
+Commands:
+  audit    Analyze OpenClaw or Hermes logs, or a local Cursor usage CSV.
+  doctor   Inspect OpenClaw or Hermes sources, or a local Cursor usage CSV.
+  push     Push a cached audit snapshot to the Xerg API.
+  login    Authenticate with the Xerg API via browser.
+  logout   Remove stored Xerg API credentials.
+
+Global options:
+  -h, --help     Show help
+  -v, --version  Show version
+`;
+}
+function renderAuditHelp(commandPrefix) {
+  return `${formatCommand("audit", commandPrefix)}
+
+Analyze OpenClaw or Hermes logs, or a local Cursor usage CSV, and produce an audit report.
+
+Usage:
+  ${formatCommand("audit [options]", commandPrefix)}
+
+Options:
+  --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
+  --json                      Render the report as JSON
+  --markdown                  Render the report as Markdown
+  --db <path>                 Custom SQLite database path
+  --no-db                     Skip local persistence
+
+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
+  --remote-config <path>      Path to a JSON file defining multiple remote sources
+  --keep-remote-files         Retain pulled files in ~/.xerg/remote-cache/ instead of using a temp directory
+
+Prerequisites:
+  SSH remote audits require ssh and rsync on your PATH.
+
+Railway options (OpenClaw only):
+  --railway                   Audit a Railway service (uses linked project by default)
+  --project <id>              Railway project ID
+  --environment <id>          Railway environment ID
+  --service <id>              Railway service ID
+
+  Railway audits require the railway CLI on your PATH.
+
+Push options:
+  --push                      Push the audit summary to the Xerg API after computing it
+  --dry-run                   With --push: print the payload to stdout without sending it
+  --verbose                   Print progress updates to stderr while the audit runs
+
+Threshold options:
+  --fail-above-waste-rate <n> Exit with code 3 if structural waste rate exceeds threshold (e.g. 0.30)
+  --fail-above-waste-usd <n>  Exit with code 3 if waste spend exceeds threshold in USD (e.g. 50)
+
+  -h, --help                  Show help
+`;
+}
+function renderPushHelp(commandPrefix) {
+  return `${formatCommand("push", commandPrefix)}
+
+Push a cached audit snapshot to the Xerg API.
+
+Usage:
+  ${formatCommand("push [options]", commandPrefix)}
+
+Options:
+  --file <path>               Push a specific snapshot file instead of the most recent cached audit
+  --dry-run                   Print the payload to stdout without sending it
+
+  -h, --help                  Show help
+
+Authentication:
+  Set XERG_API_KEY in your environment, add "apiKey" to ~/.xerg/config.json,
+  or run \`${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 or Hermes sources, or a local Cursor usage CSV, before you audit.
+
+Usage:
+  ${formatCommand("doctor [options]", commandPrefix)}
+
+Options:
+  --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, 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 (OpenClaw only):
+  --railway                   Check a Railway service (uses linked project by default)
+  --project <id>              Railway project ID
+  --environment <id>          Railway environment ID
+  --service <id>              Railway service ID
+
+  Railway checks require the railway CLI on your PATH.
+
+  -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];
 if (!command || command === "--help" || command === "-h" || command === "help") {
-  process.stdout.write(renderRootHelp(commandDisplay));
+  process.stdout.write(renderRootHelp(VERSION, commandDisplay));
   process.exit(0);
 }
 if (command === "--version" || command === "-v" || command === "version") {
@@ -3697,10 +5871,18 @@ 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;
         break;
+      case "--cursor-usage-csv":
+        options.cursorUsageCsv = readValue(arg, argv2[index + 1]);
+        index += 1;
+        break;
       case "--since":
         options.since = readValue(arg, argv2[index + 1]);
         index += 1;
@@ -3821,10 +6003,18 @@ 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;
         break;
+      case "--cursor-usage-csv":
+        options.cursorUsageCsv = readValue(arg, argv2[index + 1]);
+        index += 1;
+        break;
       case "--remote":
         options.remote = readValue(arg, argv2[index + 1]);
         index += 1;
@@ -3889,131 +6079,7 @@ function readFloat(flag, value) {
   }
   return num;
 }
-function renderRootHelp(display = commandDisplay) {
-  return `${display.name} ${VERSION}
-
-Waste intelligence for OpenClaw workflows.
-
-Usage:
-  ${formatCommand("<command> [options]", display.prefix)}
-
-Commands:
-  audit    Analyze OpenClaw logs and produce a waste intelligence report.
-  doctor   Inspect your machine for OpenClaw sources and audit readiness.
-  push     Push a cached audit snapshot to the Xerg API.
-  login    Authenticate with the Xerg API via browser.
-  logout   Remove stored Xerg API credentials.
-
-Global options:
-  -h, --help     Show help
-  -v, --version  Show version
-`;
-}
-function renderAuditHelp(commandPrefix = commandDisplay.prefix) {
-  return `${formatCommand("audit", commandPrefix)}
-
-Analyze OpenClaw logs and produce a waste intelligence 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
-  --since <duration>          Look back window such as 24h, 7d, or 30m
-  --compare                   Compare this audit to the newest compatible prior local snapshot
-  --json                      Render the report as JSON
-  --markdown                  Render the report as Markdown
-  --db <path>                 Custom SQLite database path
-  --no-db                     Skip local persistence
-
-Remote options (SSH):
-  --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
-  --remote-config <path>      Path to a JSON file defining multiple remote sources
-  --keep-remote-files         Retain pulled files in ~/.xerg/remote-cache/ instead of using a temp directory
-
-Prerequisites:
-  SSH remote audits require ssh and rsync on your PATH.
-
-Railway options:
-  --railway                   Audit a Railway service (uses linked project by default)
-  --project <id>              Railway project ID
-  --environment <id>          Railway environment ID
-  --service <id>              Railway service ID
-
-  Railway audits require the railway CLI on your PATH.
-
-Push options:
-  --push                      Push the audit summary to the Xerg API after computing it
-  --dry-run                   With --push: print the payload to stdout without sending it
-  --verbose                   Print progress updates to stderr while the audit runs
-
-Threshold options:
-  --fail-above-waste-rate <n> Exit with code 3 if structural waste rate exceeds threshold (e.g. 0.30)
-  --fail-above-waste-usd <n>  Exit with code 3 if waste spend exceeds threshold in USD (e.g. 50)
-
-  -h, --help                  Show help
-`;
-}
-function renderPushHelp(commandPrefix = commandDisplay.prefix) {
-  return `${formatCommand("push", commandPrefix)}
-
-Push a cached audit snapshot to the Xerg API.
-
-Usage:
-  ${formatCommand("push [options]", commandPrefix)}
-
-Options:
-  --file <path>               Push a specific snapshot file instead of the most recent cached audit
-  --dry-run                   Print the payload to stdout without sending it
-
-  -h, --help                  Show help
-
-Authentication:
-  Set XERG_API_KEY in your environment, add "apiKey" to ~/.xerg/config.json,
-  or run \`${formatCommand("login", commandPrefix)}\` to authenticate via browser.
-  Browser login stores a token at ~/.config/xerg/credentials.json by default.
-`;
-}
-function renderDoctorHelp(commandPrefix = commandDisplay.prefix) {
-  return `${formatCommand("doctor", commandPrefix)}
-
-Inspect your machine for OpenClaw sources and audit readiness.
-
-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
-  --verbose                   Print progress updates to stderr while doctor runs
-
-Remote options (SSH):
-  --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                   Check a Railway service (uses linked project by default)
-  --project <id>              Railway project ID
-  --environment <id>          Railway environment ID
-  --service <id>              Railway service ID
-
-  Railway checks require the railway CLI on your PATH.
-
-  -h, --help                  Show help
-`;
-}
 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(readFileSync7(packageJsonPath, "utf8"));
-  return packageJson.version ?? "0.0.0";
-}
 //# sourceMappingURL=index.js.map