@@ -24,13 +24,12 @@
 Two independent splines need not preserve `metric * throughput = constant` between
 measured knots. Pass `reciprocal_of='throughput'` (or the matching output/input
 throughput key) to spline that throughput and re-derive the metric. The live
-inference charts also expose tokens/$ and normalized token revenue as separate
-metrics; both are directly proportional to throughput. OpenRouter-priced revenue
-is proportional only when the input/output mix stays constant; otherwise spline
-the already-priced metric directly. Pass
-`proportional_to='throughput'` (or the matching output/input throughput key) so
-they use the same Pareto knots and spline as that throughput before applying the
-recovered multiplier. See docs/tco-calculator.md for a reproducible measurement.
+inference charts also expose tokens/$ and token revenue as separate metrics.
+Tokens/$ is directly proportional to throughput. For cache-aware token revenue,
+pass `revenue_pricing` with input/cached-input/output prices; the helper then
+splines throughput, measured cache hit, and input share independently before
+pricing the interpolated point, matching Fleet Lifecycle and Historical Trends.
+See docs/tco-calculator.md for a reproducible measurement.
 
 Usage as a module:
     from iso_interactivity import interpolate_metric, pareto_front_upper_left
@@ -208,6 +207,69 @@ def recover_proportional_multiplier(
     return multiplier
 
 
+def measured_cache_hit_rate(point: dict) -> Optional[float]:
+    """GPU plus external when external exists, otherwise GPU plus CPU."""
+    gpu = point.get('server_gpu_cache_hit_rate')
+    external = point.get('server_external_cache_hit_rate')
+    cpu = point.get('server_cpu_cache_hit_rate')
+    secondary = external if isinstance(external, (int, float)) else cpu
+    if not isinstance(gpu, (int, float)) and not isinstance(secondary, (int, float)):
+        return None
+    total = (float(gpu) if isinstance(gpu, (int, float)) else 0.0) + (
+        float(secondary) if isinstance(secondary, (int, float)) else 0.0
+    )
+    return max(0.0, min(1.0, total))
+
+
+def input_token_share_for_revenue(point: dict, tput_key: str) -> Optional[float]:
+    """Port of inputTokenShareForRevenue in token-revenue.ts."""
+    total = point.get('tput_per_gpu', point.get(tput_key, 0))
+    input_tput = point.get('input_tput_per_gpu', 0)
+    output_tput = point.get('output_tput_per_gpu', 0)
+    if all(isinstance(value, (int, float)) for value in (total, input_tput, output_tput)):
+        stream_sum = float(input_tput) + float(output_tput)
+        if float(total) > 0 and stream_sum > 0 and abs(stream_sum / float(total) - 1) <= 0.01:
+            return float(input_tput) / stream_sum
+
+    isl = point.get('isl')
+    osl = point.get('osl')
+    if isinstance(isl, (int, float)) and isinstance(osl, (int, float)) and isl + osl > 0:
+        return float(isl) / float(isl + osl)
+
+    prompt = point.get('total_prompt_tokens')
+    generation = point.get('total_generation_tokens')
+    if (
+        isinstance(prompt, (int, float))
+        and isinstance(generation, (int, float))
+        and prompt + generation > 0
+    ):
+        return float(prompt) / float(prompt + generation)
+    return None
+
+
+def token_revenue_from_rates_per_gpu_hour(
+    total_tput: float,
+    input_share: Optional[float],
+    cache_hit_rate: Optional[float],
+    pricing: dict,
+) -> Optional[float]:
+    """Port of tokenRevenueFromRatesPerGpuHour in token-revenue.ts."""
+    if not total_tput > 0:
+        return 0.0
+    input_price = float(pricing['input_per_million'])
+    output_price = float(pricing['output_per_million'])
+    cached_price = float(pricing.get('cached_input_per_million', input_price * 0.1))
+    hit = max(0.0, min(1.0, cache_hit_rate)) if cache_hit_rate is not None else 0.0
+    if input_price == output_price and not (hit > 0 and cached_price != input_price):
+        return total_tput * 3600 * input_price / 1_000_000
+    if input_share is None:
+        return None
+    share = max(0.0, min(1.0, input_share))
+    input_price_at_point = (1 - hit) * input_price + hit * cached_price
+    blended_price = share * input_price_at_point + (1 - share) * output_price
+    return total_tput * 3600 * blended_price / 1_000_000
+
+
 def interpolate_metric(
     points: list[dict],
     target_iv: float,
@@ -216,6 +278,7 @@ def interpolate_metric(
     tput_key: str = 'throughput',
     reciprocal_of: Optional[str] = None,
     proportional_to: Optional[str] = None,
+    revenue_pricing: Optional[dict] = None,
 ) -> Optional[float]:
     """Interpolate `metric_key` at `target_iv` using the chart's algorithm.
 
@@ -240,6 +303,10 @@ def interpolate_metric(
     with a constant input/output mix). That
     throughput is splined and the recovered multiplier applied, matching the
     dashboard.
+
+    `revenue_pricing` switches token revenue to the Fleet-compatible path:
+    interpolate throughput, input share, and cache hit independently, then price
+    that operating point. A partly measured cache frontier receives no discount.
     """
     if not points:
         return None
@@ -275,6 +342,32 @@ def interpolate_metric(
             return None
         ys.append(value)
 
+    if revenue_pricing is not None:
+        def interpolate_bounded(values: list[float]) -> float:
+            slopes = monotone_slopes(xs, values)
+            raw = hermite_interpolate(xs, values, slopes, target_iv)
+            return max(min(values), min(max(values), raw))
+
+        revenue_tput_key = proportional_to or tput_key
+        tputs = [point.get(revenue_tput_key) for point in sorted_front]
+        if any(value is None for value in tputs):
+            return None
+        input_shares = [
+            input_token_share_for_revenue(point, revenue_tput_key) for point in sorted_front
+        ]
+        cache_hit_rates = [measured_cache_hit_rate(point) for point in sorted_front]
+        input_share = (
+            interpolate_bounded(input_shares) if all(v is not None for v in input_shares) else None
+        )
+        cache_hit_rate = (
+            interpolate_bounded(cache_hit_rates)
+            if all(v is not None for v in cache_hit_rates)
+            else None
+        )
+        return token_revenue_from_rates_per_gpu_hour(
+            interpolate_bounded(tputs), input_share, cache_hit_rate, revenue_pricing
+        )
+
     if proportional_to is not None:
         tputs: list[float] = []
         for point in sorted_front:
@@ -324,7 +417,8 @@ def interpolate_metric(
 def _cli() -> None:
     """Stdin: {"points": [...], "target_iv": N, "metric_key": "...",
                "reciprocal_of": "throughput" for $/M tok and J/token,
-               "proportional_to": "throughput" for tokens/$ or revenue with a constant mix}
+               "proportional_to": "throughput" for tokens/$,
+               "revenue_pricing": {...} for cache-aware revenue}
     Stdout: {"value": N or null}"""
     req = json.loads(sys.stdin.read())
     value = interpolate_metric(
@@ -335,6 +429,7 @@ def _cli() -> None:
         tput_key=req.get('tput_key', 'throughput'),
         reciprocal_of=req.get('reciprocal_of'),
         proportional_to=req.get('proportional_to'),
+        revenue_pricing=req.get('revenue_pricing'),
     )
     json.dump({'value': value}, sys.stdout)
     sys.stdout.write('\n')
 
@@ -60,7 +60,7 @@ Returns `{ chartData: InferenceData[][], hardwareConfig: HardwareConfig }`.
 **`buildDerivedChartFields(entry, hwKey, requestedMetrics?)`** is the sole owner of inference and historical trend formulas. The full transform requests every benchmark-backed field. History requests only the selected metric and its interpolation dependencies, so it stays lightweight. Each emitted value uses `{ y: number; roof: boolean }`.
 
 - `tpPerGpu`, `outputTputPerGpu`, `inputTputPerGpu` — raw throughput from the entry (tok/s/gpu).
-- `tokenRevenuePerGpuHour` — gross revenue in $/GPU/hr. `buildDerivedChartFields` emits the normalized default (`tputPerGpu × 3,600 ÷ 1,000,000`, with input and output both priced at $1/M). `applyTokenRevenuePricing` can replace it with the selected model's current public OpenRouter prompt/completion prices. Aggregate rows use their measured input/output split; disaggregated rows derive a like-for-like split from fixed ISL:OSL or measured agentic prompt:generation totals because their raw input/output rates use different prefill/decode GPU denominators.
+- `tokenRevenuePerGpuHour` — gross revenue in $/GPU/hr. `buildDerivedChartFields` emits an uncached normalized placeholder; `applyTokenRevenuePricing` applies the selected normalized or OpenRouter prices to uncached input, cached input, and output. Normalized pricing uses $1/M for uncached input and output and $0.10/M for cached input. OpenRouter uses its published cache-read price when available, otherwise 10% of the prompt price. Agentic cache share uses the same measured GPU-plus-external-or-CPU rule as Fleet Lifecycle. Aggregate rows use their measured input/output split; disaggregated rows derive a like-for-like split from fixed ISL:OSL or measured agentic prompt:generation totals because their raw input/output rates use different prefill/decode GPU denominators. Historical Trends splines total throughput, token share, and cache hit independently before applying these prices; a partly measured cache frontier receives no cache discount.
 - `tpPerMw` — `(tputPerGpu * 1000) / hardwarePower` (GPU power in kW, result in tok/s/MW).
 - Cost-per-million fields — GPU hourly cost divided by tokens-per-hour (in millions): `costh` / `costn` / `costr` for hyperscaler / neocloud / 3-year-rental pricing respectively. Three token variants exist: combined (`costh`/`costn`/`costr`), output-only (`costhOutput`/`costnOutput`/`costrOutput`), and input-only (`costhi`/`costni`/`costri`).
 - Tokens-per-dollar fields — tokens-per-hour divided by the same hourly costs. They are separate Y-axis metrics rather than a display toggle: combined (`tokensPerDollarH`/`N`/`R`), output-only (`outputTokensPerDollarH`/`N`/`R`), and input-only (`inputTokensPerDollarH`/`N`/`R`). This keeps existing `i_metric=y_cost*` links and cost semantics unchanged.
 
@@ -113,7 +113,7 @@ them.
 Axis and presentation state:
 
 - selected x-axis and y-axis metrics, percentile, and effective x-axis mode
-- token-revenue price source (`i_revenue`): normalized $1/M or the selected model's live OpenRouter catalog prices
+- token-revenue price source (`i_revenue`): normalized uncached/cached/output pricing or the selected model's live OpenRouter catalog prices
 - scale, optimal-point, label, contrast, legend, and overlay controls
 
 Display changes stay in this domain. A contrast or label toggle therefore does not
 
@@ -167,27 +167,39 @@ at every interpolated point.
 compare interpolation models on a fixed snapshot, but they must not be presented
 as permanent impact figures for the changing live dataset.
 
-The `/inference` page also exposes tokens-per-dollar and normalized token revenue
-as separate Y-axis metrics; neither replaces the cost-per-million metrics.
-Historical trends for these proportional metrics select Pareto knots from the
-matching throughput, spline that throughput, and apply the constant multiplier.
-Tokens-per-dollar uses `3600 / $/GPU-hr`; normalized token revenue uses
-`3600 / 1,000,000` at the axis's explicit `$1/M tok` sale price. Reusing the
-matching throughput frontier is essential: total-throughput knots are not
-necessarily the output- or input-throughput Pareto knots.
-
-The revenue axis defaults to pricing every input and output token at the same
-`$1/M tok` rate, making it a model-independent SLA comparison. Its OpenRouter
-option fetches the selected model's current public prompt/completion prices from
-`https://openrouter.ai/api/v1/models` and prices the streams separately. Aggregate
-rows use their measured input/output split. Disaggregated rows cannot use the raw
-per-prefill/per-decode rates together, so they apply the fixed ISL:OSL shape or
-the measured agentic prompt:generation mix to total tok/s/GPU. The OpenRouter
-option uses standard prompt/completion prices and does not apply cache discounts.
+The `/inference` page also exposes tokens-per-dollar and token revenue as
+separate Y-axis metrics; neither replaces the cost-per-million metrics.
+Historical tokens-per-dollar trends select Pareto knots from the matching
+throughput, spline that throughput, and apply the constant `3600 / $/GPU-hr`
+multiplier. Revenue selects the total-throughput Pareto knots, interpolates their
+throughput, token mix, and cache hit independently, and then applies the selected
+prices. Reusing the matching frontier remains essential: total-throughput knots
+are not necessarily the output- or input-throughput Pareto knots.
+
+The revenue axis defaults to normalized cache-aware pricing: uncached input and
+output are `$1/M tok`, while cached input is `$0.10/M tok`, matching Fleet
+Lifecycle's default cache-read assumption. Its OpenRouter option fetches the
+selected model's current public prompt/completion/cache-read prices from
+`https://openrouter.ai/api/v1/models`; when the catalog omits a cache-read price,
+the same 10%-of-input fallback is used and the resulting price is printed in the
+plot subtitle. Aggregate rows use their measured input/output split.
+Disaggregated rows cannot use the raw per-prefill/per-decode rates together, so
+they apply the fixed ISL:OSL shape or the measured agentic prompt:generation mix
+to total tok/s/GPU.
+
+Agentic points use the same measured cache-tier rule as Fleet Lifecycle: GPU plus
+external when the external metric is present, otherwise GPU plus CPU, clamped to
+`[0,1]`. Missing cache telemetry bills the input stream at the uncached price.
+Historical Trends uses the same component-wise calculation as Fleet Lifecycle:
+it splines total throughput, input-token share, and measured cache hit separately
+on the total-throughput frontier, clamps each to its measured range, and only then
+applies the selected prices. A frontier with cache telemetry on only some knots
+opts out of the cache discount instead of inventing zero-hit measurements.
 
 Neither mode is the fleet lifecycle section's realized-revenue model: it does not
-model availability, rollout, or a user-supplied cached-input discount. Those
-business assumptions remain in Fleet Lifecycle below.
+model availability or rollout, and its cached price comes from the selected price
+source rather than Fleet Lifecycle's user-editable assumption. Those business
+assumptions remain in Fleet Lifecycle below.
 
 ### The consistency guard
 
@@ -854,8 +866,8 @@ Three properties are worth stating, because they are what make this safe:
 - **A partly-measured frontier opts out.** `interpolateForGPU` splines the rate
   only when _every_ frontier point carries one; substituting 0 for the missing
   points would invent a dip in the cached fraction and overstate the billable
-  rate. Opting out bills every input token at full price instead — wrong in the
-  direction that understates margin.
+  rate. Opting out bills every input token at full price instead, which
+  overstates revenue and margin when the missing point actually had cache hits.
 
 `cacheReadRatio` is the one user input here, labelled `Cached input (% of price)`
 and defaulting to 10% (the ratio DeepSeek and Anthropic both publish). The cached
@@ -879,7 +891,7 @@ The middle two rows carry the decision. Where an external rate is reported,
 adding CPU on top breaches the ceiling 56 times out of 106 — the router-side
 external figure already contains the offload tier, so summing double-counts it.
 Where no external rate is reported the CPU tier is real and disjoint: 0 breaches
-across all 26, every one of them an offload-on row. Hence `cacheHitRateOf` adds
+across all 26, every one of them an offload-on row. Hence `measuredCacheHitRate` adds
 external when present and CPU only in its absence.
 
 Dropping the CPU tier outright, which this did until 2026-08-19, understated the
 
@@ -84,6 +84,7 @@ describe('Inference Chart', () => {
             id: 'deepseek/deepseek-v4-pro-0813',
             pricing: {
               prompt: '0.000001122',
+              input_cache_read: '0.00000008',
               completion: '0.000003366',
             },
           },
@@ -112,12 +113,16 @@ describe('Inference Chart', () => {
       'OpenRouter current pricing',
     );
     cy.get('[data-testid="openrouter-price-summary"]')
-      .should('contain.text', 'Input $1.122/M tok')
+      .should('contain.text', 'Uncached input $1.122/M tok')
+      .and('contain.text', 'Cached input $0.08/M tok')
       .and('contain.text', 'Output $3.366/M tok');
     cy.get('[data-testid="chart-figure"]')
       .first()
       .find('[data-testid="token-revenue-subtitle-prices"]')
-      .should('have.text', 'Input $1.122/M tok · Output $3.366/M tok')
+      .should(
+        'have.text',
+        'Uncached input $1.122/M tok · Cached input $0.08/M tok · Output $3.366/M tok',
+      )
       .then(($prices) => {
         const subtitle = $prices.parent().text();
         expect(subtitle.indexOf($prices.text())).to.be.lessThan(subtitle.indexOf('Updated:'));
@@ -156,6 +161,7 @@ describe('Inference Chart', () => {
             id: 'deepseek/deepseek-v4-pro-0813',
             pricing: {
               prompt: '0.000001122',
+              input_cache_read: '0.00000008',
               completion: '0.000003366',
             },
           },
@@ -178,12 +184,16 @@ describe('Inference Chart', () => {
       'OpenRouter 当前价格',
     );
     cy.get('[data-testid="openrouter-price-summary"]')
-      .should('contain.text', '输入 $1.122/百万 token')
+      .should('contain.text', '未缓存输入 $1.122/百万 token')
+      .and('contain.text', '缓存输入 $0.08/百万 token')
       .and('contain.text', '输出 $3.366/百万 token');
     cy.get('[data-testid="chart-figure"]')
       .first()
       .find('[data-testid="token-revenue-subtitle-prices"]')
-      .should('have.text', '输入 $1.122/百万 token · 输出 $3.366/百万 token')
+      .should(
+        'have.text',
+        '未缓存输入 $1.122/百万 token · 缓存输入 $0.08/百万 token · 输出 $3.366/百万 token',
+      )
       .then(($prices) => {
         const subtitle = $prices.parent().text();
         expect(subtitle.indexOf($prices.text())).to.be.lessThan(subtitle.indexOf('更新时间：'));
 
@@ -40,6 +40,10 @@ export const metricsFor = (intvty: number, tput: number, e2el: number): Record<s
   tput_per_gpu: tput,
   output_tput_per_gpu: tput * 0.3,
   input_tput_per_gpu: tput * 0.7,
+  server_gpu_cache_hit_rate: 0.8,
+  server_external_cache_hit_rate: 0.1,
+  // External already includes the offload tier; revenue must not add this again.
+  server_cpu_cache_hit_rate: 0.05,
 });
 
 /**
 
@@ -27,6 +27,7 @@ import { SegmentedToggle, type SegmentedToggleOption } from '@/components/ui/seg
 import { TooltipProvider } from '@/components/ui/tooltip';
 import { track } from '@/lib/analytics';
 import { exportToCsv } from '@/lib/csv-export';
+import { DEFAULT_CACHED_INPUT_PRICE_RATIO } from '@/lib/cache-pricing';
 import { getGpuSpecs, getHardwareConfig } from '@/lib/constants';
 import {
   getModelLabel,
@@ -343,7 +344,7 @@ const DEFAULTS = {
    * and Anthropic both publish, and the order of magnitude the others sit at.
    * An assumption like the rest; the cached *fraction* it applies to is measured.
    */
-  cachedInputPct: 10,
+  cachedInputPct: DEFAULT_CACHED_INPUT_PRICE_RATIO * 100,
   /**
    * An output token sells for four times an input one until the user says
    * otherwise — DeepSeek's own published API pricing is $0.27 / $1.10, and the