@xerg/cli 0.1.9 → 0.2.0

package/dist/index.js

@@ -1,13 +1,122 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { styleText as styleText2 } from "util";
 
+// src/command-display.ts
+var PACKAGE_NAME = "@xerg/cli";
+var DEFAULT_COMMAND_PREFIX = "xerg";
+function resolveCommandDisplay(context) {
+  const runner = detectPackageExecutor(context);
+  if (!runner) {
+    return {
+      prefix: DEFAULT_COMMAND_PREFIX,
+      name: DEFAULT_COMMAND_PREFIX
+    };
+  }
+  return {
+    prefix: `${runner} ${PACKAGE_NAME}`,
+    name: PACKAGE_NAME
+  };
+}
+function formatCommand(command2, commandPrefix = resolveCommandDisplay().prefix) {
+  const suffix = Array.isArray(command2) ? command2.join(" ") : command2;
+  return suffix ? `${commandPrefix} ${suffix}` : commandPrefix;
+}
+function detectPackageExecutor(context) {
+  const env = context?.env ?? process.env;
+  const argv2 = context?.argv ?? process.argv;
+  const userAgent = normalizeSignal(env.npm_config_user_agent);
+  const execPath = normalizeSignal(env.npm_execpath);
+  const argvPath = normalizeSignal(argv2[1]);
+  const fromArgvPath = detectRunnerFromArgvPath(argvPath);
+  if (fromArgvPath) {
+    return fromArgvPath;
+  }
+  if (looksLikeInstalledCli(argvPath)) {
+    return null;
+  }
+  const fromUserAgent = detectRunnerFromSignal(userAgent);
+  if (fromUserAgent) {
+    return fromUserAgent;
+  }
+  const fromExecPath = detectRunnerFromSignal(execPath);
+  if (fromExecPath) {
+    return fromExecPath;
+  }
+  if (argvPath.includes("/_npx/") || argvPath.includes("\\_npx\\")) {
+    return "npx";
+  }
+  if (argvPath.includes("/.yarn/") && argvPath.includes("/dlx/")) {
+    return "yarn dlx";
+  }
+  if (argvPath.includes("/bunx/") || argvPath.includes("\\bunx\\")) {
+    return "bunx";
+  }
+  if (argvPath.includes("/dlx-") || argvPath.includes("\\dlx-")) {
+    return "pnpm dlx";
+  }
+  if (userAgent || execPath) {
+    return "npx";
+  }
+  return null;
+}
+function detectRunnerFromArgvPath(argvPath) {
+  if (!argvPath) {
+    return null;
+  }
+  if (argvPath.includes("/_npx/") || argvPath.includes("\\_npx\\")) {
+    return "npx";
+  }
+  if (argvPath.includes("/.yarn/") && argvPath.includes("/dlx/")) {
+    return "yarn dlx";
+  }
+  if (argvPath.includes("/bunx/") || argvPath.includes("\\bunx\\")) {
+    return "bunx";
+  }
+  if (argvPath.includes("/dlx-") || argvPath.includes("\\dlx-")) {
+    return "pnpm dlx";
+  }
+  return null;
+}
+function looksLikeInstalledCli(argvPath) {
+  if (!argvPath) {
+    return false;
+  }
+  const normalized = argvPath.replaceAll("\\", "/");
+  return normalized.endsWith("/node_modules/.bin/xerg") || normalized.includes("/node_modules/@xerg/cli/dist/index.js") || normalized.endsWith("/bin/xerg");
+}
+function detectRunnerFromSignal(signal) {
+  if (!signal) {
+    return null;
+  }
+  const tokens = signal.split(/[^a-z0-9]+/).filter(Boolean);
+  if (tokens.includes("pnpm")) {
+    return "pnpm dlx";
+  }
+  if (tokens.includes("yarn")) {
+    return "yarn dlx";
+  }
+  if (tokens.includes("bun")) {
+    return "bunx";
+  }
+  if (tokens.includes("npm")) {
+    return "npx";
+  }
+  return null;
+}
+function normalizeSignal(value) {
+  return value?.trim().toLowerCase() ?? "";
+}
+
 // src/commands/audit.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } 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";
@@ -71,6 +180,562 @@ 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",
+      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";
@@ -430,7 +1095,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) {
@@ -494,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);
   }
@@ -512,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);
 }
@@ -549,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,
@@ -576,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 {
@@ -595,7 +1260,11 @@ function hydrateAuditSummary(summary) {
     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) {
@@ -612,12 +1281,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,
@@ -662,8 +1331,8 @@ function readLatestComparableAuditSummary(input) {
 }
 
 // ../core/src/detect/openclaw.ts
-import { readdirSync, statSync } from "fs";
-import { isAbsolute, join as join2, resolve, sep } from "path";
+import { readdirSync, statSync as statSync2 } from "fs";
+import { isAbsolute, join as join2, resolve as resolve2, sep } from "path";
 
 // ../core/src/utils/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -699,7 +1368,7 @@ function getDefaultGatewayPattern() {
 // ../core/src/detect/openclaw.ts
 function toDetected(path, kind) {
   try {
-    const stats = statSync(path);
+    const stats = statSync2(path);
     if (!stats.isFile()) {
       return null;
     }
@@ -747,12 +1416,12 @@ async function detectOpenClawSources(options) {
   return detected.sort((left, right) => right.mtimeMs - left.mtimeMs);
 }
 async function collectGlobMatches(pattern, options) {
-  const baseDir = options?.cwd ? resolve(options.cwd) : isAbsolute(pattern) ? sep : process.cwd();
+  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 ? resolve(options.resolveWith, match) : match
+    (match) => options?.resolveWith ? resolve2(options.resolveWith, match) : match
   );
 }
 function collectMatchesFromSegments(currentPath, segments) {
@@ -830,7 +1499,10 @@ async function inspectOpenClawSources(options) {
   };
 }
 
-// ../core/src/findings/engine.ts
+// ../core/src/findings/cursor.ts
+function round3(value) {
+  return Number(value.toFixed(6));
+}
 function createFinding(input) {
   return {
     ...input,
@@ -839,11 +1511,125 @@ function createFinding(input) {
     )
   };
 }
-function round2(value) {
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asBoolean(value) {
+  return value === true;
+}
+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: [] };
+  }
+  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)
+      }
+    })
+  ];
+  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
+  };
+}
+
+// ../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 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();
@@ -851,8 +1637,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",
@@ -860,7 +1653,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
         }
@@ -872,8 +1665,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",
@@ -881,7 +1681,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
@@ -909,7 +1709,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",
@@ -917,10 +1717,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
             }
           })
@@ -933,7 +1733,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",
@@ -941,7 +1741,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
           }
@@ -954,7 +1754,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",
@@ -962,21 +1762,24 @@ 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 { readFileSync as readFileSync2 } from "fs";
 import { basename } from "path";
 
 // ../core/src/pricing-catalog.ts
@@ -1076,7 +1879,7 @@ function getNestedValue(input, paths) {
   }
   return null;
 }
-function asNumber(value) {
+function asNumber2(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
   }
@@ -1092,7 +1895,7 @@ function asString(value) {
   }
   return null;
 }
-function asBoolean(value) {
+function asBoolean2(value) {
   if (typeof value === "boolean") {
     return value;
   }
@@ -1117,7 +1920,7 @@ function pickMetadata(input, keys) {
 
 // ../core/src/normalize/openclaw.ts
 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) {
@@ -1129,7 +1932,7 @@ function parseJsonLines(path) {
   }
   return records;
 }
-function inferProvider(record) {
+function inferProvider2(record) {
   return asString(
     getNestedValue(record, [["provider"], ["message", "provider"], ["usage", "provider"]])
   ) ?? "unknown";
@@ -1168,7 +1971,7 @@ function inferTaskClass(record, workflow) {
   return asString(getNestedValue(record, [["task_class"], ["taskClass"], ["metadata", "taskClass"]])) ?? workflow.toLowerCase();
 }
 function extractUsage(record) {
-  const inputTokens = asNumber(
+  const inputTokens = asNumber2(
     getNestedValue(record, [
       ["input_tokens"],
       ["inputTokens"],
@@ -1180,7 +1983,7 @@ function extractUsage(record) {
       ["message", "usage", "prompt_tokens"]
     ])
   ) ?? 0;
-  const outputTokens = asNumber(
+  const outputTokens = asNumber2(
     getNestedValue(record, [
       ["output_tokens"],
       ["outputTokens"],
@@ -1192,7 +1995,7 @@ function extractUsage(record) {
       ["message", "usage", "completion_tokens"]
     ])
   ) ?? 0;
-  const observedCost = asNumber(
+  const observedCost = asNumber2(
     getNestedValue(record, [
       ["cost_usd"],
       ["costUsd"],
@@ -1210,8 +2013,8 @@ function extractUsage(record) {
     observedCost
   };
 }
-function buildCall(source, record, runId, index) {
-  const provider = inferProvider(record);
+function buildCall2(source, record, runId, index) {
+  const provider = inferProvider2(record);
   const model = inferModel(record);
   const workflow = inferWorkflow(record, source.path);
   const { inputTokens, outputTokens, observedCost } = extractUsage(record);
@@ -1219,13 +2022,13 @@ function buildCall(source, record, runId, index) {
   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}`),
@@ -1237,17 +2040,17 @@ 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(
+    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"])
@@ -1275,7 +2078,7 @@ function normalizeOpenClawSources(sources, since) {
       }
       const runKey = inferRunKey(record, workflow, index, source.path);
       const runId = sha1(`${source.path}:${runKey}`);
-      const call = buildCall(source, record, runId, index);
+      const call = buildCall2(source, record, runId, index);
       const existing = runsById.get(runId);
       if (!existing) {
         runsById.set(runId, {
@@ -1308,34 +2111,159 @@ 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/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 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);
+  return candidate.toISOString().slice(0, 10);
 }
-function buildAuditSummary(input) {
-  const callCount = input.runs.reduce((sum, run2) => sum + run2.calls.length, 0);
+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("|")}`
@@ -1375,6 +2303,8 @@ function buildAuditSummary(input) {
         }))
       )
     ),
+    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.",
@@ -1389,18 +2319,71 @@ function buildAuditSummary(input) {
 async function doctorOpenClaw(options) {
   return inspectOpenClawSources(options);
 }
-async function auditOpenClaw(options) {
-  options.onProgress?.("Scanning for OpenClaw source files...");
+async function doctorCursorUsageCsv(options) {
+  return inspectCursorUsageCsv(options);
+}
+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>."
     );
   }
+}
+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 auditOpenClaw(options) {
+  options.onProgress?.("Scanning for OpenClaw source files...");
+  validateCompareOptions(options);
   const sources = await detectOpenClawSources(options);
   if (sources.length === 0) {
     options.onProgress?.("No OpenClaw source files were detected.");
     throw new Error(
-      "No OpenClaw sources were detected. Run `xerg doctor` or provide --log-file / --sessions-dir."
+      `No OpenClaw sources were detected. Run \`${options.commandPrefix ?? "xerg"} doctor\` or provide --log-file / --sessions-dir.`
     );
   }
   options.onProgress?.(`Detected ${sources.length} source file${sources.length === 1 ? "" : "s"}.`);
@@ -1408,47 +2391,75 @@ async function auditOpenClaw(options) {
   const runs = normalizeOpenClawSources(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({
     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 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({
+    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;
 }
 
@@ -1499,6 +2510,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) {
@@ -1552,10 +2583,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)`;
@@ -1657,13 +2694,27 @@ function renderCompareBlock(summary) {
     ...findingChanges.length > 0 ? findingChanges : ["- High-confidence waste changes: none"]
   ];
 }
-function renderDoctorReport(report) {
+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 ? [] : [
     "",
     "## Next steps",
-    "- Try explicit local paths: xerg doctor --log-file /path/to/openclaw.log --sessions-dir /path/to/sessions",
-    "- Inspect an SSH host: xerg doctor --remote user@host",
-    "- Inspect a Railway service: xerg doctor --railway",
+    `- 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`,
     "- Remote audits still analyze locally after Xerg pulls the source files to your machine."
   ];
   const sections = [
@@ -1684,7 +2735,177 @@ function renderDoctorReport(report) {
   ];
   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"
@@ -1710,6 +2931,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"),
     "",
@@ -1731,6 +2954,9 @@ function renderTerminalSummary(summary) {
   ].join("\n");
 }
 function renderMarkdownSummary(summary) {
+  if (isCursorUsageSummary(summary)) {
+    return renderCursorMarkdownSummary(summary);
+  }
   const lines = [
     "# Xerg Audit Report",
     "",
@@ -1748,6 +2974,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)}.`;
@@ -1817,6 +3046,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
@@ -1889,12 +3120,12 @@ async function pushAudit(payload, config) {
 }
 
 // src/push/config.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
 
 // src/auth/credentials.ts
-import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join3 } from "path";
 function getCredentialsPath() {
@@ -1912,7 +3143,7 @@ function loadStoredCredentials() {
   const credPath = getCredentialsPath();
   try {
     if (!existsSync(credPath)) return null;
-    const raw = readFileSync2(credPath, "utf8");
+    const raw = readFileSync3(credPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.token || null;
   } catch {
@@ -1943,7 +3174,7 @@ function loadPushConfig() {
     };
   }
   try {
-    const raw = readFileSync3(CONFIG_PATH, "utf8");
+    const raw = readFileSync4(CONFIG_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.apiKey) {
       return {
@@ -1961,11 +3192,14 @@ function loadPushConfig() {
     };
   }
   throw new Error(
-    `No API key configured. Set XERG_API_KEY, add "apiKey" to ${CONFIG_PATH}, or run \`xerg login\`.
+    `No API key configured. Set XERG_API_KEY, add "apiKey" to ${CONFIG_PATH}, or run \`${formatCommand("login")}\`.
 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";
@@ -2522,7 +3756,7 @@ async function pullRemoteFilesRailway(opts) {
   const { status } = railwayExec("echo ok", target);
   if (status !== 0) {
     throw new Error(
-      `Cannot reach Railway service${target ? ` (project: ${target.projectId})` : " (linked project)"}. Check railway CLI auth and service configuration.`
+      target ? `Cannot reach Railway service ${target.serviceId} (project: ${target.projectId}). Check the provided --project / --environment / --service values and confirm the Railway CLI can reach that service.` : "Cannot reach the Railway service linked to this directory. Run `railway link` here and choose the OpenClaw app service, or pass --project / --environment / --service explicitly."
     );
   }
   onProgress?.("Railway service reachable.");
@@ -2535,7 +3769,7 @@ async function pullRemoteFilesRailway(opts) {
   const resolvedSessionsPath = findSessionsPath(target, source.sessionsDir);
   let pulledLog = false;
   let pulledSessions = false;
-  if (logCheck.exists) {
+  if (logCheck.fileCount > 0) {
     onProgress?.(`Pulling gateway logs from ${remoteLogPath}...`);
     const { stdout: isFile } = railwayExec(`test -f ${remoteLogPath} && echo file`, target);
     if (isFile === "file") {
@@ -2571,8 +3805,9 @@ async function pullRemoteFilesRailway(opts) {
     const checkedPaths = [remoteLogPath, DEFAULT_SESSIONS_DIR2, ...ALTERNATE_SESSION_PATHS].join(
       ", "
     );
+    const wrongServiceHint = target ? " Verify that the selected service is the OpenClaw app, or use --remote-log-file / --remote-sessions-dir for custom paths." : " If this directory is linked to a database or sidecar instead of the OpenClaw app, run `railway link` again and choose the app service.";
     throw new Error(
-      `No OpenClaw data found on Railway service. Checked: ${checkedPaths}. Use --remote-log-file or --remote-sessions-dir to specify custom paths.`
+      `No OpenClaw data found on Railway service. Checked: ${checkedPaths}. Use --remote-log-file or --remote-sessions-dir to specify custom paths.${wrongServiceHint}`
     );
   }
   const result = {
@@ -2635,12 +3870,12 @@ async function runRailwayDoctor(opts) {
       railwayAuthenticated: true,
       railwayAuthUser,
       serviceReachable: false,
-      serviceError: target ? `Cannot reach service ${target.serviceId}` : "Cannot reach linked service. Run: railway link",
+      serviceError: target ? `Cannot reach service ${target.serviceId} in project ${target.projectId}` : "Current directory is not linked to a reachable Railway service. Run `railway link` here and choose the OpenClaw app service, or pass --project / --environment / --service.",
       defaultPaths: emptyDefaultPaths(),
       alternateSessionPaths: [],
       notes: [
         ...notes,
-        target ? `Service unreachable (project: ${target.projectId}, service: ${target.serviceId})` : "Service unreachable. Ensure a project is linked with: railway link"
+        target ? `Service unreachable (project: ${target.projectId}, service: ${target.serviceId}). Verify the provided Railway IDs point at the OpenClaw app service.` : "Service unreachable for the current directory. Run `railway link` here and choose the OpenClaw app service, or pass explicit Railway IDs."
       ]
     };
   }
@@ -2700,9 +3935,11 @@ async function runRailwayDoctor(opts) {
     alternateSessionPaths,
     notes
   };
+  let logCheck = null;
+  let sessCheck = null;
   if (source.logFile || source.sessionsDir) {
-    const logCheck = source.logFile ? checkRemotePath(source.logFile, target) : null;
-    const sessCheck = source.sessionsDir ? checkRemotePath(source.sessionsDir, target) : null;
+    logCheck = source.logFile ? checkRemotePath(source.logFile, target) : null;
+    sessCheck = source.sessionsDir ? checkRemotePath(source.sessionsDir, target) : null;
     report.customPaths = {
       logFileExists: logCheck?.exists ?? false,
       logFilePath: source.logFile ?? "",
@@ -2725,6 +3962,12 @@ async function runRailwayDoctor(opts) {
       notes.push(`Custom sessions path ${source.sessionsDir}: not found`);
     }
   }
+  const foundOpenClawData = gateway.fileCount > 0 || sessions.fileCount > 0 || alternateSessionPaths.some((path) => path.fileCount > 0) || (logCheck?.fileCount ?? 0) > 0 || (sessCheck?.fileCount ?? 0) > 0;
+  if (!foundOpenClawData) {
+    notes.push(
+      target ? "No OpenClaw data was found on this Railway service. Verify that the selected service is the OpenClaw app, or use --remote-log-file / --remote-sessions-dir for custom paths." : "No OpenClaw data was found on the linked Railway service. If this directory is linked to a database or sidecar instead of the OpenClaw app, run `railway link` again and choose the app service."
+    );
+  }
   return report;
 }
 function emptyDefaultPaths() {
@@ -2748,13 +3991,13 @@ function formatBytes2(bytes) {
 }
 
 // src/transport/config.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync5 } 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 = readFileSync5(resolved, "utf8");
   } catch {
     throw new Error(`Cannot read remote config at ${resolved}`);
   }
@@ -2825,6 +4068,74 @@ function validateRailwayEntry(entry) {
   };
 }
 
+// src/source-meta.ts
+var RAILWAY_SOURCE_ID = "OpenClaw - Railway";
+function buildLocalPushSourceMeta(kind, localHost = hostname()) {
+  return {
+    environment: "local",
+    sourceId: `${kind === "cursor" ? "Cursor" : "OpenClaw"} - ${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()) {
+  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
+    };
+  }
+  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/commands/audit.ts
 var NO_DATA_PATTERN = /no openclaw sources were detected/i;
 async function auditOrNoData(...args) {
@@ -2842,6 +4153,7 @@ async function runAuditCommand(options) {
   if (options.dryRun && !options.push) {
     throw new Error("--dry-run requires --push.");
   }
+  validateCursorUsageCsvOptions(options);
   const remoteFlags = [options.remote, options.remoteConfig, options.railway].filter(
     Boolean
   ).length;
@@ -2886,6 +4198,26 @@ function buildRailwayTarget(options) {
   return void 0;
 }
 async function runLocalAudit(options, logger) {
+  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("Running a local audit.");
   if (options.logFile) {
     logger.verbose(`Using explicit local log file: ${options.logFile}`);
@@ -2900,15 +4232,37 @@ async function runLocalAudit(options, logger) {
     compare: options.compare,
     dbPath: options.db,
     noDb: options.noDb,
+    commandPrefix: options.commandPrefix,
     onProgress: logger.verbose
   });
   renderOutput(summary, options);
   if (options.push) {
-    const meta = buildMeta({ environment: "local", sourceId: hostname(), sourceHost: hostname() });
+    const meta = buildMeta(buildLocalPushSourceMeta("openclaw"));
     await handlePush(summary, meta, options);
   }
   checkThresholds(summary, options);
 }
+function validateCursorUsageCsvOptions(options) {
+  if (!options.cursorUsageCsv) {
+    return;
+  }
+  const conflicts = [
+    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 getComparisonKey(source) {
   if (source.transport === "railway") {
     return buildComparisonKeyForRailway(source);
@@ -2927,9 +4281,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(
@@ -2949,15 +4300,12 @@ async function runSingleRemoteAudit(source, options, logger) {
       dbPath: options.db,
       noDb: options.noDb,
       comparisonKeyOverride,
+      commandPrefix: options.commandPrefix,
       onProgress: logger.verbose
     });
     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);
@@ -3002,6 +4350,7 @@ ${errorMessages}`);
         dbPath: options.db,
         noDb: options.noDb,
         comparisonKeyOverride,
+        commandPrefix: options.commandPrefix,
         onProgress: logger.verbose
       });
       summaries.push({ name: source.name, source, summary });
@@ -3044,11 +4393,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);
       }
     }
@@ -3064,7 +4409,7 @@ ${"\u2550".repeat(60)}
 function readCliVersion() {
   try {
     const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
+    const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -3147,6 +4492,7 @@ function cleanupPullResult(pullResult, keepFiles) {
 // src/commands/doctor.ts
 async function runDoctorCommand(options) {
   const logger = createCliLogger({ verbose: options.verbose });
+  validateCursorUsageCsvOptions2(options);
   if (options.railway) {
     logger.verbose("Inspecting Railway audit readiness.");
     const railwayTarget = buildRailwayTarget2(options);
@@ -3169,6 +4515,17 @@ async function runDoctorCommand(options) {
     });
     const report2 = await runRemoteDoctor({ source, onProgress: logger.verbose });
     process.stdout.write(`${renderRemoteDoctorReport(report2)}
+`);
+    return;
+  }
+  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;
   }
@@ -3184,9 +4541,28 @@ async function runDoctorCommand(options) {
     sessionsDir: options.sessionsDir,
     onProgress: logger.verbose
   });
-  process.stdout.write(`${renderDoctorReport(report)}
+  process.stdout.write(`${renderDoctorReport(report, { commandPrefix: options.commandPrefix })}
 `);
 }
+function validateCursorUsageCsvOptions2(options) {
+  if (!options.cursorUsageCsv) {
+    return;
+  }
+  const conflicts = [
+    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 buildRailwayTarget2(options) {
   if (options.railwayProject && options.railwayEnvironment && options.railwayService) {
     return {
@@ -3308,7 +4684,7 @@ async function runLoginCommand() {
   if (existing) {
     process.stderr.write(
       `Already logged in. Credentials stored at ${getCredentialsPath()}.
-Run ${colorBold("xerg logout")} first to re-authenticate.
+Run ${colorBold(formatCommand("logout"))} first to re-authenticate.
 `
     );
     return;
@@ -3374,7 +4750,7 @@ Credentials saved to ${getCredentialsPath()}.
         continue;
       }
       if (res.status === 410) {
-        throw new Error("Device code expired. Please run `xerg login` again.");
+        throw new Error(`Device code expired. Please run \`${formatCommand("login")}\` again.`);
       }
       const body = await res.json().catch(() => ({}));
       throw new Error(body.error || `Unexpected response: HTTP ${res.status}`);
@@ -3384,7 +4760,7 @@ Credentials saved to ${getCredentialsPath()}.
       }
     }
   }
-  throw new Error("Authentication timed out. Please run `xerg login` again.");
+  throw new Error(`Authentication timed out. Please run \`${formatCommand("login")}\` again.`);
 }
 async function openBrowser(url) {
   const { exec } = await import("child_process");
@@ -3396,12 +4772,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;
@@ -3422,8 +4798,7 @@ function runLogoutCommand() {
 }
 
 // src/commands/push.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { hostname as hostname2 } from "os";
+import { readFileSync as readFileSync7 } from "fs";
 async function runPushCommand(options) {
   const payload = options.file ? loadPayloadFromFile(options.file) : loadPayloadFromCache();
   if (options.dryRun) {
@@ -3447,7 +4822,7 @@ async function runPushCommand(options) {
 function loadPayloadFromFile(filePath) {
   let raw;
   try {
-    raw = readFileSync6(filePath, "utf8");
+    raw = readFileSync7(filePath, "utf8");
   } catch {
     throw new Error(`Cannot read file: ${filePath}`);
   }
@@ -3472,16 +4847,16 @@ function loadPayloadFromCache() {
     summaries = listStoredAuditSummaries(dbPath);
   } catch {
     throw new NoDataError(
-      "No local audit database found. Run `xerg audit` first, or use `xerg push --file <path>`."
+      `No local audit database found. Run \`${formatCommand("audit")}\` first, or use \`${formatCommand("push --file <path>")}\`.`
     );
   }
   if (summaries.length === 0) {
     throw new NoDataError(
-      "No cached audit snapshots found. Run `xerg audit` first, or use `xerg push --file <path>`."
+      `No cached audit snapshots found. Run \`${formatCommand("audit")}\` first, or use \`${formatCommand("push --file <path>")}\`.`
     );
   }
   const latest = summaries[0];
-  const meta = buildMeta2();
+  const meta = buildMeta2(latest);
   process.stderr.write(
     `Using most recent cached audit: ${latest.auditId} (${latest.generatedAt})
 `
@@ -3491,27 +4866,152 @@ function loadPayloadFromCache() {
 function readCliVersion2() {
   try {
     const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
+    const pkg = JSON.parse(readFileSync7(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"
+    sourceId: sourceMeta.sourceId,
+    sourceHost: sourceMeta.sourceHost,
+    environment: sourceMeta.environment
   };
 }
 
+// src/help.ts
+function renderRootHelp(version, display) {
+  return `${display.name} ${version}
+
+Waste intelligence for OpenClaw workflows and local Cursor usage CSVs.
+
+Usage:
+  ${formatCommand("<command> [options]", display.prefix)}
+
+Commands:
+  audit    Analyze OpenClaw logs or a local Cursor usage CSV.
+  doctor   Inspect OpenClaw sources or a local Cursor usage CSV.
+  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 logs or a local Cursor usage CSV and produce an audit report.
+
+Usage:
+  ${formatCommand("audit [options]", commandPrefix)}
+
+Options:
+  --log-file <path>           Explicit OpenClaw gateway log file to analyze
+  --sessions-dir <path>       Explicit OpenClaw sessions directory to analyze
+  --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):
+  --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) {
+  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 sources or a local Cursor usage CSV before you audit.
+
+Usage:
+  ${formatCommand("doctor [options]", commandPrefix)}
+
+Options:
+  --log-file <path>           Explicit OpenClaw gateway log file to inspect
+  --sessions-dir <path>       Explicit OpenClaw sessions directory to inspect
+  --cursor-usage-csv <path>   Local Cursor usage CSV export 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
+`;
+}
+
 // src/index.ts
 var VERSION = readVersion();
 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());
+  process.stdout.write(renderRootHelp(VERSION, commandDisplay));
   process.exit(0);
 }
 if (command === "--version" || command === "-v" || command === "version") {
@@ -3521,7 +5021,7 @@ if (command === "--version" || command === "-v" || command === "version") {
 }
 run().catch((error) => {
   const message = error instanceof Error ? error.message : "Unknown error";
-  process.stderr.write(`${colorError(`xerg failed: ${message}`)}
+  process.stderr.write(`${colorError(`${commandDisplay.name} failed: ${message}`)}
 `);
   process.exitCode = error instanceof NoDataError ? 2 : 1;
 });
@@ -3531,12 +5031,18 @@ async function run() {
     if (options.json && options.markdown) {
       throw new Error("Use either --json or --markdown, not both.");
     }
-    await runAuditCommand(options);
+    await runAuditCommand({
+      ...options,
+      commandPrefix: commandDisplay.prefix
+    });
     return;
   }
   if (command === "doctor") {
     const options = parseDoctorOptions(argv.slice(1));
-    await runDoctorCommand(options);
+    await runDoctorCommand({
+      ...options,
+      commandPrefix: commandDisplay.prefix
+    });
     return;
   }
   if (command === "push") {
@@ -3552,7 +5058,9 @@ async function run() {
     runLogoutCommand();
     return;
   }
-  throw new Error(`Unknown command "${command}". Run \`xerg --help\` to see available commands.`);
+  throw new Error(
+    `Unknown command "${command}". Run \`${formatCommand("--help", commandDisplay.prefix)}\` to see available commands.`
+  );
 }
 function parseAuditOptions(raw) {
   const argv2 = expandEqualsArgs(raw);
@@ -3562,7 +5070,7 @@ function parseAuditOptions(raw) {
     switch (arg) {
       case "--help":
       case "-h":
-        process.stdout.write(renderAuditHelp());
+        process.stdout.write(renderAuditHelp(commandDisplay.prefix));
         process.exit(0);
         break;
       case "--log-file":
@@ -3573,6 +5081,10 @@ function parseAuditOptions(raw) {
         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;
@@ -3645,7 +5157,9 @@ function parseAuditOptions(raw) {
         index += 1;
         break;
       default:
-        throw new Error(`Unknown audit option "${arg}". Run \`xerg audit --help\` for usage.`);
+        throw new Error(
+          `Unknown audit option "${arg}". Run \`${formatCommand(["audit", "--help"], commandDisplay.prefix)}\` for usage.`
+        );
     }
   }
   return options;
@@ -3658,7 +5172,7 @@ function parsePushOptions(raw) {
     switch (arg) {
       case "--help":
       case "-h":
-        process.stdout.write(renderPushHelp());
+        process.stdout.write(renderPushHelp(commandDisplay.prefix));
         process.exit(0);
         break;
       case "--file":
@@ -3669,7 +5183,9 @@ function parsePushOptions(raw) {
         options.dryRun = true;
         break;
       default:
-        throw new Error(`Unknown push option "${arg}". Run \`xerg push --help\` for usage.`);
+        throw new Error(
+          `Unknown push option "${arg}". Run \`${formatCommand(["push", "--help"], commandDisplay.prefix)}\` for usage.`
+        );
     }
   }
   return options;
@@ -3682,7 +5198,7 @@ function parseDoctorOptions(raw) {
     switch (arg) {
       case "--help":
       case "-h":
-        process.stdout.write(renderDoctorHelp());
+        process.stdout.write(renderDoctorHelp(commandDisplay.prefix));
         process.exit(0);
         break;
       case "--log-file":
@@ -3693,6 +5209,10 @@ function parseDoctorOptions(raw) {
         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;
@@ -3724,7 +5244,9 @@ function parseDoctorOptions(raw) {
         options.verbose = true;
         break;
       default:
-        throw new Error(`Unknown doctor option "${arg}". Run \`xerg doctor --help\` for usage.`);
+        throw new Error(
+          `Unknown doctor option "${arg}". Run \`${formatCommand(["doctor", "--help"], commandDisplay.prefix)}\` for usage.`
+        );
     }
   }
   return options;
@@ -3755,131 +5277,12 @@ function readFloat(flag, value) {
   }
   return num;
 }
-function renderRootHelp() {
-  return `xerg ${VERSION}
-
-Waste intelligence for OpenClaw workflows.
-
-Usage:
-  xerg <command> [options]
-
-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() {
-  return `xerg audit
-
-Analyze OpenClaw logs and produce a waste intelligence report.
-
-Usage:
-  xerg audit [options]
-
-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() {
-  return `xerg push
-
-Push a cached audit snapshot to the Xerg API.
-
-Usage:
-  xerg push [options]
-
-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 \`xerg login\` to authenticate via browser.
-  Browser login stores a token at ~/.config/xerg/credentials.json by default.
-`;
-}
-function renderDoctorHelp() {
-  return `xerg doctor
-
-Inspect your machine for OpenClaw sources and audit readiness.
-
-Usage:
-  xerg doctor [options]
-
-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"));
+  const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
   return packageJson.version ?? "0.0.0";
 }
 //# sourceMappingURL=index.js.map