@bitkyc08/opencodex 2.35.0 → 2.36.0-preview.20260830

package/src/usage/summary.ts

@@ -2,7 +2,7 @@ import { baseProviderLabel } from "../providers/label";
 import { canonicalAntigravityUsageModel } from "../providers/antigravity-models";
 import { usageDisplayTotalTokens } from "./totals";
 import { isCodexUsageAccountLogLabel, type PersistedUsageEntry, type UsageStatus } from "./log";
-import { estimateAttemptCost, estimateComboCost, estimateRequestCost, serviceTierContext } from "./cost";
+import { type AttemptCostEstimate, type CostEstimate, estimateAttemptCost, estimateRequestCost, serviceTierContext, type ServiceTierContext } from "./cost";
 
 /**
  * Canonical range members. The warm-up loop in the management usage route
@@ -60,8 +60,12 @@ export interface UsageDayModel {
   requests: number;
   attemptCount: number;
   totalTokens: number;
-  /** Display-time estimated cost attributed to this provider/model on this day. */
-  estimatedCostUsd: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadInputTokens?: number;
+  cacheCreationInputTokens?: number;
+  cacheHitRate?: number | null;
+  estimatedCostUsd?: number;
 }
 
 export interface UsageModel {
@@ -76,6 +80,13 @@ export interface UsageModel {
   totalTokens: number;
   inputTokens: number;
   outputTokens: number;
+  cachedInputTokens?: number;
+  cacheReadInputTokens?: number;
+  cacheCreationInputTokens?: number;
+  cacheHitRate?: number | null;
+  priceCoverageRatio?: number;
+  pricedRequests?: number;
+  unpricedRequests?: number;
   shareRatio: number;
   estimatedCostUsd?: number;
 }
@@ -88,6 +99,15 @@ export interface UsageProvider {
   reportedRequests: number;
   estimatedRequests: number;
   totalTokens: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  cachedInputTokens?: number;
+  cacheReadInputTokens?: number;
+  cacheCreationInputTokens?: number;
+  cacheHitRate?: number | null;
+  priceCoverageRatio?: number;
+  pricedRequests?: number;
+  unpricedRequests?: number;
   shareRatio: number;
   estimatedCostUsd?: number;
 }
@@ -146,6 +166,72 @@ export interface UsageFilterEcho {
   comboOverlap: boolean;
 }
 
+export interface EntryCostInfo {
+  tier: ServiceTierContext;
+  estimate: CostEstimate | null;
+  attemptEstimates?: (AttemptCostEstimate | null)[];
+  costTotal: number;
+  isPriced: boolean;
+}
+
+export function cacheTokensFromUsage(usage?: PersistedUsageEntry["usage"]): {
+  read: number | undefined;
+  creation: number | undefined;
+  hasCacheTelemetry: boolean;
+} {
+  if (!usage) return { read: undefined, creation: undefined, hasCacheTelemetry: false };
+  const creation = usage.cacheCreationInputTokens;
+  const read = typeof usage.cacheReadInputTokens === "number"
+    ? usage.cacheReadInputTokens
+    : typeof usage.cachedInputTokens === "number" && typeof creation === "number"
+      ? Math.max(0, usage.cachedInputTokens - creation)
+      : usage.cachedInputTokens;
+  const hasCacheTelemetry = typeof usage.cachedInputTokens === "number"
+    || typeof usage.cacheReadInputTokens === "number"
+    || typeof usage.cacheCreationInputTokens === "number";
+  return { read, creation, hasCacheTelemetry };
+}
+
+export function calculateCacheHitRate(
+  cacheObserved: boolean,
+  inputTokens: number,
+  cacheReadTokens: number,
+): number | null {
+  if (!cacheObserved || inputTokens <= 0) return null;
+  return Math.max(0, Math.min(1, cacheReadTokens / inputTokens));
+}
+
+export function computeEntryCost(entry: PersistedUsageEntry): EntryCostInfo {
+  const tier = serviceTierContext(entry);
+  if (entry.attempts?.length) {
+    const attemptEstimates = entry.attempts.map(attempt =>
+      estimateAttemptCost(attempt, undefined, tier)
+    );
+    let costTotal = 0;
+    let isPriced = false;
+    for (const est of attemptEstimates) {
+      if (est) {
+        costTotal += est.cost.total;
+        isPriced = true;
+      }
+    }
+    return { tier, estimate: null, attemptEstimates, costTotal, isPriced };
+  }
+  const estimate = estimateRequestCost({
+    provider: entry.provider,
+    model: entry.model,
+    usage: entry.usage,
+    usageStatus: entry.usageStatus,
+    serviceTier: tier,
+  });
+  return {
+    tier,
+    estimate,
+    costTotal: estimate ? estimate.cost.total : 0,
+    isPriced: estimate !== null,
+  };
+}
+
 const DAY_MS = 86_400_000;
 export const MAX_USAGE_MODEL_BREAKDOWN_ROWS = 256;
 
@@ -281,11 +367,6 @@ function usageModelKey(providerKey: string, model: string): string {
   return `${providerKey}/${model}`;
 }
 
-function antigravityUsageModel(provider: string, model: string): string {
-  if (baseProviderLabel(provider) !== "google-antigravity") return model;
-  return canonicalAntigravityUsageModel(model);
-}
-
 function usageAttributions(entry: PersistedUsageEntry): UsageAttribution[] {
   if (!entry.attempts?.length) {
     return [{
@@ -307,6 +388,63 @@ function usageAttributions(entry: PersistedUsageEntry): UsageAttribution[] {
   }));
 }
 
+function projectedComboUsage(
+  attempts: readonly NonNullable<PersistedUsageEntry["attempts"]>[number][],
+): { usage?: PersistedUsageEntry["usage"]; totalTokens?: number } {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cachedInputTokens = 0;
+  let cacheReadInputTokens = 0;
+  let cacheCreationInputTokens = 0;
+  let reasoningOutputTokens = 0;
+  let hasUsage = false;
+  let hasCacheTelemetry = false;
+  let hasReasoningTelemetry = false;
+  let totalTokens = 0;
+  let hasTotalTokens = false;
+  let estimated = false;
+
+  for (const attempt of attempts) {
+    if (attempt.usage) {
+      hasUsage = true;
+      inputTokens += attempt.usage.inputTokens;
+      outputTokens += attempt.usage.outputTokens;
+      const cache = cacheTokensFromUsage(attempt.usage);
+      if (cache.hasCacheTelemetry) hasCacheTelemetry = true;
+      if (typeof cache.read === "number") {
+        cachedInputTokens += cache.read;
+        cacheReadInputTokens += cache.read;
+      }
+      if (typeof cache.creation === "number") cacheCreationInputTokens += cache.creation;
+      if (typeof attempt.usage.reasoningOutputTokens === "number") {
+        hasReasoningTelemetry = true;
+        reasoningOutputTokens += attempt.usage.reasoningOutputTokens;
+      }
+      if (attempt.usage.estimated === true) estimated = true;
+    }
+    const attemptTotal = usageDisplayTotalTokens(attempt.usage, attempt.totalTokens);
+    if (attemptTotal !== undefined) {
+      hasTotalTokens = true;
+      totalTokens += attemptTotal;
+    }
+  }
+
+  if (!hasUsage && !hasTotalTokens) return {};
+  const usage = hasUsage
+    ? {
+      inputTokens,
+      outputTokens,
+      ...(hasCacheTelemetry ? { cachedInputTokens, cacheReadInputTokens, cacheCreationInputTokens } : {}),
+      ...(hasReasoningTelemetry ? { reasoningOutputTokens } : {}),
+      ...(estimated ? { estimated: true } : {}),
+    }
+    : undefined;
+  return {
+    ...(usage ? { usage } : {}),
+    ...(hasTotalTokens ? { totalTokens } : {}),
+  };
+}
+
 function foldAttributionStatuses(statuses: readonly UsageStatus[]): UsageStatus {
   if (statuses.length > 0 && statuses.every(status => status === "unsupported")) {
     return "unsupported";
@@ -334,15 +472,7 @@ function addTokens(
   if (!entry.usage) return;
   totals.inputTokens += entry.usage.inputTokens;
   totals.outputTokens += entry.usage.outputTokens;
-  // Prefer the explicit read/write split; legacy claude-route rows stored read+write
-  // combined in cachedInputTokens with only the creation split present (devlog 070),
-  // so recover reads by subtracting the write share for those rows.
-  const creation = entry.usage.cacheCreationInputTokens;
-  const read = typeof entry.usage.cacheReadInputTokens === "number"
-    ? entry.usage.cacheReadInputTokens
-    : typeof entry.usage.cachedInputTokens === "number" && typeof creation === "number"
-      ? Math.max(0, entry.usage.cachedInputTokens - creation)
-      : entry.usage.cachedInputTokens;
+  const { read, creation } = cacheTokensFromUsage(entry.usage);
   if (typeof read === "number") {
     totals.cachedInputTokens += read;
     totals.cacheReadInputTokens += read;
@@ -358,68 +488,52 @@ function finalizeCoverage(totals: UsageSummaryTotals): void {
 
 function addEstimatedCost(
   totals: UsageSummaryTotals,
-  entry: Pick<PersistedUsageEntry, "provider" | "model" | "usageStatus" | "usage" | "attempts" | "responseServiceTier" | "requestedServiceTier" | "configuredServiceTier">,
+  entry: Pick<PersistedUsageEntry, "usageStatus" | "usage" | "attempts">,
+  costInfo: EntryCostInfo,
 ): void {
   if (entry.usageStatus === "unreported" || entry.usageStatus === "unsupported"
     || (!entry.usage && !entry.attempts?.length)) {
     totals.unmeteredRequests += 1;
     return;
   }
-  const tier = serviceTierContext(entry);
-  const estimate = entry.attempts?.length
-    ? estimateComboCost(entry.attempts, undefined, tier)
-    : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier });
-  if (!estimate) {
+  if (!costInfo.isPriced) {
     totals.unpricedRequests += 1;
     return;
   }
   totals.pricedRequests += 1;
-  totals.estimatedCostUsd += estimate.cost.total;
+  totals.estimatedCostUsd += costInfo.costTotal;
 }
 
-/**
- * Per-attribution cost for one entry, keyed by `provider/model`.
- *
- * Mirrors the attribution branch in {@link buildModels}: a combo request is
- * priced per attempt and each attempt's cost belongs to its own model, so cost
- * partitions across models rather than being counted once per participant. A
- * single-target request contributes its whole cost to the entry's own model.
- */
-function dayAttributionCosts(entry: PersistedUsageEntry): Map<string, number> {
-  const costs = new Map<string, number>();
-  const tier = serviceTierContext(entry);
-  const estimate = entry.attempts?.length
-    ? estimateComboCost(entry.attempts, undefined, tier)
-    : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier });
-  if (!estimate) return costs;
-  const add = (provider: string, model: string, amount: number): void => {
-    const key = usageModelKey(baseProviderLabel(provider), antigravityUsageModel(provider, model));
-    costs.set(key, (costs.get(key) ?? 0) + amount);
-  };
-  if (entry.attempts?.length && estimate.attempts) {
-    for (const attempt of estimate.attempts) add(attempt.provider, attempt.model, attempt.cost.total);
-  } else {
-    add(entry.provider, entry.model, estimate.cost.total);
-  }
-  return costs;
-}
-
-function buildDayGrid(range: UsageRange, since: number | null, now: number, entries: PersistedUsageEntry[]): UsageDay[] {
+function buildDayGrid(range: UsageRange, since: number | null, now: number, entries: PersistedUsageEntry[], costMap: Map<PersistedUsageEntry, EntryCostInfo>): UsageDay[] {
   const window = rangeWindow(range, now);
   const days = range === "all" ? dayCountForAllRange(entries, now) : window.days;
   const grid = new Map<string, UsageDay>();
   // Per-day model breakdown accumulator, keyed by day then provider/model, so the 7d bar chart can
   // render a per-model stacked bar with a hover tooltip without a second pass over the entries.
-  const dayModels = new Map<string, Map<string, UsageDayModel>>();
+  interface DayModelAccumulator extends UsageDayModel {
+    cacheObserved?: boolean;
+  }
+  const dayModels = new Map<string, Map<string, DayModelAccumulator>>();
   const dayModelRequests = new Map<string, Set<string>>();
-  const bumpDayModel = (dayKey: string, attribution: UsageAttribution, costUsd: number): void => {
+  const bumpDayModel = (dayKey: string, attribution: UsageAttribution): void => {
     let models = dayModels.get(dayKey);
     if (!models) { models = new Map(); dayModels.set(dayKey, models); }
     const providerKey = baseProviderLabel(attribution.provider);
     const mKey = usageModelKey(providerKey, attribution.model);
     let m = models.get(mKey);
     if (!m) {
-      m = { model: attribution.model, provider: providerKey, requests: 0, attemptCount: 0, totalTokens: 0, estimatedCostUsd: 0 };
+      m = {
+        model: attribution.model,
+        provider: providerKey,
+        requests: 0,
+        attemptCount: 0,
+        totalTokens: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        cacheHitRate: null,
+      };
       models.set(mKey, m);
     }
     const requestKey = `${dayKey}\0${mKey}`;
@@ -428,8 +542,15 @@ function buildDayGrid(range: UsageRange, since: number | null, now: number, entr
     requests.add(attribution.requestId);
     m.requests = requests.size;
     m.attemptCount += 1;
+    if (attribution.usage) {
+      m.inputTokens = (m.inputTokens ?? 0) + attribution.usage.inputTokens;
+      m.outputTokens = (m.outputTokens ?? 0) + attribution.usage.outputTokens;
+      const { read, creation, hasCacheTelemetry } = cacheTokensFromUsage(attribution.usage);
+      if (hasCacheTelemetry) m.cacheObserved = true;
+      if (typeof read === "number") m.cacheReadInputTokens = (m.cacheReadInputTokens ?? 0) + read;
+      if (typeof creation === "number") m.cacheCreationInputTokens = (m.cacheCreationInputTokens ?? 0) + creation;
+    }
     m.totalTokens += usageDisplayTotalTokens(attribution.usage, attribution.totalTokens) ?? 0;
-    m.estimatedCostUsd += costUsd;
   };
   const startOfToday = startOfLocalDay(now);
   for (let i = days - 1; i >= 0; i--) {
@@ -449,23 +570,29 @@ function buildDayGrid(range: UsageRange, since: number | null, now: number, entr
     if (isMeasuredStatus(entry.usageStatus)) day.measuredRequests += 1;
     if (entry.usageStatus === "reported") day.reportedRequests += 1;
     day.totalTokens += usageDisplayTotalTokens(entry.usage, entry.totalTokens) ?? 0;
-    // Price through the same seam buildModels uses: combo attempts are priced
-    // per attempt and attributed to their own model, everything else to the
-    // entry's model. Re-deriving a price here would make days[] disagree with
-    // models[] for exactly the combo traffic where nobody would notice.
-    const attributionCosts = dayAttributionCosts(entry);
-    for (const attribution of usageAttributions(entry)) {
-      const attributionKey = usageModelKey(baseProviderLabel(attribution.provider), attribution.model);
-      // Spend each key's cost ONCE. `attributionCosts` already holds the SUM of every
-      // attempt that shares a provider/model key, while `usageAttributions` yields one
-      // entry per attempt — so a retry onto the same model would otherwise add that
-      // pair's total twice and double the day against `summary.estimatedCostUsd`.
-      // Deleting on read keeps the first attribution carrying the group's cost and gives
-      // its siblings zero, which is what `buildModels` already does per attempt.
-      const costUsd = attributionCosts.get(attributionKey) ?? 0;
-      attributionCosts.delete(attributionKey);
-      bumpDayModel(key, attribution, costUsd);
-      day.estimatedCostUsd += costUsd;
+    for (const attribution of usageAttributions(entry)) bumpDayModel(key, attribution);
+    const costInfo = costMap.get(entry);
+    if (costInfo?.isPriced) {
+      if (entry.attempts?.length && costInfo.attemptEstimates) {
+        for (let i = 0; i < entry.attempts.length; i++) {
+          const attempt = entry.attempts[i];
+          const attemptEst = costInfo.attemptEstimates[i];
+          if (attemptEst) {
+            const aProviderKey = baseProviderLabel(attempt.provider);
+            const aIdentity = usageModelIdentity(attempt.provider, attempt.model);
+            const aKey = usageModelKey(aProviderKey, aIdentity.model);
+            const m = dayModels.get(key)?.get(aKey);
+            if (m) m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + attemptEst.cost.total;
+          }
+        }
+      } else if (costInfo.estimate) {
+        const providerKey = baseProviderLabel(entry.provider);
+        const identity = usageModelIdentity(entry.provider, entry.model, entry.resolvedModel);
+        const mKey = usageModelKey(providerKey, identity.model);
+        const m = dayModels.get(key)?.get(mKey);
+        if (m) m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + costInfo.estimate.cost.total;
+      }
+      day.estimatedCostUsd += costInfo.costTotal;
     }
   }
   void since;
@@ -473,28 +600,61 @@ function buildDayGrid(range: UsageRange, since: number | null, now: number, entr
   for (const day of out) {
     const models = dayModels.get(day.date);
     if (models) {
+      for (const m of models.values()) {
+        m.cacheHitRate = calculateCacheHitRate(!!m.cacheObserved, m.inputTokens ?? 0, m.cacheReadInputTokens ?? 0);
+      }
       const sorted = [...models.values()].sort((a, b) => b.requests - a.requests);
-      day.models = retainedBreakdownRows(sorted, overflow => {
+      const retained = retainedBreakdownRows(sorted, overflow => {
         const requests = new Set<string>();
         let attemptCount = 0;
         let totalTokens = 0;
-        let estimatedCostUsd = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cacheReadInputTokens = 0;
+        let cacheCreationInputTokens = 0;
+        let cacheObserved = false;
+        let estimatedCostUsd: number | undefined;
         for (const model of overflow) {
           attemptCount += model.attemptCount;
           totalTokens += model.totalTokens;
-          estimatedCostUsd += model.estimatedCostUsd;
+          inputTokens += model.inputTokens ?? 0;
+          outputTokens += model.outputTokens ?? 0;
+          cacheReadInputTokens += model.cacheReadInputTokens ?? 0;
+          cacheCreationInputTokens += model.cacheCreationInputTokens ?? 0;
+          if (model.cacheObserved) cacheObserved = true;
+          if (model.estimatedCostUsd !== undefined) {
+            estimatedCostUsd = (estimatedCostUsd ?? 0) + model.estimatedCostUsd;
+          }
           const requestKey = `${day.date}\0${usageModelKey(model.provider, model.model)}`;
           for (const requestId of dayModelRequests.get(requestKey) ?? []) requests.add(requestId);
         }
-        return { model: "other", provider: "other", requests: requests.size, attemptCount, totalTokens, estimatedCostUsd };
+        const cacheHitRate = calculateCacheHitRate(cacheObserved, inputTokens, cacheReadInputTokens);
+        return {
+          model: "other",
+          provider: "other",
+          requests: requests.size,
+          attemptCount,
+          totalTokens,
+          inputTokens,
+          outputTokens,
+          cacheReadInputTokens,
+          cacheCreationInputTokens,
+          cacheHitRate,
+          ...(estimatedCostUsd !== undefined ? { estimatedCostUsd } : {}),
+        };
       });
+      for (const model of retained) delete model.cacheObserved;
+      day.models = retained;
     }
   }
   return out;
 }
 
-function buildModels(entries: PersistedUsageEntry[], totalTokens: number): UsageModel[] {
-  const byKey = new Map<string, UsageModel>();
+function buildModels(entries: PersistedUsageEntry[], totalTokens: number, costMap: Map<PersistedUsageEntry, EntryCostInfo>): UsageModel[] {
+  interface ModelAccumulator extends UsageModel {
+    cacheObserved?: boolean;
+  }
+  const byKey = new Map<string, ModelAccumulator>();
   const statusesByKey = new Map<string, Map<string, UsageStatus[]>>();
   for (const entry of entries) {
     for (const attribution of usageAttributions(entry)) {
@@ -515,6 +675,12 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
           totalTokens: 0,
           inputTokens: 0,
           outputTokens: 0,
+          cachedInputTokens: 0,
+          cacheReadInputTokens: 0,
+          cacheCreationInputTokens: 0,
+          pricedRequests: 0,
+          unpricedRequests: 0,
+          priceCoverageRatio: 0,
           shareRatio: 0,
         };
         byKey.set(key, model);
@@ -528,6 +694,15 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
       if (attribution.usage) {
         model.inputTokens += attribution.usage.inputTokens;
         model.outputTokens += attribution.usage.outputTokens;
+        const { read, creation, hasCacheTelemetry } = cacheTokensFromUsage(attribution.usage);
+        if (hasCacheTelemetry) model.cacheObserved = true;
+        if (typeof read === "number") {
+          model.cachedInputTokens = (model.cachedInputTokens ?? 0) + read;
+          model.cacheReadInputTokens = (model.cacheReadInputTokens ?? 0) + read;
+        }
+        if (typeof creation === "number") {
+          model.cacheCreationInputTokens = (model.cacheCreationInputTokens ?? 0) + creation;
+        }
         model.totalTokens += usageDisplayTotalTokens(attribution.usage, attribution.totalTokens) ?? 0;
       }
     }
@@ -542,36 +717,68 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
       else if (status === "estimated") model.estimatedRequests += 1;
     }
   }
-  // Accumulate per-model estimated cost
+  // Accumulate per-model estimated cost & price coverage by request ID
+  const pricedRequestsByModel = new Map<string, Set<string>>();
+  const unpricedRequestsByModel = new Map<string, Set<string>>();
   for (const entry of entries) {
-    const tier = serviceTierContext(entry);
-    const estimate = entry.attempts?.length
-      ? estimateComboCost(entry.attempts, undefined, tier)
-      : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier });
-    if (!estimate) continue;
-
-    if (entry.attempts?.length && estimate.attempts) {
-      // Combo: attribute each attempt's cost to its own model
-      for (const attemptEst of estimate.attempts) {
-        const aProviderKey = baseProviderLabel(attemptEst.provider);
-        const aKey = usageModelKey(aProviderKey, antigravityUsageModel(attemptEst.provider, attemptEst.model));
-        const m = byKey.get(aKey);
-        if (m) m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + attemptEst.cost.total;
+    const costInfo = costMap.get(entry);
+    if (entry.attempts?.length) {
+      const attemptEstimates = costInfo?.attemptEstimates;
+      for (let i = 0; i < entry.attempts.length; i++) {
+        const attempt = entry.attempts[i];
+        const attemptEst = attemptEstimates?.[i];
+        const aProviderKey = baseProviderLabel(attempt.provider);
+        const aIdentity = usageModelIdentity(attempt.provider, attempt.model);
+        const aKey = usageModelKey(aProviderKey, aIdentity.model);
+        if (attemptEst) {
+          const m = byKey.get(aKey);
+          if (m) {
+            m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + attemptEst.cost.total;
+          }
+          let s = pricedRequestsByModel.get(aKey);
+          if (!s) { s = new Set(); pricedRequestsByModel.set(aKey, s); }
+          s.add(entry.requestId);
+        } else {
+          let s = unpricedRequestsByModel.get(aKey);
+          if (!s) { s = new Set(); unpricedRequestsByModel.set(aKey, s); }
+          s.add(entry.requestId);
+        }
       }
     } else {
-      // Single-target: attribute to the entry's model
       const providerKey = baseProviderLabel(entry.provider);
-      const key = usageModelKey(providerKey, antigravityUsageModel(entry.provider, entry.model));
-      const m = byKey.get(key);
-      if (m) m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + estimate.cost.total;
+      const identity = usageModelIdentity(entry.provider, entry.model, entry.resolvedModel);
+      const key = usageModelKey(providerKey, identity.model);
+      const estimate = costInfo?.estimate;
+      if (estimate) {
+        const m = byKey.get(key);
+        if (m) {
+          m.estimatedCostUsd = (m.estimatedCostUsd ?? 0) + estimate.cost.total;
+        }
+        let s = pricedRequestsByModel.get(key);
+        if (!s) { s = new Set(); pricedRequestsByModel.set(key, s); }
+        s.add(entry.requestId);
+      } else {
+        let s = unpricedRequestsByModel.get(key);
+        if (!s) { s = new Set(); unpricedRequestsByModel.set(key, s); }
+        s.add(entry.requestId);
+      }
     }
   }
   const models = [...byKey.values()];
-  for (const m of models) m.shareRatio = totalTokens === 0 ? 0 : m.totalTokens / totalTokens;
+  for (const [key, m] of byKey) {
+    m.pricedRequests = pricedRequestsByModel.get(key)?.size ?? 0;
+    m.unpricedRequests = unpricedRequestsByModel.get(key)?.size ?? 0;
+    m.shareRatio = totalTokens === 0 ? 0 : m.totalTokens / totalTokens;
+    m.cacheHitRate = calculateCacheHitRate(!!m.cacheObserved, m.inputTokens, m.cacheReadInputTokens ?? 0);
+    m.priceCoverageRatio = m.requests > 0 ? m.pricedRequests / m.requests : 0;
+  }
   const sorted = models.sort((a, b) => b.requests - a.requests);
-  return retainedBreakdownRows(sorted, overflow => {
+  const retained = retainedBreakdownRows(sorted, overflow => {
     const statusesByRequest = new Map<string, UsageStatus[]>();
-    const other: UsageModel = {
+    const overflowPricedRequests = new Set<string>();
+    const overflowUnpricedRequests = new Set<string>();
+    let cacheObserved = false;
+    const other: ModelAccumulator = {
       provider: "other",
       model: "other",
       requests: 0,
@@ -582,6 +789,12 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
       totalTokens: 0,
       inputTokens: 0,
       outputTokens: 0,
+      cachedInputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      pricedRequests: 0,
+      unpricedRequests: 0,
+      priceCoverageRatio: 0,
       shareRatio: 0,
     };
     for (const model of overflow) {
@@ -589,6 +802,10 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
       other.totalTokens += model.totalTokens;
       other.inputTokens += model.inputTokens;
       other.outputTokens += model.outputTokens;
+      if (model.cacheObserved) cacheObserved = true;
+      other.cachedInputTokens = (other.cachedInputTokens ?? 0) + (model.cachedInputTokens ?? 0);
+      other.cacheReadInputTokens = (other.cacheReadInputTokens ?? 0) + (model.cacheReadInputTokens ?? 0);
+      other.cacheCreationInputTokens = (other.cacheCreationInputTokens ?? 0) + (model.cacheCreationInputTokens ?? 0);
       if (model.estimatedCostUsd !== undefined) {
         other.estimatedCostUsd = (other.estimatedCostUsd ?? 0) + model.estimatedCostUsd;
       }
@@ -598,8 +815,12 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
         combined.push(...statuses);
         statusesByRequest.set(requestId, combined);
       }
+      for (const reqId of pricedRequestsByModel.get(key) ?? []) overflowPricedRequests.add(reqId);
+      for (const reqId of unpricedRequestsByModel.get(key) ?? []) overflowUnpricedRequests.add(reqId);
     }
     other.requests = statusesByRequest.size;
+    other.pricedRequests = overflowPricedRequests.size;
+    other.unpricedRequests = overflowUnpricedRequests.size;
     for (const statuses of statusesByRequest.values()) {
       const status = foldAttributionStatuses(statuses);
       if (isMeasuredStatus(status)) other.measuredRequests += 1;
@@ -607,12 +828,19 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
       else if (status === "estimated") other.estimatedRequests += 1;
     }
     other.shareRatio = totalTokens === 0 ? 0 : other.totalTokens / totalTokens;
+    other.cacheHitRate = calculateCacheHitRate(cacheObserved, other.inputTokens, other.cacheReadInputTokens ?? 0);
+    other.priceCoverageRatio = other.requests > 0 ? other.pricedRequests / other.requests : 0;
     return other;
   });
+  for (const model of retained) delete model.cacheObserved;
+  return retained;
 }
 
-function buildProviders(entries: PersistedUsageEntry[], totalTokens: number): UsageProvider[] {
-  const byKey = new Map<string, UsageProvider>();
+function buildProviders(entries: PersistedUsageEntry[], totalTokens: number, costMap: Map<PersistedUsageEntry, EntryCostInfo>): UsageProvider[] {
+  interface ProviderAccumulator extends UsageProvider {
+    cacheObserved?: boolean;
+  }
+  const byKey = new Map<string, ProviderAccumulator>();
   const statusesByKey = new Map<string, Map<string, UsageStatus[]>>();
   for (const entry of entries) {
     for (const attribution of usageAttributions(entry)) {
@@ -627,6 +855,14 @@ function buildProviders(entries: PersistedUsageEntry[], totalTokens: number): Us
           reportedRequests: 0,
           estimatedRequests: 0,
           totalTokens: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cachedInputTokens: 0,
+          cacheReadInputTokens: 0,
+          cacheCreationInputTokens: 0,
+          pricedRequests: 0,
+          unpricedRequests: 0,
+          priceCoverageRatio: 0,
           shareRatio: 0,
         };
         byKey.set(providerKey, provider);
@@ -638,6 +874,17 @@ function buildProviders(entries: PersistedUsageEntry[], totalTokens: number): Us
       statuses.push(attribution.usageStatus);
       requests.set(attribution.requestId, statuses);
       if (attribution.usage) {
+        provider.inputTokens = (provider.inputTokens ?? 0) + attribution.usage.inputTokens;
+        provider.outputTokens = (provider.outputTokens ?? 0) + attribution.usage.outputTokens;
+        const { read, creation, hasCacheTelemetry } = cacheTokensFromUsage(attribution.usage);
+        if (hasCacheTelemetry) provider.cacheObserved = true;
+        if (typeof read === "number") {
+          provider.cachedInputTokens = (provider.cachedInputTokens ?? 0) + read;
+          provider.cacheReadInputTokens = (provider.cacheReadInputTokens ?? 0) + read;
+        }
+        if (typeof creation === "number") {
+          provider.cacheCreationInputTokens = (provider.cacheCreationInputTokens ?? 0) + creation;
+        }
         provider.totalTokens += usageDisplayTotalTokens(attribution.usage, attribution.totalTokens) ?? 0;
       }
     }
@@ -652,28 +899,59 @@ function buildProviders(entries: PersistedUsageEntry[], totalTokens: number): Us
       else if (status === "estimated") provider.estimatedRequests += 1;
     }
   }
+  const pricedRequestsByProvider = new Map<string, Set<string>>();
+  const unpricedRequestsByProvider = new Map<string, Set<string>>();
   for (const entry of entries) {
-    const tier = serviceTierContext(entry);
-    const estimate = entry.attempts?.length
-      ? estimateComboCost(entry.attempts, undefined, tier)
-      : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier });
-    if (!estimate) continue;
-
-    if (entry.attempts?.length && estimate.attempts) {
-      for (const attemptEst of estimate.attempts) {
-        const aProviderKey = baseProviderLabel(attemptEst.provider);
-        const p = byKey.get(aProviderKey);
-        if (p) p.estimatedCostUsd = (p.estimatedCostUsd ?? 0) + attemptEst.cost.total;
+    const costInfo = costMap.get(entry);
+    if (entry.attempts?.length) {
+      const attemptEstimates = costInfo?.attemptEstimates;
+      for (let i = 0; i < entry.attempts.length; i++) {
+        const attempt = entry.attempts[i];
+        const attemptEst = attemptEstimates?.[i];
+        const aProviderKey = baseProviderLabel(attempt.provider);
+        if (attemptEst) {
+          const p = byKey.get(aProviderKey);
+          if (p) {
+            p.estimatedCostUsd = (p.estimatedCostUsd ?? 0) + attemptEst.cost.total;
+          }
+          let s = pricedRequestsByProvider.get(aProviderKey);
+          if (!s) { s = new Set(); pricedRequestsByProvider.set(aProviderKey, s); }
+          s.add(entry.requestId);
+        } else {
+          let s = unpricedRequestsByProvider.get(aProviderKey);
+          if (!s) { s = new Set(); unpricedRequestsByProvider.set(aProviderKey, s); }
+          s.add(entry.requestId);
+        }
       }
     } else {
       const providerKey = baseProviderLabel(entry.provider);
-      const p = byKey.get(providerKey);
-      if (p) p.estimatedCostUsd = (p.estimatedCostUsd ?? 0) + estimate.cost.total;
+      const estimate = costInfo?.estimate;
+      if (estimate) {
+        const p = byKey.get(providerKey);
+        if (p) {
+          p.estimatedCostUsd = (p.estimatedCostUsd ?? 0) + estimate.cost.total;
+        }
+        let s = pricedRequestsByProvider.get(providerKey);
+        if (!s) { s = new Set(); pricedRequestsByProvider.set(providerKey, s); }
+        s.add(entry.requestId);
+      } else {
+        let s = unpricedRequestsByProvider.get(providerKey);
+        if (!s) { s = new Set(); unpricedRequestsByProvider.set(providerKey, s); }
+        s.add(entry.requestId);
+      }
     }
   }
   const providers = [...byKey.values()];
-  for (const p of providers) p.shareRatio = totalTokens === 0 ? 0 : p.totalTokens / totalTokens;
-  return providers.sort((a, b) => b.requests - a.requests);
+  for (const [key, p] of byKey) {
+    p.pricedRequests = pricedRequestsByProvider.get(key)?.size ?? 0;
+    p.unpricedRequests = unpricedRequestsByProvider.get(key)?.size ?? 0;
+    p.shareRatio = totalTokens === 0 ? 0 : p.totalTokens / totalTokens;
+    p.cacheHitRate = calculateCacheHitRate(!!p.cacheObserved, p.inputTokens ?? 0, p.cacheReadInputTokens ?? 0);
+    p.priceCoverageRatio = p.requests > 0 ? p.pricedRequests / p.requests : 0;
+  }
+  const sorted = providers.sort((a, b) => b.requests - a.requests);
+  for (const provider of sorted) delete provider.cacheObserved;
+  return sorted;
 }
 
 const LEGACY_AMBIGUOUS_ACCOUNT_LABEL = "legacy-ambiguous";
@@ -699,7 +977,7 @@ function accountLabelForAttribution(provider: string, explicit: unknown): string
   return legacyCodexAccountLabel(provider);
 }
 
-function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
+function buildAccounts(entries: PersistedUsageEntry[], costMap: Map<PersistedUsageEntry, EntryCostInfo>): UsageAccount[] {
   const byLabel = new Map<string, UsageAccount>();
   const requestIds = new Map<string, Set<string>>();
 
@@ -710,7 +988,7 @@ function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
     usageStatus: UsageStatus;
     usage?: PersistedUsageEntry["usage"];
     totalTokens?: number;
-    estimate: ReturnType<typeof estimateRequestCost>;
+    estimate: AttemptCostEstimate | CostEstimate | null;
   }): void => {
     const label = accountLabelForAttribution(input.provider, input.accountLogLabel);
     if (!label) return;
@@ -753,12 +1031,7 @@ function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
     else if (input.usageStatus === "estimated") row.estimatedAttempts += 1;
     row.inputTokens += input.usage!.inputTokens;
     row.outputTokens += input.usage!.outputTokens;
-    const creation = input.usage!.cacheCreationInputTokens;
-    const read = typeof input.usage!.cacheReadInputTokens === "number"
-      ? input.usage!.cacheReadInputTokens
-      : typeof input.usage!.cachedInputTokens === "number" && typeof creation === "number"
-        ? Math.max(0, input.usage!.cachedInputTokens - creation)
-        : input.usage!.cachedInputTokens;
+    const { read, creation } = cacheTokensFromUsage(input.usage);
     if (typeof read === "number") row.cacheReadInputTokens += read;
     if (typeof creation === "number") row.cacheCreationInputTokens += creation;
     if (typeof input.usage!.reasoningOutputTokens === "number") {
@@ -774,9 +1047,11 @@ function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
   };
 
   for (const entry of entries) {
-    const tier = serviceTierContext(entry);
+    const costInfo = costMap.get(entry);
     if (entry.attempts?.length) {
-      for (const attempt of entry.attempts) {
+      for (let i = 0; i < entry.attempts.length; i++) {
+        const attempt = entry.attempts[i];
+        const attemptEst = costInfo?.attemptEstimates?.[i] ?? null;
         add({
           requestId: entry.requestId,
           provider: attempt.provider,
@@ -784,7 +1059,7 @@ function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
           usageStatus: attempt.usageStatus,
           ...(attempt.usage ? { usage: attempt.usage } : {}),
           ...(attempt.totalTokens !== undefined ? { totalTokens: attempt.totalTokens } : {}),
-          estimate: estimateAttemptCost(attempt, undefined, tier),
+          estimate: attemptEst,
         });
       }
       continue;
@@ -796,13 +1071,7 @@ function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
       usageStatus: entry.usageStatus,
       ...(entry.usage ? { usage: entry.usage } : {}),
       ...(entry.totalTokens !== undefined ? { totalTokens: entry.totalTokens } : {}),
-      estimate: estimateRequestCost({
-        provider: entry.provider,
-        model: entry.model,
-        usage: entry.usage,
-        usageStatus: entry.usageStatus,
-        serviceTier: tier,
-      }),
+      estimate: costInfo?.estimate ?? null,
     });
   }
 
@@ -830,12 +1099,16 @@ export function summarizeUsage(
     if (surface === "codex") return entry.surface === undefined;
     return true;
   });
+  const costMap = new Map<PersistedUsageEntry, EntryCostInfo>();
+  for (const entry of filteredEntries) {
+    costMap.set(entry, computeEntryCost(entry));
+  }
   const totals = blankTotals();
   for (const entry of filteredEntries) {
     bumpStatus(totals, entry.usageStatus);
     totals.attemptCount += entry.attempts?.length ?? 1;
     addTokens(totals, entry);
-    addEstimatedCost(totals, entry);
+    addEstimatedCost(totals, entry, costMap.get(entry)!);
   }
   finalizeCoverage(totals);
   return {
@@ -844,10 +1117,10 @@ export function summarizeUsage(
     since,
     generatedAt: now,
     summary: totals,
-    days: buildDayGrid(range, since, now, filteredEntries),
-    models: buildModels(filteredEntries, totals.totalTokens),
-    providers: buildProviders(filteredEntries, totals.totalTokens),
-    accounts: buildAccounts(filteredEntries),
+    days: buildDayGrid(range, since, now, filteredEntries, costMap),
+    models: buildModels(filteredEntries, totals.totalTokens, costMap),
+    providers: buildProviders(filteredEntries, totals.totalTokens, costMap),
+    accounts: buildAccounts(filteredEntries, costMap),
   };
 }
 
@@ -886,59 +1159,33 @@ export function projectUsageSummary<T extends UsageSummary>(
   const model = normalizeFilterValue(filter.model);
   if (provider === null && model === null) return summary;
 
-  // Re-summarise from the entries the summary was built from, rather than
-  // projecting over its rows.
-  //
-  // Projecting rows looked cheaper and was wrong in three ways that only show
-  // up together: breakdown rows past MAX_USAGE_MODEL_BREAKDOWN_ROWS are
-  // collapsed into a synthetic "other" row, so a provider living only in that
-  // tail is unfindable and reports matched:false despite real usage; a
-  // provider row is a whole-provider aggregate, so a model filter kept the
-  // provider's OTHER models in providers[] while models[] and the totals
-  // excluded them, contradicting itself inside one response; and a model row
-  // carries a single optional cost, so priced/unpriced/unmetered counts could
-  // only be guessed per model rather than counted per request.
-  //
-  // The entries are already in hand on every path that filters, so the honest
-  // computation is also the simple one.
   const matches = (rowProvider: string, rowModel: string): boolean => {
     if (provider !== null && baseProviderLabel(rowProvider).toLowerCase() !== provider) return false;
     if (model !== null && rowModel.toLowerCase() !== model) return false;
     return true;
   };
 
-  // Narrow to matching ATTRIBUTIONS, not matching entries.
-  //
-  // Keeping a whole combo entry because one of its attempts matched drags the
-  // other attempts' tokens and cost into the filtered totals: a two-attempt
-  // combo filtered to its cheap model reported the expensive model's spend
-  // too. Rewriting the entry down to its matching attempts is what makes the
-  // filtered numbers mean what the flag says.
   const source = entries ?? [];
   let comboOverlap = false;
   const filtered: PersistedUsageEntry[] = [];
   for (const entry of source) {
     if (!entry.attempts?.length) {
-      if (matches(entry.provider, antigravityUsageModel(entry.provider, entry.model))) filtered.push(entry);
+      const identity = usageModelIdentity(entry.provider, entry.model, entry.resolvedModel);
+      if (matches(entry.provider, identity.model)) filtered.push(entry);
       continue;
     }
-    const attempts = entry.attempts.filter(a => matches(a.provider, antigravityUsageModel(a.provider, a.model)));
+    const attempts = entry.attempts.filter(a => {
+      const identity = usageModelIdentity(a.provider, a.model);
+      return matches(a.provider, identity.model);
+    });
     if (attempts.length === 0) continue;
-    // A combo is still counted once per participating model, so a filtered
-    // request count can exceed the number of distinct requests. That is the
-    // documented overlap, and it is why comboOverlap exists.
     if (entry.attempts.length > 1) comboOverlap = true;
-    filtered.push({ ...entry, attempts });
+    const { usage: _parentUsage, totalTokens: _parentTotalTokens, ...withoutParentUsage } = entry;
+    filtered.push({ ...withoutParentUsage, attempts, ...projectedComboUsage(attempts) });
   }
 
   const projected = summarizeUsage(filtered, summary.range, summary.generatedAt, summary.surface);
-  // matched reflects usage inside the requested WINDOW, not anywhere in the
-  // log: summarizeUsage applies the range and surface predicates, and the CLI
-  // uses this flag to decide between a table and "no usage recorded".
   const matched = projected.summary.requests > 0;
-  // A combo entry survives the entry filter as a whole, so its non-matching
-  // attributions can still appear as rows. Drop those so every row in the
-  // response satisfies the filter the caller asked for.
   const models = projected.models.filter(row => matches(row.provider, row.model));
   const retainedProviders = new Set(models.map(row => row.provider));
   return {
@@ -947,9 +1194,6 @@ export function projectUsageSummary<T extends UsageSummary>(
     days: projected.days.map(day => ({ ...day, models: day.models.filter(row => matches(row.provider, row.model)) })),
     models,
     providers: projected.providers.filter(row => retainedProviders.has(row.provider)),
-    // Account rows are not provider-partitioned in a way this projection could
-    // honestly re-derive, and unfiltered account totals sitting beside filtered
-    // model totals would invite exactly the wrong reading.
     accounts: [],
     filter: { provider, model, matched, comboOverlap },
   };