tledger 0.3.0 → 0.4.0

package/lib/token-ledger-usage.mjs

@@ -2,7 +2,7 @@ const MINUTE_MS = 60 * 1_000;
 const HOUR_MS = 60 * MINUTE_MS;
 const DAY_MS = 24 * HOUR_MS;
 
-export const SNAPSHOT_SCHEMA_VERSION = 2;
+export const SNAPSHOT_SCHEMA_VERSION = 3;
 export const ADAPTIVE_USAGE_RESOLUTIONS_SECONDS = Object.freeze([
   5 * 60,
   15 * 60,
@@ -21,6 +21,7 @@ export const DEFAULT_USAGE_RESOLUTION_POLICY = Object.freeze([
 
 const COMPACT_DURING_BUILD_BUCKET_COUNT = 50_000;
 const MAX_BUILD_BUCKET_COUNT = 100_000;
+export const MAX_SAFE_TOKEN_COUNT = Number.MAX_SAFE_INTEGER;
 
 const NUMERIC_USAGE_FIELDS = Object.freeze([
   "inputTokens",
@@ -37,6 +38,242 @@ const FRACTIONAL_COUNT_FIELDS = Object.freeze([
   "inputCallCount",
 ]);
 
+function primitiveNumber(value) {
+  try {
+    const number = Number.prototype.valueOf.call(value);
+    return number === value ? number : null;
+  } catch {
+    return null;
+  }
+}
+
+function parsedTokenValue(value, allowFractional = false) {
+  const number = primitiveNumber(value);
+  if (
+    number === null ||
+    !Number.isFinite(number) ||
+    number < 0 ||
+    number > MAX_SAFE_TOKEN_COUNT ||
+    (!allowFractional && !Number.isSafeInteger(number))
+  ) {
+    return null;
+  }
+  return number;
+}
+
+function parsedOptionalTokenValue(value, allowFractional = false) {
+  return value === undefined
+    ? 0
+    : parsedTokenValue(value, allowFractional);
+}
+
+export function tokenValue(value, { allowFractional = false } = {}) {
+  return parsedTokenValue(value, allowFractional) ?? 0;
+}
+
+export function isValidTokenValue(value, { allowFractional = false } = {}) {
+  return parsedTokenValue(value, allowFractional) !== null;
+}
+
+export function checkedTokenAdd(
+  current,
+  contribution,
+  { allowFractional = false } = {},
+) {
+  const left = tokenValue(current, { allowFractional: true });
+  const right = tokenValue(contribution, { allowFractional });
+  const sum = left + right;
+  return Number.isFinite(sum) && sum <= MAX_SAFE_TOKEN_COUNT
+    ? sum
+    : MAX_SAFE_TOKEN_COUNT;
+}
+
+// Output rendered next to a scaled overall total must shrink by the same
+// factor; saturating it independently would overstate the output share.
+export function scaledOutputTokens(events, totalTokens) {
+  const totals = { totalTokens: 0, outputTokens: 0, scale: 1 };
+  for (const event of events) {
+    if (event?.invalidTokenRecord === true) continue;
+    const allowFractional = event?.rangeAllocationEstimated === true;
+    const nextTotal = totals.totalTokens +
+      tokenValue(event.totalTokens, { allowFractional }) / totals.scale;
+    const nextOutput = totals.outputTokens +
+      tokenValue(event.outputTokens, { allowFractional }) / totals.scale;
+    const scaleFactor = Math.max(
+      1,
+      nextTotal / MAX_SAFE_TOKEN_COUNT,
+      nextOutput / MAX_SAFE_TOKEN_COUNT,
+    );
+    totals.totalTokens = nextTotal / scaleFactor;
+    totals.outputTokens = nextOutput / scaleFactor;
+    totals.scale *= scaleFactor;
+  }
+  if (totals.scale === 1) return totals.outputTokens;
+  return totals.totalTokens > 0 && totalTokens > 0
+    ? (totals.outputTokens / totals.totalTokens) * totalTokens
+    : totals.outputTokens;
+}
+
+const TOKEN_PARTITION_SCALE = Symbol("tokenPartitionScale");
+
+function tokenPartitionScale(target) {
+  return Number.isFinite(target[TOKEN_PARTITION_SCALE]) &&
+      target[TOKEN_PARTITION_SCALE] >= 1
+    ? target[TOKEN_PARTITION_SCALE]
+    : 1;
+}
+
+function setTokenPartitionScale(target, scale) {
+  Object.defineProperty(target, TOKEN_PARTITION_SCALE, {
+    configurable: true,
+    enumerable: false,
+    value: scale,
+    writable: true,
+  });
+}
+
+export function checkedTokenPartitionAdd(
+  target,
+  contribution,
+  { detailed = false } = {},
+) {
+  const targetScale = tokenPartitionScale(target);
+  const value =
+    tokenValue(contribution, { allowFractional: true }) / targetScale;
+  let nextDetailed = tokenValue(target.detailedTokens, {
+    allowFractional: true,
+  });
+  let nextUnknown = tokenValue(target.unknownBreakdownTokens, {
+    allowFractional: true,
+  });
+  if (detailed) nextDetailed += value;
+  else nextUnknown += value;
+  const scaleFactor = Math.max(
+    1,
+    (nextDetailed + nextUnknown) / MAX_SAFE_TOKEN_COUNT,
+  );
+  target.detailedTokens = nextDetailed / scaleFactor;
+  target.unknownBreakdownTokens = nextUnknown / scaleFactor;
+  setTokenPartitionScale(target, targetScale * scaleFactor);
+}
+
+export function nonNegativeFiniteValue(value) {
+  const number = primitiveNumber(value);
+  return number !== null && Number.isFinite(number) && number >= 0
+    ? number
+    : 0;
+}
+
+export function isNonNegativeFiniteValue(value) {
+  const number = primitiveNumber(value);
+  return number !== null && Number.isFinite(number) && number >= 0;
+}
+
+export function checkedFiniteAdd(current, contribution) {
+  const sum =
+    nonNegativeFiniteValue(current) + nonNegativeFiniteValue(contribution);
+  return Number.isFinite(sum) ? sum : Number.MAX_VALUE;
+}
+
+export function tokenTotalsReconcile(
+  totalTokens,
+  inputTokens,
+  outputTokens,
+  allowFractional,
+) {
+  const componentTotal = inputTokens + outputTokens;
+  if (
+    !Number.isFinite(componentTotal) ||
+    componentTotal > MAX_SAFE_TOKEN_COUNT
+  ) {
+    return false;
+  }
+  if (componentTotal === totalTokens) return true;
+  if (!allowFractional) return false;
+  const tolerance =
+    Number.EPSILON * Math.max(1, componentTotal, totalTokens) * 16;
+  return Math.abs(componentTotal - totalTokens) <= tolerance;
+}
+
+function invalidTokenUsage(row) {
+  const source = Object(row) === row ? { ...row } : {};
+  return {
+    ...source,
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    cacheWriteInputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    toolCalls: 0,
+    breakdownAvailable: false,
+    invalidTokenRecord: true,
+  };
+}
+
+export function normalizeTokenUsage(row) {
+  if (!row || Object(row) !== row) return null;
+  if (row.invalidTokenRecord === true) return invalidTokenUsage(row);
+
+  const allowFractional = row.rangeAllocationEstimated === true;
+  const totalTokens = parsedTokenValue(row.totalTokens, allowFractional);
+  if (totalTokens === null) return invalidTokenUsage(row);
+
+  const componentValues = [
+    parsedOptionalTokenValue(row.inputTokens, allowFractional),
+    parsedOptionalTokenValue(row.cachedInputTokens, allowFractional),
+    parsedOptionalTokenValue(row.cacheWriteInputTokens, allowFractional),
+    parsedOptionalTokenValue(row.outputTokens, allowFractional),
+    parsedOptionalTokenValue(row.reasoningTokens, allowFractional),
+  ];
+  const componentsValid = componentValues.every((value) => value !== null);
+  const inputTokens = componentValues[0] ?? 0;
+  const cachedInputTokens = Math.min(inputTokens, componentValues[1] ?? 0);
+  const cacheWriteInputTokens = componentValues[2] ?? 0;
+  const outputTokens = componentValues[3] ?? 0;
+  const reasoningTokens = Math.min(outputTokens, componentValues[4] ?? 0);
+  const componentTotal = inputTokens + outputTokens;
+  const breakdownAvailable =
+    row.breakdownAvailable !== false &&
+    componentsValid &&
+    (totalTokens === 0
+      ? componentTotal === 0
+      : tokenTotalsReconcile(
+          totalTokens,
+          inputTokens,
+          outputTokens,
+          allowFractional,
+        ) &&
+        (inputTokens > 0 || outputTokens > 0));
+
+  const normalized = {
+    ...row,
+    inputTokens,
+    cachedInputTokens,
+    cacheWriteInputTokens,
+    outputTokens,
+    reasoningTokens,
+    totalTokens,
+    toolCalls: tokenValue(row.toolCalls, { allowFractional }),
+    breakdownAvailable,
+  };
+  // Older snapshots could retain a positive detailed-call count on a
+  // total-only bucket because the source supplied a valid total but no
+  // input/output partition. Canonicalize the exported count here so every
+  // downstream consumer sees the same coverage contract. A valid explicit
+  // zero is meaningful partial coverage and must not fall back to callCount;
+  // omitted or malformed legacy values retain the detailed fallback.
+  const storedDetailedCallCount = nonNegativeStoredCount(
+    row.detailedCallCount,
+    allowFractional,
+  );
+  const callCount = usageCallCount(normalized);
+  normalized.detailedCallCount = breakdownAvailable
+    ? Math.min(callCount, storedDetailedCallCount ?? callCount)
+    : 0;
+  return normalized;
+}
+
 function finiteTimestamp(value) {
   try {
     const timestampMs = Date.parse(String(value ?? ""));
@@ -56,19 +293,20 @@ function nonNegativeNumber(value) {
 }
 
 function positiveSafeInteger(value) {
-  try {
-    const number = Number(value);
-    return Number.isSafeInteger(number) && number > 0 ? number : 0;
-  } catch {
-    return 0;
-  }
+  const number = parsedTokenValue(value);
+  return number !== null && number > 0 ? number : 0;
 }
 
 function positiveNumber(value) {
-  const number = nonNegativeNumber(value);
+  const number = nonNegativeFiniteValue(value);
   return number > 0 ? number : 0;
 }
 
+function nonNegativeStoredCount(value, allowFractional = false) {
+  if (value === undefined || value === null) return null;
+  return parsedTokenValue(value, allowFractional);
+}
+
 function primitiveString(value) {
   try {
     const text = String.prototype.valueOf.call(value);
@@ -101,6 +339,7 @@ function groupingKey(row, bucketIndex, uniqueKey = "") {
     uniqueKey,
     String(row.project ?? "Unlabelled activity"),
     String(row.model ?? "unknown"),
+    String(row.rateCardModel ?? row.model ?? "unknown"),
     String(row.effort ?? "unknown"),
     String(row.source ?? "unknown"),
     String(row.useType ?? "unknown"),
@@ -114,7 +353,7 @@ function newAggregate(row, timestampMs, resolutionMs) {
   const rateCardCredits = row.rateCardCredits == null
     ? null
     : 0;
-  const callCount = positiveSafeInteger(row.callCount) || 1;
+  const callCount = usageCallCount(row);
   const aggregate = {
     timestampMeanMs: timestampMs,
     timestampWeight: callCount,
@@ -122,6 +361,7 @@ function newAggregate(row, timestampMs, resolutionMs) {
     endMs: finiteTimestamp(row.endAt) ?? timestampMs,
     project: String(row.project ?? "Unlabelled activity"),
     model: String(row.model ?? "unknown"),
+    rateCardModel: String(row.rateCardModel ?? row.model ?? "unknown"),
     effort: String(row.effort ?? "unknown"),
     source: String(row.source ?? "unknown"),
     useType: String(row.useType ?? "unknown"),
@@ -138,6 +378,7 @@ function newAggregate(row, timestampMs, resolutionMs) {
     callCount: 0,
     detailedCallCount: 0,
     inputCallCount: 0,
+    rangeAllocationEstimated: false,
     resolutionSeconds: Math.max(
       nonNegativeNumber(row.resolutionSeconds),
       resolutionMs / 1_000,
@@ -149,7 +390,9 @@ function newAggregate(row, timestampMs, resolutionMs) {
 }
 
 function addToAggregate(aggregate, row, timestampMs) {
-  const callCount = positiveSafeInteger(row.callCount) || 1;
+  const estimated = row.rangeAllocationEstimated === true;
+  aggregate.rangeAllocationEstimated ||= estimated;
+  const callCount = usageCallCount(row);
   if (aggregate.callCount > 0) {
     const combinedWeight = aggregate.timestampWeight + callCount;
     aggregate.timestampMeanMs +=
@@ -165,19 +408,46 @@ function addToAggregate(aggregate, row, timestampMs) {
     finiteTimestamp(row.endAt) ?? timestampMs,
   );
   for (const field of NUMERIC_USAGE_FIELDS) {
-    aggregate[field] += nonNegativeNumber(row[field]);
+    aggregate[field] = checkedTokenAdd(aggregate[field], row[field], {
+      allowFractional: estimated,
+    });
   }
-  aggregate.callCount += callCount;
-  const detailedCallCount = positiveSafeInteger(row.detailedCallCount);
-  aggregate.detailedCallCount += detailedCallCount || (
-    row.breakdownAvailable === true ? callCount : 0
+  aggregate.cachedInputTokens = Math.min(
+    aggregate.inputTokens,
+    aggregate.cachedInputTokens,
+  );
+  aggregate.reasoningTokens = Math.min(
+    aggregate.outputTokens,
+    aggregate.reasoningTokens,
+  );
+  aggregate.breakdownAvailable =
+    aggregate.breakdownAvailable &&
+    tokenTotalsReconcile(
+      aggregate.totalTokens,
+      aggregate.inputTokens,
+      aggregate.outputTokens,
+      aggregate.rangeAllocationEstimated,
+    );
+  aggregate.callCount = checkedTokenAdd(aggregate.callCount, callCount, {
+    allowFractional: estimated,
+  });
+  const detailedCallCount = usageDetailedCallCount(row);
+  aggregate.detailedCallCount = checkedTokenAdd(
+    aggregate.detailedCallCount,
+    detailedCallCount,
+    { allowFractional: estimated },
   );
-  const inputCallCount = positiveSafeInteger(row.inputCallCount);
-  aggregate.inputCallCount += inputCallCount || (
-    nonNegativeNumber(row.inputTokens) > 0 ? callCount : 0
+  const inputCallCount = usageInputCallCount(row);
+  aggregate.inputCallCount = checkedTokenAdd(
+    aggregate.inputCallCount,
+    inputCallCount,
+    { allowFractional: estimated },
   );
   if (aggregate.rateCardCredits !== null) {
-    aggregate.rateCardCredits += nonNegativeNumber(row.rateCardCredits);
+    aggregate.rateCardCredits = checkedFiniteAdd(
+      aggregate.rateCardCredits,
+      row.rateCardCredits,
+    );
   }
   aggregate.resolutionSeconds = Math.max(
     aggregate.resolutionSeconds,
@@ -187,12 +457,13 @@ function addToAggregate(aggregate, row, timestampMs) {
 }
 
 function finishAggregate(aggregate) {
-  return {
+  const result = {
     timestamp: new Date(Math.round(aggregate.timestampMeanMs)).toISOString(),
     startAt: new Date(aggregate.startMs).toISOString(),
     endAt: new Date(aggregate.endMs).toISOString(),
     project: aggregate.project,
     model: aggregate.model,
+    rateCardModel: aggregate.rateCardModel,
     effort: aggregate.effort,
     source: aggregate.source,
     useType: aggregate.useType,
@@ -212,6 +483,10 @@ function finishAggregate(aggregate) {
     threadIds: [...aggregate.threadIds].sort(),
     resolutionSeconds: aggregate.resolutionSeconds,
   };
+  if (aggregate.rangeAllocationEstimated) {
+    result.rangeAllocationEstimated = true;
+  }
+  return result;
 }
 
 function addRowToGroups(
@@ -233,7 +508,12 @@ function addRowToGroups(
 function aggregateRows(rows, resolutionForRow) {
   const groups = new Map();
   let index = 0;
-  for (const row of rows) {
+  for (const sourceRow of rows) {
+    const row = normalizeTokenUsage(sourceRow);
+    if (!row || row.invalidTokenRecord === true) {
+      index += 1;
+      continue;
+    }
     const timestampMs = finiteTimestamp(row?.timestamp);
     if (timestampMs === null) {
       index += 1;
@@ -292,7 +572,12 @@ export function buildUsageBuckets(
   let minimumResolutionMs = 0;
   let nextResolutionIndex = 0;
   let index = 0;
-  for (const row of rows) {
+  for (const sourceRow of rows) {
+    const row = normalizeTokenUsage(sourceRow);
+    if (!row || row.invalidTokenRecord === true) {
+      index += 1;
+      continue;
+    }
     const timestampMs = finiteTimestamp(row?.timestamp);
     if (timestampMs === null) {
       index += 1;
@@ -349,7 +634,13 @@ export function coarsenUsageBuckets(buckets, resolutionSeconds) {
 }
 
 export function usageBuckets(snapshot = {}) {
-  return Array.isArray(snapshot.events) ? snapshot.events : [];
+  if (!Array.isArray(snapshot.events)) return [];
+  return [...snapshot.events].flatMap((row) => {
+    const normalized = normalizeTokenUsage(row);
+    return normalized && normalized.invalidTokenRecord !== true
+      ? [normalized]
+      : [];
+  });
 }
 
 function usageBucketInterval(bucket) {
@@ -377,6 +668,11 @@ function firstBoundaryAfter(boundaries, value) {
 }
 
 function sliceUsageBucket(bucket, startMs, endMs, fraction) {
+  const rangeAllocationOrigin = bucket?.rangeAllocationOrigin ?? {
+    inputTokens: nonNegativeNumber(bucket?.inputTokens),
+    totalTokens: nonNegativeNumber(bucket?.totalTokens),
+    callCount: usageCallCount(bucket),
+  };
   const fragment = {
     ...bucket,
     timestamp: new Date(Math.round(startMs + (endMs - startMs - 1) / 2))
@@ -386,12 +682,13 @@ function sliceUsageBucket(bucket, startMs, endMs, fraction) {
     rangeAllocationEstimated: true,
     rangeAllocationFraction:
       (positiveNumber(bucket?.rangeAllocationFraction) || 1) * fraction,
+    rangeAllocationOrigin,
   };
   for (const field of NUMERIC_USAGE_FIELDS) {
-    fragment[field] = nonNegativeNumber(bucket?.[field]) * fraction;
+    fragment[field] = tokenValue(bucket?.[field], { allowFractional: true }) * fraction;
   }
   if (bucket?.rateCardCredits != null) {
-    fragment.rateCardCredits = nonNegativeNumber(bucket.rateCardCredits) * fraction;
+    fragment.rateCardCredits = nonNegativeFiniteValue(bucket.rateCardCredits) * fraction;
   }
   for (const field of FRACTIONAL_COUNT_FIELDS) {
     const value = field === "callCount"
@@ -418,7 +715,9 @@ export function splitUsageBucketsAtBoundaries(buckets, boundaryValues) {
   if (boundaries.length === 0) return Array.isArray(buckets) ? [...buckets] : [];
 
   const fragments = [];
-  for (const bucket of Array.isArray(buckets) ? buckets : []) {
+  for (const sourceBucket of Array.isArray(buckets) ? buckets : []) {
+    const bucket = normalizeTokenUsage(sourceBucket);
+    if (!bucket || bucket.invalidTokenRecord === true) continue;
     const interval = usageBucketInterval(bucket);
     if (interval === null) {
       fragments.push(bucket);
@@ -476,6 +775,7 @@ export function usageBucketsInRange(snapshot, startValue, endValue) {
 
 export function usageCallCount(bucket) {
   if (bucket == null || Object(bucket) !== bucket) return 0;
+  if (bucket.invalidTokenRecord === true) return 0;
   const stored = bucket.rangeAllocationEstimated === true
     ? positiveNumber(bucket.callCount)
     : positiveSafeInteger(bucket.callCount);
@@ -483,17 +783,18 @@ export function usageCallCount(bucket) {
 }
 
 export function usageDetailedCallCount(bucket) {
+  if (bucket?.invalidTokenRecord === true) return 0;
+  if (bucket?.breakdownAvailable === false) return 0;
   const callCount = usageCallCount(bucket);
-  const stored = bucket?.rangeAllocationEstimated === true
-    ? positiveNumber(bucket.detailedCallCount)
-    : positiveSafeInteger(bucket?.detailedCallCount);
-  return Math.min(
-    callCount,
-    stored || (bucket?.breakdownAvailable === false ? 0 : callCount),
+  const stored = nonNegativeStoredCount(
+    bucket?.detailedCallCount,
+    bucket?.rangeAllocationEstimated === true,
   );
+  return Math.min(callCount, stored ?? callCount);
 }
 
 export function usageInputCallCount(bucket) {
+  if (bucket?.invalidTokenRecord === true) return 0;
   const callCount = usageCallCount(bucket);
   const stored = bucket?.rangeAllocationEstimated === true
     ? positiveNumber(bucket.inputCallCount)
@@ -512,7 +813,12 @@ export function usageBucketStats(buckets) {
   const rows = Array.isArray(buckets) ? buckets : [];
   return {
     bucketCount: rows.length,
-    callCount: rows.reduce((sum, row) => sum + usageCallCount(row), 0),
+    callCount: rows.reduce(
+      (sum, row) => checkedTokenAdd(sum, usageCallCount(row), {
+        allowFractional: row?.rangeAllocationEstimated === true,
+      }),
+      0,
+    ),
     maximumResolutionSeconds: rows.reduce(
       (maximum, row) => Math.max(
         maximum,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tledger",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A local-only terminal dashboard for Codex token usage",
   "license": "MIT",
   "keywords": [
@@ -36,20 +36,23 @@
   },
   "scripts": {
     "test": "node --test tests/*.test.mjs",
-    "cli:test": "node --test tests/token-ledger-cli.test.mjs",
-    "lint": "eslint . && oxlint",
-    "usage:snapshot": "node lib/token-ledger-importer.mjs --output outputs/token-ledger-snapshot-v2.json.gz",
+    "test:stress": "node --test tests/stress/*.test.mjs",
+    "test:all": "node tools/run-tests.mjs all",
+    "cli:test": "node --test tests/cli.smoke.test.mjs",
+    "lint": "eslint .",
+    "usage:snapshot": "node lib/token-ledger-importer.mjs --output outputs/token-ledger-snapshot-v3.json.gz",
     "usage:day": "node bin/token-ledger.mjs day",
     "usage:week": "node bin/token-ledger.mjs week",
     "verify:release": "node tools/verify-release.mjs",
-    "prepublishOnly": "npm test && npm run verify:release",
-    "lint:eslint": "eslint .",
-    "lint:oxlint": "oxlint"
+    "prepublishOnly": "npm run test:all && npm run lint && npm run verify:release",
+    "benchmark:refresh": "node tools/benchmark-importer.mjs",
+    "test:fast": "node tools/run-tests.mjs fast",
+    "test:integration": "node tools/run-tests.mjs integration",
+    "check": "npm test && npm run lint"
   },
   "devDependencies": {
-    "@oxlint/plugins": "1.79.0",
-    "eslint": "9.39.4",
-    "oxlint": "1.79.0"
+    "@eslint/js": "9.39.4",
+    "eslint": "9.39.4"
   },
   "type": "module",
   "dependencies": {

package/bin/token-ledger-rates.mjs

@@ -1,65 +0,0 @@
-// Pricing weights are used only for the separate attribution lens. They are
-// never used to scale or relabel the actual-token columns.
-export const RATE_CARD_AS_OF = "2026-08-17";
-
-// Fast mode (service tier "priority") debits the plan limit at a higher rate.
-export const FAST_MODE_MULTIPLIER = 1.5;
-
-export const RATE_CARD = {
-  "gpt-5.6-sol": { input: 125, cached: 12.5, output: 750 },
-  "gpt-5.6-terra": { input: 50, cached: 5, output: 300 },
-  "gpt-5.6-luna": { input: 5, cached: 0.5, output: 30 },
-  "gpt-5.5": { input: 125, cached: 12.5, output: 750 },
-  "gpt-5.5-cyber": { input: 500, cached: 50, output: 3_000 },
-  "gpt-5.4": { input: 62.5, cached: 6.25, output: 375 },
-  "gpt-5.4-mini": { input: 18.75, cached: 1.875, output: 113 },
-  "gpt-5.3-codex": { input: 43.75, cached: 4.375, output: 350 },
-  "gpt-5.2": { input: 43.75, cached: 4.375, output: 350 },
-};
-
-export function normalizeModel(model) {
-  // Collapse underscore and whitespace separators to dashes so variants like
-  // "gpt-5.4 mini" resolve to their own rate-card entry. Keep in lockstep
-  // with normalizeModel in lib/token-ledger-importer.mjs.
-  const value = String(model || "unknown")
-    .trim()
-    .toLowerCase()
-    .replace(/[\s_]+/g, "-");
-  if (RATE_CARD[value]) return value;
-  if (value.startsWith("gpt-5.6-sol")) return "gpt-5.6-sol";
-  if (value.startsWith("gpt-5.6-terra")) return "gpt-5.6-terra";
-  if (value.startsWith("gpt-5.6-luna")) return "gpt-5.6-luna";
-  if (value.startsWith("gpt-5.5-cyber")) return "gpt-5.5-cyber";
-  if (value.startsWith("gpt-5.5")) return "gpt-5.5";
-  if (value.startsWith("gpt-5.4-mini")) return "gpt-5.4-mini";
-  if (value.startsWith("gpt-5.4")) return "gpt-5.4";
-  if (value.startsWith("gpt-5.3-codex")) return "gpt-5.3-codex";
-  if (value.startsWith("gpt-5.2")) return "gpt-5.2";
-  return value || "unknown";
-}
-
-function hasDetailedBreakdown(usage) {
-  const totalTokens = Number(usage.totalTokens) || 0;
-  const inputTokens = Number(usage.inputTokens) || 0;
-  const outputTokens = Number(usage.outputTokens) || 0;
-  if (totalTokens === 0) return true;
-  return (
-    inputTokens + outputTokens === totalTokens &&
-    (inputTokens > 0 || outputTokens > 0)
-  );
-}
-
-export function creditsForUsage(model, usage) {
-  if (!hasDetailedBreakdown(usage)) return null;
-  const rate = RATE_CARD[normalizeModel(model)];
-  if (!rate) return null;
-  const inputTokens = Math.max(0, Number(usage.inputTokens) || 0);
-  const cachedInputTokens = Math.max(0, Number(usage.cachedInputTokens) || 0);
-  const outputTokens = Math.max(0, Number(usage.outputTokens) || 0);
-  const cached = Math.min(inputTokens, cachedInputTokens);
-  const uncached = Math.max(0, inputTokens - cached);
-  return (
-    (uncached * rate.input + cached * rate.cached + outputTokens * rate.output) /
-    1_000_000
-  );
-}