llm-usage-metrics 0.7.0 → 0.7.2

package/dist/index.js

@@ -106,9 +106,6 @@ function getParsingRuntimeConfig(env = process.env) {
   };
 }
 
-// src/update/update-notifier.ts
-import { spawn as spawn2 } from "child_process";
-
 // src/update/update-cache-repository.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
 import path2 from "path";
@@ -529,7 +526,6 @@ async function runInteractiveInstallAndRestart(options) {
 
 // src/update/update-notifier.ts
 var UPDATE_CHECK_SKIP_ENV_VAR = "LLM_USAGE_SKIP_UPDATE_CHECK";
-var UPDATE_CHECK_REFRESH_ENV_VAR = "LLM_USAGE_REFRESH_UPDATE_CHECK";
 function isTruthyEnvFlag(value) {
   if (value === void 0) {
     return false;
@@ -588,32 +584,6 @@ function toResolveLatestVersionOptions(options, env) {
     now: options.now
   };
 }
-function runDetachedCommandWithSpawn(command, args, options = {}) {
-  const child = spawn2(command, args, {
-    env: options.env,
-    stdio: options.stdio ?? "ignore",
-    detached: true
-  });
-  child.on("error", () => void 0);
-  child.unref();
-}
-function scheduleBackgroundUpdateRefresh(options, env, argv) {
-  const spawnDetachedCommand = options.spawnDetachedCommand ?? runDetachedCommandWithSpawn;
-  spawnDetachedCommand(options.execPath ?? process.execPath, argv.slice(1), {
-    env: {
-      ...env,
-      [UPDATE_CHECK_REFRESH_ENV_VAR]: "1"
-    },
-    stdio: "ignore"
-  });
-}
-async function refreshUpdateCheckCache(options) {
-  try {
-    const env = options.env ?? process.env;
-    await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
-  } catch {
-  }
-}
 async function checkForUpdatesAndMaybeRestart(options) {
   const env = options.env ?? process.env;
   const argv = options.argv ?? process.argv;
@@ -630,19 +600,7 @@ async function checkForUpdatesAndMaybeRestart(options) {
     return { continueExecution: true };
   }
   try {
-    const resolveOptions = toResolveLatestVersionOptions(options, env);
-    const cacheFilePath = resolveOptions.cacheFilePath ?? getDefaultUpdateCheckCachePath();
-    const cachePayload = await readUpdateCheckCachePayload(cacheFilePath);
-    const cacheTtlMs = resolveOptions.cacheTtlMs ?? DEFAULT_UPDATE_CHECK_CACHE_TTL_MS;
-    const now = resolveOptions.now ?? Date.now;
-    if (!cachePayload || !isCacheFresh(cachePayload, cacheTtlMs, now)) {
-      try {
-        scheduleBackgroundUpdateRefresh(options, env, argv);
-      } catch {
-      }
-      return { continueExecution: true };
-    }
-    const latestVersion = cachePayload.latestVersion;
+    const latestVersion = await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
     if (!latestVersion || !shouldOfferUpdate(options.currentVersion, latestVersion)) {
       return { continueExecution: true };
     }
@@ -2659,7 +2617,7 @@ function aggregateEfficiency(options) {
 }
 
 // src/efficiency/git-outcome-collector.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 import path3 from "path";
 import { stat } from "fs/promises";
@@ -2858,7 +2816,7 @@ function parseGitLogShortstatLines(lines, authorEmail) {
 }
 async function runGitCommand(repoDir, args) {
   return await new Promise((resolve, reject) => {
-    const child = spawn3("git", args, {
+    const child = spawn2("git", args, {
       cwd: repoDir,
       env: {
         ...process.env,
@@ -3763,13 +3721,16 @@ function parseUsage(usage) {
     totalTokens
   };
 }
-function createDedupKey(filePath, line, message) {
+function createDedupKey(filePath, line, message, timestamp, model) {
   const messageId = asTrimmedText(message.id);
   if (messageId) {
     return `${filePath}\0${messageId}`;
   }
   const uuid = asTrimmedText(line.uuid);
-  return uuid ? `${filePath}\0${uuid}` : void 0;
+  if (uuid) {
+    return `${filePath}\0${uuid}`;
+  }
+  return `${filePath}\0${timestamp}\0${model ?? ""}`;
 }
 function comparePendingEvents(left, right) {
   if (left.timestamp !== right.timestamp) {
@@ -3842,12 +3803,7 @@ var ClaudeSourceAdapter = class {
         incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
         continue;
       }
-      const dedupKey = createDedupKey(filePath, line, message);
-      if (!dedupKey) {
-        skippedRows++;
-        incrementSkippedReason(skippedRowReasons, "missing_message_id");
-        continue;
-      }
+      const dedupKey = createDedupKey(filePath, line, message, timestamp, model);
       const sessionId = asTrimmedText(line.sessionId) ?? getFallbackSessionId(filePath);
       const repoRoot = asTrimmedText(line.cwd);
       const provider = resolveProvider(message, model);
@@ -5050,17 +5006,257 @@ var OpenCodeSourceAdapter = class {
   }
 };
 
-// src/sources/pi/pi-source-adapter.ts
+// src/sources/openclaw/openclaw-source-adapter.ts
 import os7 from "os";
 import path11 from "path";
-var defaultSessionsDir3 = path11.join(os7.homedir(), ".pi", "agent", "sessions");
+var defaultAgentsDir = path11.join(os7.homedir(), ".openclaw", "agents");
+var SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
+var MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
+var MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
+var USAGE_LINE_PATTERN = /"usage"\s*:/u;
+var MODEL_LINE_PATTERN = /"model"\s*:/u;
+var PROVIDER_LINE_PATTERN = /"provider"\s*:/u;
+function shouldParseOpenClawJsonlLine(lineText) {
+  return SESSION_LINE_PATTERN.test(lineText) || MESSAGE_LINE_PATTERN.test(lineText) || MODEL_CHANGE_LINE_PATTERN.test(lineText) || USAGE_LINE_PATTERN.test(lineText) || MODEL_LINE_PATTERN.test(lineText) || PROVIDER_LINE_PATTERN.test(lineText);
+}
+function getFallbackSessionId3(filePath) {
+  return path11.basename(filePath, ".jsonl");
+}
+function resolveRepoRootFromRecord(record) {
+  if (!record) {
+    return void 0;
+  }
+  const pathRecord = asRecord(record.path);
+  return asTrimmedText(record.cwd) ?? asTrimmedText(pathRecord?.root) ?? asTrimmedText(pathRecord?.cwd) ?? asTrimmedText(record.repo_root) ?? asTrimmedText(record.repoRoot) ?? asTrimmedText(record.project_root) ?? asTrimmedText(record.projectRoot) ?? asTrimmedText(record.workspace);
+}
+function firstText(...values) {
+  for (const value of values) {
+    const normalized = asTrimmedText(value);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+function isAssistantMessage(line, message) {
+  return firstText(line.role, message.role)?.toLowerCase() === "assistant";
+}
+function isDeliveryMirror(provider, model, message) {
+  const messageKind = firstText(message.kind, message.source, message.provenance);
+  return provider?.toLowerCase() === "openclaw" || model?.toLowerCase() === "delivery-mirror" || messageKind?.toLowerCase() === "delivery-mirror";
+}
+function toFiniteNumber2(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.trim().length === 0) {
+    return void 0;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function extractCostUsd(usage) {
+  const cost = asRecord(usage.cost);
+  return toNumberLike(usage.costUsd) ?? toNumberLike(usage.cost_usd) ?? toNumberLike(usage.turnUsd) ?? toNumberLike(usage.turn_usd) ?? toNumberLike(usage.usd) ?? toNumberLike(usage.cost) ?? toNumberLike(cost?.total) ?? toNumberLike(cost?.usd) ?? toNumberLike(cost?.turnUsd) ?? toNumberLike(cost?.turn_usd);
+}
+function extractUsageFromRecord(usage) {
+  const extracted = {
+    inputTokens: toNumberLike(usage.input) ?? toNumberLike(usage.inputTokens) ?? toNumberLike(usage.input_tokens) ?? toNumberLike(usage.prompt_tokens),
+    outputTokens: toNumberLike(usage.output) ?? toNumberLike(usage.outputTokens) ?? toNumberLike(usage.output_tokens) ?? toNumberLike(usage.completion_tokens),
+    reasoningTokens: toNumberLike(usage.reasoning) ?? toNumberLike(usage.reasoningTokens) ?? toNumberLike(usage.reasoning_tokens) ?? toNumberLike(usage.reasoningOutput) ?? toNumberLike(usage.reasoning_output_tokens),
+    cacheReadTokens: toNumberLike(usage.cacheRead) ?? toNumberLike(usage.cache_read) ?? toNumberLike(usage.cacheReadTokens) ?? toNumberLike(usage.cache_read_tokens) ?? toNumberLike(usage.cached) ?? toNumberLike(usage.cached_input_tokens),
+    cacheWriteTokens: toNumberLike(usage.cacheWrite) ?? toNumberLike(usage.cache_write) ?? toNumberLike(usage.cacheWriteTokens) ?? toNumberLike(usage.cache_write_tokens),
+    totalTokens: toNumberLike(usage.total) ?? toNumberLike(usage.totalTokens) ?? toNumberLike(usage.total_tokens),
+    costUsd: extractCostUsd(usage)
+  };
+  const usageCandidates = [
+    extracted.inputTokens,
+    extracted.outputTokens,
+    extracted.reasoningTokens,
+    extracted.cacheReadTokens,
+    extracted.cacheWriteTokens,
+    extracted.totalTokens
+  ];
+  const hasPositiveUsageSignal = usageCandidates.some((value) => {
+    const parsed = toFiniteNumber2(value);
+    return parsed !== void 0 && parsed > 0;
+  });
+  const explicitCost = toFiniteNumber2(extracted.costUsd);
+  const hasPositiveCostSignal = explicitCost !== void 0 && explicitCost > 0;
+  return hasPositiveUsageSignal || hasPositiveCostSignal ? extracted : void 0;
+}
+function mergeUsageExtracts(primary, fallback) {
+  if (!primary) {
+    return fallback;
+  }
+  if (!fallback) {
+    return primary;
+  }
+  return {
+    inputTokens: primary.inputTokens ?? fallback.inputTokens,
+    outputTokens: primary.outputTokens ?? fallback.outputTokens,
+    reasoningTokens: primary.reasoningTokens ?? fallback.reasoningTokens,
+    cacheReadTokens: primary.cacheReadTokens ?? fallback.cacheReadTokens,
+    cacheWriteTokens: primary.cacheWriteTokens ?? fallback.cacheWriteTokens,
+    totalTokens: primary.totalTokens ?? fallback.totalTokens,
+    costUsd: primary.costUsd ?? fallback.costUsd
+  };
+}
+function extractUsage(line, message) {
+  const lineUsage = asRecord(line.usage);
+  const messageUsage = asRecord(message.usage);
+  const extractedLineUsage = lineUsage ? extractUsageFromRecord(lineUsage) : void 0;
+  const extractedMessageUsage = messageUsage ? extractUsageFromRecord(messageUsage) : void 0;
+  return mergeUsageExtracts(extractedLineUsage, extractedMessageUsage);
+}
+function resolveTimestamp2(line, message, state, fallbackTimestamp) {
+  const candidates = [line.timestamp, message.timestamp, fallbackTimestamp, state.sessionTimestamp];
+  for (const candidate of candidates) {
+    const normalizedTimestamp = normalizeTimestampCandidate(candidate);
+    if (normalizedTimestamp) {
+      return normalizedTimestamp;
+    }
+  }
+  return void 0;
+}
+function updateRuntimeStateFromRecord(state, record, nested) {
+  state.provider = firstText(
+    record.provider,
+    record.modelProvider,
+    record.model_provider,
+    nested?.provider,
+    nested?.modelProvider,
+    nested?.model_provider
+  ) ?? state.provider;
+  state.model = firstText(
+    record.model,
+    record.modelId,
+    record.model_id,
+    nested?.model,
+    nested?.modelId,
+    nested?.model_id
+  ) ?? state.model;
+  state.repoRoot = resolveRepoRootFromRecord(record) ?? resolveRepoRootFromRecord(nested) ?? state.repoRoot;
+}
+var OpenClawSourceAdapter = class {
+  id = "openclaw";
+  agentsDir;
+  requireAgentsDir;
+  constructor(options = {}) {
+    this.agentsDir = options.agentsDir ?? defaultAgentsDir;
+    this.requireAgentsDir = options.requireAgentsDir ?? false;
+  }
+  async discoverFiles() {
+    if (isBlankText(this.agentsDir)) {
+      throw new Error("OpenClaw agents directory must be a non-empty path");
+    }
+    const normalizedAgentsDir = this.agentsDir.trim();
+    if (this.requireAgentsDir) {
+      const agentsDirStats = await pathStat(normalizedAgentsDir);
+      if (!agentsDirStats) {
+        throw new Error(
+          `OpenClaw agents directory is missing or unreadable: ${normalizedAgentsDir}`
+        );
+      }
+      if (!agentsDirStats.isDirectory()) {
+        throw new Error(`OpenClaw agents directory is not a directory: ${normalizedAgentsDir}`);
+      }
+    }
+    return discoverJsonlFiles(normalizedAgentsDir);
+  }
+  async parseFile(filePath) {
+    return (await this.parseFileWithDiagnostics(filePath)).events;
+  }
+  async parseFileWithDiagnostics(filePath) {
+    const events = [];
+    let skippedRows = 0;
+    const skippedRowReasons = /* @__PURE__ */ new Map();
+    const fileStats = await pathStat(filePath);
+    const fallbackTimestamp = fileStats?.mtime.toISOString();
+    const state = {
+      sessionId: getFallbackSessionId3(filePath)
+    };
+    for await (const line of readJsonlObjects(filePath, {
+      shouldParseLine: shouldParseOpenClawJsonlLine
+    })) {
+      const message = asRecord(line.message) ?? line;
+      if (line.type === "session") {
+        state.sessionId = firstText(line.id, line.sessionId, line.session_id) ?? state.sessionId;
+        state.sessionTimestamp = normalizeTimestampCandidate(line.timestamp) ?? state.sessionTimestamp;
+        updateRuntimeStateFromRecord(state, line, message);
+        continue;
+      }
+      if (line.type === "model_change") {
+        updateRuntimeStateFromRecord(state, line, message);
+        continue;
+      }
+      if (line.type !== "message" || !isAssistantMessage(line, message)) {
+        updateRuntimeStateFromRecord(state, line, message);
+        continue;
+      }
+      const rowProvider = firstText(
+        line.provider,
+        message.provider,
+        line.modelProvider,
+        message.modelProvider,
+        line.model_provider,
+        message.model_provider
+      );
+      const rowModel = firstText(
+        line.model,
+        message.model,
+        line.modelId,
+        message.modelId,
+        line.model_id,
+        message.model_id
+      );
+      if (isDeliveryMirror(rowProvider, rowModel, message)) {
+        continue;
+      }
+      updateRuntimeStateFromRecord(state, line, message);
+      const provider = rowProvider ?? state.provider;
+      const model = rowModel ?? state.model;
+      const usage = extractUsage(line, message);
+      if (!usage) {
+        continue;
+      }
+      const timestamp = resolveTimestamp2(line, message, state, fallbackTimestamp);
+      if (!timestamp) {
+        continue;
+      }
+      try {
+        events.push(
+          createUsageEvent({
+            source: this.id,
+            sessionId: state.sessionId,
+            timestamp,
+            repoRoot: state.repoRoot,
+            provider,
+            model,
+            ...usage
+          })
+        );
+      } catch {
+        skippedRows += 1;
+        incrementSkippedReason(skippedRowReasons, "invalid_usage_event");
+        continue;
+      }
+    }
+    return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+  }
+};
+
+// src/sources/pi/pi-source-adapter.ts
+import os8 from "os";
+import path12 from "path";
+var defaultSessionsDir3 = path12.join(os8.homedir(), ".pi", "agent", "sessions");
 var PI_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var PI_SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
 var PI_MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
 function shouldParsePiJsonlLine(lineText) {
   return PI_MESSAGE_LINE_PATTERN.test(lineText) || PI_SESSION_LINE_PATTERN.test(lineText) || PI_MODEL_CHANGE_LINE_PATTERN.test(lineText);
 }
-function resolveTimestamp2(line, message, state) {
+function resolveTimestamp3(line, message, state) {
   const candidates = [line.timestamp, message?.timestamp, state.sessionTimestamp];
   for (const candidate of candidates) {
     const normalizedTimestamp = normalizeTimestampCandidate(candidate);
@@ -5070,7 +5266,7 @@ function resolveTimestamp2(line, message, state) {
   }
   return void 0;
 }
-function extractUsageFromRecord(usage) {
+function extractUsageFromRecord2(usage) {
   const cost = asRecord(usage.cost);
   const extracted = {
     inputTokens: toNumberLike(usage.input),
@@ -5083,7 +5279,7 @@ function extractUsageFromRecord(usage) {
     totalTokens: toNumberLike(usage.totalTokens),
     costUsd: toNumberLike(cost?.total)
   };
-  const toFiniteNumber2 = (value) => {
+  const toFiniteNumber3 = (value) => {
     if (value === null || value === void 0) {
       return void 0;
     }
@@ -5105,18 +5301,18 @@ function extractUsageFromRecord(usage) {
     extracted.totalTokens
   ];
   const hasPositiveUsageSignal = usageCandidates.some((value) => {
-    const parsed = toFiniteNumber2(value);
+    const parsed = toFiniteNumber3(value);
     return parsed !== void 0 && parsed > 0;
   });
-  const explicitCost = toFiniteNumber2(extracted.costUsd);
+  const explicitCost = toFiniteNumber3(extracted.costUsd);
   const hasPositiveCostSignal = explicitCost !== void 0 && explicitCost > 0;
   return hasPositiveUsageSignal || hasPositiveCostSignal ? extracted : void 0;
 }
-function extractUsage(line, message) {
+function extractUsage2(line, message) {
   const lineUsage = asRecord(line.usage);
   const messageUsage = asRecord(message?.usage);
   if (lineUsage) {
-    const extractedLineUsage = extractUsageFromRecord(lineUsage);
+    const extractedLineUsage = extractUsageFromRecord2(lineUsage);
     if (extractedLineUsage) {
       return extractedLineUsage;
     }
@@ -5124,12 +5320,12 @@ function extractUsage(line, message) {
   if (!messageUsage) {
     return void 0;
   }
-  return extractUsageFromRecord(messageUsage);
+  return extractUsageFromRecord2(messageUsage);
 }
-function getFallbackSessionId3(filePath) {
-  return path11.basename(filePath, ".jsonl");
+function getFallbackSessionId4(filePath) {
+  return path12.basename(filePath, ".jsonl");
 }
-function resolveRepoRootFromRecord(record) {
+function resolveRepoRootFromRecord2(record) {
   if (!record) {
     return void 0;
   }
@@ -5159,37 +5355,37 @@ var PiSourceAdapter = class {
   }
   async parseFile(filePath) {
     const events = [];
-    const state = { sessionId: getFallbackSessionId3(filePath) };
+    const state = { sessionId: getFallbackSessionId4(filePath) };
     for await (const line of readJsonlObjects(filePath, {
       shouldParseLine: shouldParsePiJsonlLine
     })) {
       if (line.type === "session") {
         state.sessionId = asTrimmedText(line.id) ?? state.sessionId;
         state.sessionTimestamp = asTrimmedText(line.timestamp) ?? state.sessionTimestamp;
-        state.repoRoot = resolveRepoRootFromRecord(line) ?? state.repoRoot;
+        state.repoRoot = resolveRepoRootFromRecord2(line) ?? state.repoRoot;
         continue;
       }
       if (line.type === "model_change") {
         state.provider = asTrimmedText(line.provider) ?? state.provider;
         state.model = asTrimmedText(line.modelId) ?? asTrimmedText(line.model) ?? state.model;
-        state.repoRoot = resolveRepoRootFromRecord(line) ?? state.repoRoot;
+        state.repoRoot = resolveRepoRootFromRecord2(line) ?? state.repoRoot;
         continue;
       }
       if (line.type !== "message") {
         continue;
       }
       const message = asRecord(line.message);
-      const usage = extractUsage(line, message);
+      const usage = extractUsage2(line, message);
       if (!usage) {
         continue;
       }
       const provider = asTrimmedText(line.provider) ?? asTrimmedText(message?.provider) ?? state.provider;
-      const timestamp = resolveTimestamp2(line, message, state);
+      const timestamp = resolveTimestamp3(line, message, state);
       if (!timestamp || !state.sessionId) {
         continue;
       }
       const model = asTrimmedText(line.model) ?? asTrimmedText(line.modelId) ?? asTrimmedText(message?.model) ?? state.model;
-      const repoRoot = resolveRepoRootFromRecord(line) ?? resolveRepoRootFromRecord(message) ?? state.repoRoot;
+      const repoRoot = resolveRepoRootFromRecord2(line) ?? resolveRepoRootFromRecord2(message) ?? state.repoRoot;
       try {
         events.push(
           createUsageEvent({
@@ -5299,6 +5495,21 @@ var sourceRegistrations = [
       dbPath: options.opencodeDb
     })
   },
+  {
+    id: "openclaw",
+    sourceDirOverride: { kind: "directory" },
+    create: (_options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig(
+        "openclaw",
+        void 0,
+        sourceDirectoryOverrides
+      );
+      return new OpenClawSourceAdapter({
+        agentsDir: directoryConfig.path,
+        requireAgentsDir: directoryConfig.requireExistingPath
+      });
+    }
+  },
   {
     id: "claude",
     sourceDirOverride: { kind: "directory" },
@@ -5636,7 +5847,7 @@ function normalizeSkippedRowReasons(value) {
 
 // src/cli/parse-file-cache.ts
 import { mkdir as mkdir2, readFile as readFile4, rename, rm, stat as stat4, writeFile as writeFile2 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 var PARSE_FILE_CACHE_VERSION = 5;
 var CACHE_KEY_SEPARATOR = "\0";
 function createCacheKey(source, filePath) {
@@ -5863,7 +6074,7 @@ function normalizeCacheEntry(value) {
   };
 }
 function getDefaultParseFileCachePath() {
-  return path12.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
+  return path13.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
 }
 function normalizeCacheShardSource(source) {
   const normalizedSource = normalizeCacheSource(source);
@@ -5873,12 +6084,12 @@ function normalizeCacheShardSource(source) {
   return normalizedSource.replace(/[^a-z0-9._-]/gu, "_");
 }
 function getSourceShardedParseFileCachePath(cacheFilePath, source) {
-  const parsedPath = path12.parse(cacheFilePath);
+  const parsedPath = path13.parse(cacheFilePath);
   const sourceShard = normalizeCacheShardSource(source);
   if (parsedPath.ext.length > 0) {
-    return path12.join(parsedPath.dir, `${parsedPath.name}.${sourceShard}${parsedPath.ext}`);
+    return path13.join(parsedPath.dir, `${parsedPath.name}.${sourceShard}${parsedPath.ext}`);
   }
-  return path12.join(parsedPath.dir, `${parsedPath.base}.${sourceShard}`);
+  return path13.join(parsedPath.dir, `${parsedPath.base}.${sourceShard}`);
 }
 var ParseFileCache = class _ParseFileCache {
   constructor(cacheFilePath, limits, now) {
@@ -5975,7 +6186,7 @@ var ParseFileCache = class _ParseFileCache {
       keptEntries.length = bestCount;
       payloadText = bestPayloadText;
     }
-    await mkdir2(path12.dirname(this.cacheFilePath), { recursive: true });
+    await mkdir2(path13.dirname(this.cacheFilePath), { recursive: true });
     const temporaryPath = `${this.cacheFilePath}.${process.pid}.${this.now()}.tmp`;
     try {
       await writeFile2(temporaryPath, payloadText, "utf8");
@@ -6462,9 +6673,92 @@ function applyPricingToEvents(events, pricingSource) {
   });
 }
 
+// src/pricing/pricing-override-source.ts
+import { readFile as readFile5 } from "fs/promises";
+function toFiniteUsdRate(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return void 0;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeReasoningBilling(value) {
+  if (value === "included-in-output" || value === "separate") {
+    return value;
+  }
+  return void 0;
+}
+function normalizePricingOverride(raw) {
+  const inputPer1MUsd = toFiniteUsdRate(toNumberLike(raw.inputPer1MUsd));
+  const outputPer1MUsd = toFiniteUsdRate(toNumberLike(raw.outputPer1MUsd));
+  if (inputPer1MUsd === void 0 || outputPer1MUsd === void 0) {
+    return void 0;
+  }
+  const cacheReadPer1MUsd = toFiniteUsdRate(toNumberLike(raw.cacheReadPer1MUsd));
+  const cacheWritePer1MUsd = toFiniteUsdRate(toNumberLike(raw.cacheWritePer1MUsd));
+  const reasoningPer1MUsd = toFiniteUsdRate(toNumberLike(raw.reasoningPer1MUsd));
+  const reasoningBilling = normalizeReasoningBilling(raw.reasoningBilling);
+  return {
+    inputPer1MUsd,
+    outputPer1MUsd,
+    ...cacheReadPer1MUsd !== void 0 ? { cacheReadPer1MUsd } : {},
+    ...cacheWritePer1MUsd !== void 0 ? { cacheWritePer1MUsd } : {},
+    ...reasoningPer1MUsd !== void 0 ? { reasoningPer1MUsd } : {},
+    ...reasoningBilling !== void 0 ? { reasoningBilling } : {}
+  };
+}
+function normalizeOverrideFile(payload) {
+  const root = asRecord(payload);
+  const overrides = /* @__PURE__ */ new Map();
+  const modelsRecord = asRecord(root?.models);
+  if (!modelsRecord) {
+    return overrides;
+  }
+  for (const [modelName, rawPricing] of Object.entries(modelsRecord)) {
+    const normalizedModelName = asTrimmedText(modelName)?.toLowerCase();
+    if (!normalizedModelName) {
+      continue;
+    }
+    const pricing = normalizePricingOverride(asRecord(rawPricing) ?? {});
+    if (pricing) {
+      overrides.set(normalizedModelName, pricing);
+    }
+  }
+  return overrides;
+}
+async function loadPricingOverrides(filePath) {
+  const fileContents = await readFile5(filePath, "utf8");
+  const parsed = JSON.parse(fileContents);
+  return normalizeOverrideFile(parsed);
+}
+var PricingOverrideSource = class {
+  overrides;
+  delegate;
+  constructor(overrides, delegate) {
+    this.overrides = overrides;
+    this.delegate = delegate;
+  }
+  resolveModelAlias(model) {
+    if (this.overrides.has(model.toLowerCase())) {
+      return model;
+    }
+    return this.delegate.resolveModelAlias(model);
+  }
+  getPricing(model) {
+    const override = this.overrides.get(model.toLowerCase());
+    if (override) {
+      return override;
+    }
+    return this.delegate.getPricing(model);
+  }
+};
+
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import path13 from "path";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import path14 from "path";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -6648,7 +6942,7 @@ function normalizeLitellmPricingPayload(payload) {
   return normalizedPricing;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path13.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path14.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 function stripProviderPrefix(model) {
   const slashIndex = model.lastIndexOf("/");
@@ -7007,7 +7301,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile5(this.cacheFilePath, "utf8");
+      content = await readFile6(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -7042,7 +7336,7 @@ var LiteLLMPricingFetcher = class {
     };
   }
   async writeCache() {
-    const directoryPath = path13.dirname(this.cacheFilePath);
+    const directoryPath = path14.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -7054,7 +7348,27 @@ var LiteLLMPricingFetcher = class {
 };
 
 // src/cli/build-usage-data-pricing.ts
+function wrapWithPricingOverrides(overrides, delegate) {
+  if (!overrides || overrides.size === 0) {
+    return delegate;
+  }
+  return new PricingOverrideSource(overrides, delegate);
+}
 async function resolvePricingSource(options, runtimeConfig) {
+  let pricingOverrides;
+  if (options.pricingOverrides) {
+    try {
+      pricingOverrides = await loadPricingOverrides(options.pricingOverrides);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Could not load --pricing-overrides from ${options.pricingOverrides}: ${reason}`,
+        {
+          cause: error
+        }
+      );
+    }
+  }
   const litellmPricingFetcher = new LiteLLMPricingFetcher({
     sourceUrl: options.pricingUrl,
     offline: options.pricingOffline,
@@ -7063,10 +7377,11 @@ async function resolvePricingSource(options, runtimeConfig) {
   });
   try {
     const fromCache = await litellmPricingFetcher.load();
+    const source = wrapWithPricingOverrides(pricingOverrides, litellmPricingFetcher);
     if (options.pricingOffline) {
-      return { source: litellmPricingFetcher, origin: "offline-cache" };
+      return { source, origin: "offline-cache" };
     }
-    return { source: litellmPricingFetcher, origin: fromCache ? "cache" : "network" };
+    return { source, origin: fromCache ? "cache" : "network" };
   } catch (error) {
     if (options.pricingOffline) {
       throw new Error("Offline pricing mode enabled but cached pricing is unavailable", {
@@ -7634,12 +7949,12 @@ function emitEnvVarOverrides(activeEnvOverrides, diagnosticsLogger) {
 }
 
 // src/cli/share-artifact.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { constants as constants3 } from "fs";
 import { access as access3, writeFile as writeFile4 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 async function writeShareSvgFile(fileName, svgContent) {
-  const outputPath = path14.resolve(process.cwd(), fileName);
+  const outputPath = path15.resolve(process.cwd(), fileName);
   await writeFile4(outputPath, svgContent, "utf8");
   return outputPath;
 }
@@ -7667,10 +7982,10 @@ async function resolveBinaryPath(primaryPath, fallbackNames) {
   if (await fileExists(primaryPath)) {
     return primaryPath;
   }
-  const pathDirs = (process.env.PATH ?? "").split(path14.delimiter).filter(Boolean);
+  const pathDirs = (process.env.PATH ?? "").split(path15.delimiter).filter(Boolean);
   for (const fallbackName of fallbackNames) {
     for (const dir of pathDirs) {
-      const candidate = path14.join(dir, fallbackName);
+      const candidate = path15.join(dir, fallbackName);
       if (await fileExists(candidate)) {
         return candidate;
       }
@@ -7716,7 +8031,7 @@ async function resolveOpenCommand(filePath, platform) {
 }
 async function spawnDetached(command, args) {
   await new Promise((resolve, reject) => {
-    const child = spawn4(command, args, {
+    const child = spawn3(command, args, {
       detached: true,
       stdio: "ignore",
       windowsHide: true
@@ -9916,7 +10231,10 @@ function registerSharedReportOptions(command, profile) {
     "--model <name>",
     "Filter by model (repeatable/comma-separated; exact when exact match exists after source/provider/date filters, otherwise substring)",
     collectRepeatedOption
-  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
+  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option(
+    "--pricing-overrides <path>",
+    "Path to a JSON file of per-model pricing overrides (takes precedence over LiteLLM)"
+  ).option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
     "--ignore-pricing-failures",
     "Continue without estimated costs when pricing cannot be loaded"
   ).option("--json", "Render output as JSON");
@@ -9968,7 +10286,7 @@ function createUsageReportDefinition(granularity) {
         includeInRootHelp: true
       },
       {
-        command: "llm-usage daily --source-dir pi=/tmp/pi-sessions --source-dir gemini=/tmp/.gemini --source-dir droid=/tmp/droid-sessions",
+        command: "llm-usage daily --source-dir pi=/tmp/pi-sessions --source-dir gemini=/tmp/.gemini --source-dir droid=/tmp/droid-sessions --source-dir openclaw=/tmp/openclaw-agents",
         includeInRootHelp: true,
         includeInCliReference: true
       },
@@ -10230,15 +10548,6 @@ var { packageName, packageVersion } = loadPackageMetadataFromRuntime();
 var updateRuntimeConfig = getUpdateNotifierRuntimeConfig();
 var cli = createCli({ version: packageVersion });
 async function main() {
-  if (process.env[UPDATE_CHECK_REFRESH_ENV_VAR] === "1") {
-    await refreshUpdateCheckCache({
-      packageName,
-      currentVersion: packageVersion,
-      cacheTtlMs: updateRuntimeConfig.cacheTtlMs,
-      fetchTimeoutMs: updateRuntimeConfig.fetchTimeoutMs
-    });
-    return;
-  }
   const updateResult = await checkForUpdatesAndMaybeRestart({
     packageName,
     currentVersion: packageVersion,