ai-zero-token 2.0.7 → 2.0.8

package/dist/core/services/usage-service.js

@@ -10,15 +10,62 @@ import {
   getUsageLifetimePath
 } from "../store/state-paths.js";
 const durationBucketLimits = [100, 300, 500, 1e3, 2e3, 5e3, 1e4, 3e4, 6e4, 12e4, Number.POSITIVE_INFINITY];
+const openAIGpt54LongContextInputThreshold = 272e3;
+const gpt54Pricing = {
+  inputUsdPerToken: 25e-7,
+  outputUsdPerToken: 15e-6,
+  cacheCreationUsdPerToken: 25e-7,
+  cacheReadUsdPerToken: 25e-8,
+  longContextInputThreshold: openAIGpt54LongContextInputThreshold,
+  longContextInputMultiplier: 2,
+  longContextOutputMultiplier: 1.5
+};
+const tokenPricingByModel = {
+  "gpt-5.5": gpt54Pricing,
+  "gpt-5.4": gpt54Pricing,
+  "gpt-5.4-mini": {
+    inputUsdPerToken: 75e-8,
+    outputUsdPerToken: 45e-7,
+    cacheCreationUsdPerToken: 0,
+    cacheReadUsdPerToken: 75e-9
+  },
+  "gpt-5.4-nano": {
+    inputUsdPerToken: 2e-7,
+    outputUsdPerToken: 125e-8,
+    cacheCreationUsdPerToken: 0,
+    cacheReadUsdPerToken: 2e-8
+  },
+  "gpt-5.2": {
+    inputUsdPerToken: 175e-8,
+    outputUsdPerToken: 14e-6,
+    cacheCreationUsdPerToken: 175e-8,
+    cacheReadUsdPerToken: 175e-9
+  },
+  "gpt-5.3-codex": {
+    inputUsdPerToken: 15e-7,
+    outputUsdPerToken: 12e-6,
+    cacheCreationUsdPerToken: 15e-7,
+    cacheReadUsdPerToken: 15e-8
+  }
+};
 function createAggregate() {
   return {
     requestCount: 0,
     successCount: 0,
     failureCount: 0,
     inputTokens: 0,
+    uncachedInputTokens: 0,
     outputTokens: 0,
     totalTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    inputCostUsd: 0,
+    outputCostUsd: 0,
+    cacheCreationCostUsd: 0,
+    cacheReadCostUsd: 0,
+    estimatedCostUsd: 0,
     unknownTokenCount: 0,
+    unknownTokenStatusCounts: {},
     imageCount: 0,
     totalDurationMs: 0,
     averageDurationMs: 0,
@@ -29,6 +76,7 @@ function createAggregate() {
 function cloneAggregate(value) {
   return {
     ...value,
+    unknownTokenStatusCounts: { ...value.unknownTokenStatusCounts },
     durationBuckets: { ...value.durationBuckets }
   };
 }
@@ -40,14 +88,25 @@ function normalizeAggregate(value) {
     return createAggregate();
   }
   const record = value;
+  const inputTokens = Math.max(0, Math.trunc(normalizeNumber(record.inputTokens)));
+  const cacheReadTokens = Math.max(0, Math.trunc(normalizeNumber(record.cacheReadTokens)));
   const aggregate = {
     requestCount: Math.max(0, Math.trunc(normalizeNumber(record.requestCount))),
     successCount: Math.max(0, Math.trunc(normalizeNumber(record.successCount))),
     failureCount: Math.max(0, Math.trunc(normalizeNumber(record.failureCount))),
-    inputTokens: Math.max(0, Math.trunc(normalizeNumber(record.inputTokens))),
+    inputTokens,
+    uncachedInputTokens: Math.max(0, Math.trunc(normalizeNumber(record.uncachedInputTokens, Math.max(0, inputTokens - cacheReadTokens)))),
     outputTokens: Math.max(0, Math.trunc(normalizeNumber(record.outputTokens))),
     totalTokens: Math.max(0, Math.trunc(normalizeNumber(record.totalTokens))),
+    cacheCreationTokens: Math.max(0, Math.trunc(normalizeNumber(record.cacheCreationTokens))),
+    cacheReadTokens,
+    inputCostUsd: Math.max(0, normalizeNumber(record.inputCostUsd)),
+    outputCostUsd: Math.max(0, normalizeNumber(record.outputCostUsd)),
+    cacheCreationCostUsd: Math.max(0, normalizeNumber(record.cacheCreationCostUsd)),
+    cacheReadCostUsd: Math.max(0, normalizeNumber(record.cacheReadCostUsd)),
+    estimatedCostUsd: Math.max(0, normalizeNumber(record.estimatedCostUsd)),
     unknownTokenCount: Math.max(0, Math.trunc(normalizeNumber(record.unknownTokenCount))),
+    unknownTokenStatusCounts: {},
     imageCount: Math.max(0, Math.trunc(normalizeNumber(record.imageCount))),
     totalDurationMs: Math.max(0, normalizeNumber(record.totalDurationMs)),
     averageDurationMs: 0,
@@ -59,6 +118,11 @@ function normalizeAggregate(value) {
       aggregate.durationBuckets[key] = Math.max(0, Math.trunc(normalizeNumber(item)));
     }
   }
+  if (record.unknownTokenStatusCounts && typeof record.unknownTokenStatusCounts === "object") {
+    for (const [key, item] of Object.entries(record.unknownTokenStatusCounts)) {
+      aggregate.unknownTokenStatusCounts[key] = Math.max(0, Math.trunc(normalizeNumber(item)));
+    }
+  }
   refreshDerivedMetrics(aggregate);
   return aggregate;
 }
@@ -96,6 +160,7 @@ function createLifetimeStore() {
     byModel: {},
     byEndpoint: {},
     byError: {},
+    byTokenUsageStatus: {},
     byImageRoute: {},
     bySource: {}
   };
@@ -126,6 +191,7 @@ function normalizeLifetimeStore(value) {
     byModel: normalizeDimensionStore(record.byModel),
     byEndpoint: normalizeDimensionStore(record.byEndpoint),
     byError: normalizeDimensionStore(record.byError),
+    byTokenUsageStatus: normalizeDimensionStore(record.byTokenUsageStatus),
     byImageRoute: normalizeDimensionStore(record.byImageRoute),
     bySource: normalizeDimensionStore(record.bySource)
   };
@@ -175,18 +241,183 @@ function refreshDerivedMetrics(aggregate) {
 function tokenNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
 }
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function normalizeTokenUsageForEvent(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const usage = {
+    inputTokens: tokenNumber(record.inputTokens),
+    uncachedInputTokens: tokenNumber(record.uncachedInputTokens),
+    outputTokens: tokenNumber(record.outputTokens),
+    totalTokens: tokenNumber(record.totalTokens),
+    cacheCreationTokens: tokenNumber(record.cacheCreationTokens),
+    cacheReadTokens: tokenNumber(record.cacheReadTokens)
+  };
+  return Object.values(usage).some((item) => item !== null) ? usage : null;
+}
+function normalizeImageRoute(value) {
+  return value === "codex-tool" || value === "chatgpt-web" ? value : "none";
+}
+function normalizeTokenUsageStatus(value, tokenUsage, success) {
+  if (value === "captured" || value === "missing_terminal" || value === "terminal_without_usage" || value === "parse_failed" || value === "upstream_error" || value === "not_returned") {
+    return value;
+  }
+  if (tokenNumber(tokenUsage?.totalTokens) !== null) {
+    return "captured";
+  }
+  return success ? "not_returned" : "upstream_error";
+}
+function normalizeUsageRecordEvent(event) {
+  const statusCode = Math.trunc(normalizeNumber(event.statusCode));
+  const timestamp = normalizeNumber(event.timestamp, Date.now());
+  const success = event.success ?? (statusCode >= 200 && statusCode < 400);
+  const tokenUsage = normalizeTokenUsageForEvent(event.tokenUsage);
+  return {
+    ...event,
+    id: optionalString(event.id) ?? randomUUID(),
+    timestamp,
+    statusCode,
+    durationMs: Math.max(0, normalizeNumber(event.durationMs)),
+    endpoint: optionalString(event.endpoint) ?? "-",
+    method: optionalString(event.method) ?? "-",
+    model: optionalString(event.model) ?? "-",
+    source: optionalString(event.source) ?? "-",
+    profileId: optionalString(event.profileId),
+    accountId: optionalString(event.accountId),
+    accountLabel: optionalString(event.accountLabel),
+    planType: optionalString(event.planType),
+    errorType: optionalString(event.errorType),
+    tokenUsage,
+    tokenUsageStatus: normalizeTokenUsageStatus(event.tokenUsageStatus, tokenUsage, success),
+    imageRoute: normalizeImageRoute(event.imageRoute),
+    imageCount: Math.max(0, Math.trunc(normalizeNumber(event.imageCount))),
+    success
+  };
+}
+function lastModelSegment(model) {
+  const trimmed = model.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const parts = trimmed.split("/");
+  return parts[parts.length - 1]?.trim() ?? "";
+}
+function canonicalizeModelForPricing(model) {
+  let normalized = lastModelSegment(model).toLowerCase();
+  if (!normalized) {
+    return "";
+  }
+  normalized = normalized.replaceAll("_", "-").replace(/\s+/g, "-");
+  while (normalized.includes("--")) {
+    normalized = normalized.replaceAll("--", "-");
+  }
+  if (normalized.startsWith("gpt5")) {
+    normalized = `gpt-5${normalized.slice("gpt5".length)}`;
+  }
+  normalized = normalized.replaceAll("gpt-5.4mini", "gpt-5.4-mini").replaceAll("gpt-5.4nano", "gpt-5.4-nano").replaceAll("gpt-5.3-codexspark", "gpt-5.3-codex-spark").replaceAll("gpt-5.3codexspark", "gpt-5.3-codex-spark").replaceAll("gpt-5.3codex", "gpt-5.3-codex");
+  const compactSuffix = "-openai-compact";
+  if (normalized.endsWith(compactSuffix)) {
+    normalized = normalized.slice(0, -compactSuffix.length);
+  }
+  return normalized;
+}
+function pricingKeyForModel(model) {
+  const normalized = canonicalizeModelForPricing(model);
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.includes("gpt-5.5")) {
+    return "gpt-5.5";
+  }
+  if (normalized.includes("gpt-5.4-mini")) {
+    return "gpt-5.4-mini";
+  }
+  if (normalized.includes("gpt-5.4-nano")) {
+    return "gpt-5.4-nano";
+  }
+  if (normalized.includes("gpt-5.4")) {
+    return "gpt-5.4";
+  }
+  if (normalized.includes("gpt-5.2")) {
+    return "gpt-5.2";
+  }
+  if (normalized.includes("gpt-5.3-codex") || normalized.includes("gpt-5.3") || normalized.includes("codex")) {
+    return "gpt-5.3-codex";
+  }
+  if (normalized.includes("gpt-5")) {
+    return "gpt-5.4";
+  }
+  return null;
+}
+function estimateUsageCost(model, tokenUsage) {
+  const pricingKey = pricingKeyForModel(model);
+  const pricing = pricingKey ? tokenPricingByModel[pricingKey] : void 0;
+  if (!pricing) {
+    return {
+      inputCostUsd: 0,
+      outputCostUsd: 0,
+      cacheCreationCostUsd: 0,
+      cacheReadCostUsd: 0,
+      estimatedCostUsd: 0
+    };
+  }
+  const inputTokens = tokenNumber(tokenUsage?.inputTokens) ?? 0;
+  const cacheReadTokens = tokenNumber(tokenUsage?.cacheReadTokens) ?? 0;
+  const uncachedInputTokens = tokenNumber(tokenUsage?.uncachedInputTokens) ?? Math.max(0, inputTokens - cacheReadTokens);
+  const outputTokens = tokenNumber(tokenUsage?.outputTokens) ?? 0;
+  const cacheCreationTokens = tokenNumber(tokenUsage?.cacheCreationTokens) ?? 0;
+  const totalInputTokens = uncachedInputTokens + cacheReadTokens;
+  const longContext = pricing.longContextInputThreshold && totalInputTokens > pricing.longContextInputThreshold;
+  const inputMultiplier = longContext ? pricing.longContextInputMultiplier ?? 1 : 1;
+  const outputMultiplier = longContext ? pricing.longContextOutputMultiplier ?? 1 : 1;
+  const inputCostUsd = uncachedInputTokens * pricing.inputUsdPerToken * inputMultiplier;
+  const outputCostUsd = outputTokens * pricing.outputUsdPerToken * outputMultiplier;
+  const cacheCreationCostUsd = cacheCreationTokens * pricing.cacheCreationUsdPerToken;
+  const cacheReadCostUsd = cacheReadTokens * pricing.cacheReadUsdPerToken;
+  return {
+    inputCostUsd,
+    outputCostUsd,
+    cacheCreationCostUsd,
+    cacheReadCostUsd,
+    estimatedCostUsd: inputCostUsd + outputCostUsd + cacheCreationCostUsd + cacheReadCostUsd
+  };
+}
+function tokenUsageStatusForEvent(event) {
+  return normalizeTokenUsageStatus(event.tokenUsageStatus, event.tokenUsage ?? null, event.success ?? (event.statusCode >= 200 && event.statusCode < 400));
+}
 function addToAggregate(aggregate, event) {
   const success = event.success ?? (event.statusCode >= 200 && event.statusCode < 400);
   const inputTokens = tokenNumber(event.tokenUsage?.inputTokens);
+  const cacheReadTokens = tokenNumber(event.tokenUsage?.cacheReadTokens);
+  const cacheCreationTokens = tokenNumber(event.tokenUsage?.cacheCreationTokens);
+  const inferredUncachedInputTokens = inputTokens !== null ? Math.max(0, inputTokens - (cacheReadTokens ?? 0)) : null;
+  const uncachedInputTokens = tokenNumber(event.tokenUsage?.uncachedInputTokens) ?? inferredUncachedInputTokens;
   const outputTokens = tokenNumber(event.tokenUsage?.outputTokens);
   const totalTokens = tokenNumber(event.tokenUsage?.totalTokens) ?? (inputTokens !== null || outputTokens !== null ? (inputTokens ?? 0) + (outputTokens ?? 0) : null);
+  const cost = estimateUsageCost(event.model, event.tokenUsage);
   aggregate.requestCount += 1;
   aggregate.successCount += success ? 1 : 0;
   aggregate.failureCount += success ? 0 : 1;
   aggregate.inputTokens += inputTokens ?? 0;
+  aggregate.uncachedInputTokens += uncachedInputTokens ?? 0;
   aggregate.outputTokens += outputTokens ?? 0;
   aggregate.totalTokens += totalTokens ?? 0;
-  aggregate.unknownTokenCount += totalTokens === null ? 1 : 0;
+  aggregate.cacheCreationTokens += cacheCreationTokens ?? 0;
+  aggregate.cacheReadTokens += cacheReadTokens ?? 0;
+  aggregate.inputCostUsd += cost.inputCostUsd;
+  aggregate.outputCostUsd += cost.outputCostUsd;
+  aggregate.cacheCreationCostUsd += cost.cacheCreationCostUsd;
+  aggregate.cacheReadCostUsd += cost.cacheReadCostUsd;
+  aggregate.estimatedCostUsd += cost.estimatedCostUsd;
+  if (totalTokens === null) {
+    const tokenUsageStatus = tokenUsageStatusForEvent(event);
+    aggregate.unknownTokenCount += 1;
+    aggregate.unknownTokenStatusCounts[tokenUsageStatus] = (aggregate.unknownTokenStatusCounts[tokenUsageStatus] ?? 0) + 1;
+  }
   aggregate.imageCount += Math.max(0, Math.trunc(event.imageCount ?? 0));
   aggregate.totalDurationMs += Math.max(0, event.durationMs);
   const bucket = durationBucketKey(event.durationMs);
@@ -202,6 +433,42 @@ function imageRouteLabel(route) {
   }
   return "\u975E\u751F\u56FE";
 }
+function tokenUsageStatusLabel(status) {
+  if (status === "captured") {
+    return "\u5DF2\u6355\u83B7\u7528\u91CF";
+  }
+  if (status === "missing_terminal") {
+    return "\u7F3A\u5C11\u7EC8\u6001\u4E8B\u4EF6";
+  }
+  if (status === "terminal_without_usage") {
+    return "\u7EC8\u6001\u65E0 usage";
+  }
+  if (status === "parse_failed") {
+    return "SSE \u89E3\u6790\u5931\u8D25";
+  }
+  if (status === "upstream_error") {
+    return "\u4E0A\u6E38\u9519\u8BEF";
+  }
+  return "\u672A\u8FD4\u56DE usage";
+}
+function addEventToStores(daily, lifetime, normalized) {
+  const date = formatLocalDate(normalized.timestamp);
+  daily.days[date] = daily.days[date] ? normalizeAggregate(daily.days[date]) : createAggregate();
+  addToAggregate(daily.days[date], normalized);
+  addToAggregate(lifetime.aggregate, normalized);
+  bumpDimension(lifetime.byAccount, normalized.profileId || normalized.accountId || normalized.accountLabel || "-", normalized.accountLabel || normalized.accountId || normalized.profileId || "-", normalized);
+  bumpDimension(lifetime.byModel, normalized.model || "-", normalized.model || "-", normalized);
+  bumpDimension(lifetime.byEndpoint, `${normalized.method} ${normalized.endpoint}`, `${normalized.method} ${normalized.endpoint}`, normalized);
+  bumpDimension(lifetime.bySource, normalized.source || "-", normalized.source || "-", normalized);
+  bumpDimension(lifetime.byTokenUsageStatus, normalized.tokenUsageStatus ?? "not_returned", tokenUsageStatusLabel(normalized.tokenUsageStatus ?? "not_returned"), normalized);
+  bumpDimension(lifetime.byImageRoute, normalized.imageRoute, imageRouteLabel(normalized.imageRoute), normalized);
+  if (!normalized.success) {
+    const errorType = normalized.errorType?.trim() || `HTTP ${normalized.statusCode}`;
+    bumpDimension(lifetime.byError, errorType, errorType, normalized);
+  }
+  daily.updatedAt = Math.max(daily.updatedAt, normalized.timestamp);
+  lifetime.updatedAt = Math.max(lifetime.updatedAt, normalized.timestamp);
+}
 function bumpDimension(store, key, label, event) {
   const normalizedKey = key.trim() || "-";
   const existing = store[normalizedKey] ?? {
@@ -227,6 +494,14 @@ async function readJsonFile(filePath) {
     return null;
   }
 }
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function writeJsonAtomic(filePath, value) {
   await fs.mkdir(path.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
@@ -239,6 +514,86 @@ async function writeJsonAtomic(filePath, value) {
     throw error;
   }
 }
+function formatBackupTimestamp(date = /* @__PURE__ */ new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}-${hours}${minutes}${seconds}`;
+}
+async function uniqueBackupDir(usageDir) {
+  const parentDir = path.dirname(usageDir);
+  const baseName = `${path.basename(usageDir)}.backup.${formatBackupTimestamp()}`;
+  let candidate = path.join(parentDir, baseName);
+  for (let index = 2; await fileExists(candidate); index += 1) {
+    candidate = path.join(parentDir, `${baseName}-${index}`);
+  }
+  return candidate;
+}
+function aggregateNeedsCostBackfill(aggregate) {
+  return aggregate.totalTokens > 0 && aggregate.estimatedCostUsd <= 0;
+}
+function shouldBackfillUsageCosts(daily, lifetime) {
+  const knownPricedModelMissingCost = Object.values(lifetime.byModel).some(
+    (row) => aggregateNeedsCostBackfill(row.aggregate) && pricingKeyForModel(row.key) !== null
+  );
+  if (!knownPricedModelMissingCost) {
+    return false;
+  }
+  return aggregateNeedsCostBackfill(lifetime.aggregate) || Object.values(daily.days).some(aggregateNeedsCostBackfill);
+}
+function shouldBackfillUsageDiagnostics(daily, lifetime) {
+  if (lifetime.aggregate.requestCount <= 0) {
+    return false;
+  }
+  if (Object.keys(lifetime.byTokenUsageStatus).length === 0) {
+    return true;
+  }
+  if (lifetime.aggregate.unknownTokenCount > 0 && Object.keys(lifetime.aggregate.unknownTokenStatusCounts).length === 0) {
+    return true;
+  }
+  return Object.values(daily.days).some(
+    (aggregate) => aggregate.unknownTokenCount > 0 && Object.keys(aggregate.unknownTokenStatusCounts).length === 0
+  );
+}
+async function rebuildStoresFromEventLogs() {
+  let entries;
+  try {
+    entries = await fs.readdir(getUsageEventsDir());
+  } catch {
+    return null;
+  }
+  const eventFiles = entries.filter((entry) => entry.endsWith(".jsonl")).sort();
+  if (eventFiles.length === 0) {
+    return null;
+  }
+  const daily = createDailyStore();
+  const lifetime = createLifetimeStore();
+  let seen = false;
+  for (const fileName of eventFiles) {
+    let content;
+    try {
+      content = await fs.readFile(path.join(getUsageEventsDir(), fileName), "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(trimmed);
+        addEventToStores(daily, lifetime, normalizeUsageRecordEvent(parsed));
+        seen = true;
+      } catch {
+      }
+    }
+  }
+  return seen ? { daily, lifetime } : null;
+}
 class UsageService {
   startedAt = Date.now();
   startupAggregate = createAggregate();
@@ -248,39 +603,13 @@ class UsageService {
   saveQueue = Promise.resolve();
   async record(event) {
     await this.ensureLoaded();
-    const timestamp = event.timestamp ?? Date.now();
+    const normalized = normalizeUsageRecordEvent(event);
+    const timestamp = normalized.timestamp;
     const date = formatLocalDate(timestamp);
-    const normalized = {
-      ...event,
-      id: event.id ?? randomUUID(),
-      timestamp,
-      statusCode: event.statusCode,
-      durationMs: Math.max(0, event.durationMs),
-      endpoint: event.endpoint || "-",
-      method: event.method || "-",
-      model: event.model || "-",
-      source: event.source || "-",
-      imageRoute: event.imageRoute ?? "none",
-      imageCount: Math.max(0, Math.trunc(event.imageCount ?? 0)),
-      success: event.success ?? (event.statusCode >= 200 && event.statusCode < 400)
-    };
     const daily = this.dailyStore ?? createDailyStore();
     const lifetime = this.lifetimeStore ?? createLifetimeStore();
-    daily.days[date] = daily.days[date] ? normalizeAggregate(daily.days[date]) : createAggregate();
     addToAggregate(this.startupAggregate, normalized);
-    addToAggregate(daily.days[date], normalized);
-    addToAggregate(lifetime.aggregate, normalized);
-    bumpDimension(lifetime.byAccount, normalized.profileId || normalized.accountId || normalized.accountLabel || "-", normalized.accountLabel || normalized.accountId || normalized.profileId || "-", normalized);
-    bumpDimension(lifetime.byModel, normalized.model || "-", normalized.model || "-", normalized);
-    bumpDimension(lifetime.byEndpoint, `${normalized.method} ${normalized.endpoint}`, `${normalized.method} ${normalized.endpoint}`, normalized);
-    bumpDimension(lifetime.bySource, normalized.source || "-", normalized.source || "-", normalized);
-    bumpDimension(lifetime.byImageRoute, normalized.imageRoute ?? "none", imageRouteLabel(normalized.imageRoute ?? "none"), normalized);
-    if (!normalized.success) {
-      const errorType = normalized.errorType?.trim() || `HTTP ${normalized.statusCode}`;
-      bumpDimension(lifetime.byError, errorType, errorType, normalized);
-    }
-    daily.updatedAt = timestamp;
-    lifetime.updatedAt = timestamp;
+    addEventToStores(daily, lifetime, normalized);
     this.dailyStore = daily;
     this.lifetimeStore = lifetime;
     const eventPath = path.join(getUsageEventsDir(), `${date}.jsonl`);
@@ -323,10 +652,41 @@ class UsageService {
       byModel: topRows(lifetime.byModel, 16),
       byEndpoint: topRows(lifetime.byEndpoint, 16),
       byError: topRows(lifetime.byError, 16),
+      byTokenUsageStatus: topRows(lifetime.byTokenUsageStatus, 8),
       byImageRoute: topRows(lifetime.byImageRoute, 8),
       bySource: topRows(lifetime.bySource, 8)
     };
   }
+  async backupAndReset() {
+    await this.ensureLoaded();
+    let backupDir = "";
+    const reset = async () => {
+      const usageDir = getUsageDir();
+      await fs.mkdir(path.dirname(usageDir), { recursive: true });
+      backupDir = await uniqueBackupDir(usageDir);
+      if (await fileExists(usageDir)) {
+        await fs.rename(usageDir, backupDir);
+      } else {
+        await fs.mkdir(backupDir, { recursive: true });
+      }
+      const daily = createDailyStore();
+      const lifetime = createLifetimeStore();
+      Object.assign(this.startupAggregate, createAggregate());
+      this.dailyStore = daily;
+      this.lifetimeStore = lifetime;
+      await fs.mkdir(getUsageEventsDir(), { recursive: true });
+      await Promise.all([
+        writeJsonAtomic(getUsageDailyPath(), daily),
+        writeJsonAtomic(getUsageLifetimePath(), lifetime)
+      ]);
+    };
+    this.saveQueue = this.saveQueue.then(reset, reset);
+    await this.saveQueue;
+    return {
+      backupDir,
+      usage: await this.getSummary()
+    };
+  }
   async ensureLoaded() {
     if (!this.loadPromise) {
       this.loadPromise = (async () => {
@@ -339,6 +699,17 @@ class UsageService {
         ]);
         this.dailyStore = normalizeDailyStore(dailyRaw);
         this.lifetimeStore = normalizeLifetimeStore(lifetimeRaw);
+        if (shouldBackfillUsageCosts(this.dailyStore, this.lifetimeStore) || shouldBackfillUsageDiagnostics(this.dailyStore, this.lifetimeStore)) {
+          const rebuilt = await rebuildStoresFromEventLogs();
+          if (rebuilt) {
+            this.dailyStore = rebuilt.daily;
+            this.lifetimeStore = rebuilt.lifetime;
+            await Promise.all([
+              writeJsonAtomic(getUsageDailyPath(), rebuilt.daily),
+              writeJsonAtomic(getUsageLifetimePath(), rebuilt.lifetime)
+            ]);
+          }
+        }
       })();
     }
     await this.loadPromise;

package/dist/core/store/codex-auth-store.js

@@ -48,10 +48,71 @@ function sqliteQuote(value) {
 async function runSqlite(dbPath, sql) {
   const { stdout } = await execFileAsync("sqlite3", [dbPath, sql], {
     timeout: 15e3,
-    maxBuffer: 1024 * 1024
+    maxBuffer: 8 * 1024 * 1024
   });
   return stdout.trim();
 }
+function resolveCodexSessionPath(value) {
+  return path.isAbsolute(value) ? value : path.join(getCodexHomeDir(), value);
+}
+function parseLegacyHistoryThreadRows(raw) {
+  if (!raw.trim()) {
+    return [];
+  }
+  return raw.split(/\r?\n/).map((line) => {
+    const separator = line.indexOf("	");
+    if (separator === -1) {
+      return null;
+    }
+    const id = line.slice(0, separator).trim();
+    const rolloutPath = line.slice(separator + 1).trim();
+    return id && rolloutPath ? { id, rolloutPath } : null;
+  }).filter((item) => Boolean(item));
+}
+async function patchSessionRolloutProvider(rolloutPath, backupSuffix, fromProvider, toProvider) {
+  const targetPath = resolveCodexSessionPath(rolloutPath);
+  let raw = "";
+  try {
+    raw = await fs.readFile(targetPath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+  const newline = raw.includes("\r\n") ? "\r\n" : "\n";
+  const trailingNewline = raw.endsWith("\n");
+  const lines = raw.replace(/\r?\n$/u, "").split(/\r?\n/u);
+  let changed = false;
+  for (let index = 0; index < Math.min(lines.length, 20); index += 1) {
+    try {
+      const parsed = JSON.parse(lines[index] ?? "");
+      if (!isRecord(parsed) || parsed.type !== "session_meta" || !isRecord(parsed.payload)) {
+        continue;
+      }
+      if (parsed.payload.model_provider !== fromProvider) {
+        return false;
+      }
+      parsed.payload.model_provider = toProvider;
+      lines[index] = JSON.stringify(parsed);
+      changed = true;
+      break;
+    } catch {
+      continue;
+    }
+  }
+  if (!changed) {
+    return false;
+  }
+  await fs.copyFile(targetPath, `${targetPath}.azt-backup-${backupSuffix}`);
+  const tmpPath = `${targetPath}.tmp-${process.pid}`;
+  await fs.writeFile(tmpPath, `${lines.join(newline)}${trailingNewline ? newline : ""}`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await fs.rename(tmpPath, targetPath);
+  return true;
+}
 async function migrateLegacyCodexHistoryProvider() {
   const dbPath = getCodexStateDbPath();
   if (!await fileExists(dbPath)) {
@@ -62,20 +123,32 @@ async function migrateLegacyCodexHistoryProvider() {
     };
   }
   try {
-    const countRaw = await runSqlite(
+    const rowsRaw = await runSqlite(
       dbPath,
-      `select count(*) from threads where model_provider=${sqliteQuote(LEGACY_CODEX_PROVIDER_ID)};`
+      `select id || char(9) || rollout_path from threads where model_provider=${sqliteQuote(LEGACY_CODEX_PROVIDER_ID)};`
     );
-    const migratedCount = Number.parseInt(countRaw, 10);
-    if (!Number.isFinite(migratedCount) || migratedCount <= 0) {
+    const legacyThreads = parseLegacyHistoryThreadRows(rowsRaw);
+    if (legacyThreads.length <= 0) {
       return {
         path: dbPath,
         migratedCount: 0,
         skipped: true
       };
     }
-    const backupPath = `${dbPath}.azt-backup-${createBackupSuffix()}`;
+    const backupSuffix = createBackupSuffix();
+    const backupPath = `${dbPath}.azt-backup-${backupSuffix}`;
     await runSqlite(dbPath, `.backup ${sqliteQuote(backupPath)}`);
+    let rolloutPatchedCount = 0;
+    const rolloutPatchErrors = [];
+    for (const thread of legacyThreads) {
+      try {
+        if (await patchSessionRolloutProvider(thread.rolloutPath, backupSuffix, LEGACY_CODEX_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID)) {
+          rolloutPatchedCount += 1;
+        }
+      } catch (error) {
+        rolloutPatchErrors.push(`${thread.id}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     await runSqlite(
       dbPath,
       `update threads set model_provider=${sqliteQuote(OPENAI_CODEX_PROVIDER_ID)} where model_provider=${sqliteQuote(LEGACY_CODEX_PROVIDER_ID)};`
@@ -83,7 +156,9 @@ async function migrateLegacyCodexHistoryProvider() {
     return {
       path: dbPath,
       backupPath,
-      migratedCount
+      migratedCount: legacyThreads.length,
+      rolloutPatchedCount,
+      rolloutPatchErrors: rolloutPatchErrors.length ? rolloutPatchErrors.slice(0, 20) : void 0
     };
   } catch (error) {
     return {