@@ -10,6 +10,12 @@
 from collections import Counter, defaultdict
 from pathlib import Path
 
+from rle.tracking.cost_tracker import (
+    authoritative_cost_usd,
+    infer_cost_source,
+    is_pareto_cost_source,
+)
+
 # Failure substrings attributable to the harness / known RIMAPI quirks, not the model.
 HARNESS_FAILURE_MARKERS = [
     "Invalid plant definition",          # Plant_Rice / Plant_Potato def-name quirk
@@ -122,10 +128,12 @@ def main() -> None:
         delta = [round(a - b, 4) for a, b in zip(traj, base_slice)]
         ticks_above = sum(1 for x in delta if x > 0)
         c = m["summary"]["cost_snapshot"]
-        # Billed ground truth (run_scenario reconciles via OpenRouter's
-        # generation API) — same schema we hand-patched into the v0.3.0
-        # leaderboard from the dashboard. Estimates stay for comparison.
+        # Billed / console / estimated stay distinct. cost_source is the
+        # enum (billed|estimated|console|unknown); unknown $0 is not a
+        # Pareto point.
         billed = m["summary"].get("billed_cost")
+        source = infer_cost_source(c, billed if isinstance(billed, dict) else None)
+        display = authoritative_cost_usd(c, billed if isinstance(billed, dict) else None)
         rows.append({
             "model": m["summary"]["model"],
             "name": name,
@@ -143,11 +151,22 @@ def main() -> None:
             "avg_latency_s": round(m["deliberation"]["avg_latency_ms"] / 1000, 1),
             "avg_confidence": m["deliberation"]["avg_confidence"],
             "wall_min": round(c["wall_time_s"] / 60, 1),
-            "est_cost_usd": round(c["estimated_cost_usd"], 2),
+            "est_cost_usd": round(c.get("estimated_cost_usd") or 0, 2),
             "real_cost_usd": (
-                round(billed["billed_cost_usd"], 3) if billed else None
+                round(float(billed["billed_cost_usd"]), 3)
+                if isinstance(billed, dict) and billed.get("billed_cost_usd") is not None
+                else (
+                    round(float(c["billed_cost_usd"]), 3)
+                    if c.get("billed_cost_usd") is not None else None
+                )
+            ),
+            "console_cost_usd": (
+                round(float(c["console_cost_usd"]), 3)
+                if c.get("console_cost_usd") is not None else None
             ),
-            "cost_source": billed["source"] if billed else None,
+            "display_cost_usd": round(display, 3) if display is not None else None,
+            "cost_source": source.value,
+            "pareto_eligible": is_pareto_cost_source(source),
             "trajectory": traj,
             "days": days,
             "baseline_slice": [round(x, 4) for x in base_slice],
 
@@ -22,6 +22,8 @@
 from decimal import ROUND_HALF_UP, Decimal
 from pathlib import Path
 
+from rle.tracking.cost_tracker import is_pareto_cost_source
+
 # Display name / family / family swatch per model slug, mirroring the palette
 # in AppSprout-Site client/src/rle/data.ts. Unknown slugs fall back to a
 # derived family + neutral color with a warning, so a new model never blocks
@@ -43,6 +45,32 @@
 }
 FALLBACK_COLOR = "#B7AC8B"
 
+# Optional published-pack backfill (Site may apply later). Not live-metered
+# here and not fetched from any API — values from the n1-final pack review:
+# CLI coding-agent harness estimated $1.594858 from 796917 tokens; Felix keep
+# billed $0.857296; ACP console ~$7; raw = unknown / omit from cost Pareto.
+PACK_COST_BACKFILL: dict[str, dict[str, object]] = {
+    "cli-agent": {
+        "cost_usd": 1.594858,
+        "cost_source": "estimated",
+        "note": "796917 tokens; pricing slug was openrouter/x-ai/grok-4.6",
+    },
+    "felix": {
+        "cost_usd": 0.857296,
+        "cost_source": "billed",
+    },
+    "acp": {
+        "cost_usd": 7.0,
+        "cost_source": "console",
+        "note": "n1-final console ~$7",
+    },
+    "raw-grok": {
+        "cost_usd": None,
+        "cost_source": "unknown",
+        "note": "omit from cost Pareto",
+    },
+}
+
 GITHUB_URL = "https://github.com/AppSprout-dev/RLE"
 GITHUB_REPO = "AppSprout-dev/RLE"
 DISCORD_URL = "https://discord.gg/vKuyjqNEea"
@@ -69,11 +97,30 @@ def registry_entry(slug: str) -> tuple[str, str, str]:
     return slug, family, FALLBACK_COLOR
 
 
+def _row_cost_source(row: dict) -> str:
+    raw = row.get("cost_source")
+    return str(raw) if raw else "unknown"
+
+
 def build_model(row: dict) -> dict:
     slug = row["model"]
     display, family, color = registry_entry(slug)
-    real = row.get("real_cost_usd")
-    cost = real if real is not None else row["est_cost_usd"]
+    source = _row_cost_source(row)
+    eligible = bool(row.get("pareto_eligible", is_pareto_cost_source(source)))
+    # Prefer the analyze-spread authoritative figure; never fall back to
+    # unknown $0 (that used to land CLI/ACP/raw rows on the Site Pareto).
+    display_cost = row.get("display_cost_usd")
+    if display_cost is None and eligible:
+        real = row.get("real_cost_usd")
+        console = row.get("console_cost_usd")
+        if source == "billed" and real is not None:
+            display_cost = real
+        elif source == "console" and console is not None:
+            display_cost = console
+        elif source == "estimated":
+            display_cost = row.get("est_cost_usd")
+    if not eligible:
+        display_cost = None
     return {
         "slug": slug,
         "key": row["name"],
@@ -89,13 +136,24 @@ def build_model(row: dict) -> dict:
         "exArtifactSuccess": rnd(row["ex_artifact_success"], 2),
         "avgLatencyS": rnd(row["avg_latency_s"], 1),
         "wallMin": rnd(row["wall_min"], 1),
-        "costUsd": rnd(cost, 2),
-        "costEstimated": real is None,
+        "costUsd": rnd(display_cost, 2) if display_cost is not None else None,
+        "costEstimated": source == "estimated",
+        "costSource": source,
+        "paretoEligible": eligible and display_cost is not None,
     }
 
 
 def build_meta(board: dict, rows: list[dict], args: argparse.Namespace) -> dict:
-    metered = [r["real_cost_usd"] for r in board["rows"] if r.get("real_cost_usd") is not None]
+    metered: list[float] = []
+    for r in board["rows"]:
+        source = _row_cost_source(r)
+        if source not in ("billed", "console"):
+            continue
+        amount = r.get("real_cost_usd") if source == "billed" else r.get("console_cost_usd")
+        if amount is None:
+            amount = r.get("display_cost_usd")
+        if amount is not None:
+            metered.append(float(amount))
     ticks = max((len(r.get("trajectory", [])) for r in board["rows"]), default=0)
     return {
         "scenario": args.scenario,
@@ -127,8 +185,8 @@ def emit_ts(meta: dict, models: list[dict], spread_dir: Path) -> str:
         f"  ticks: {meta['ticks']},",
         f"  nRuns: {meta['nRuns']},",
         f'  date: "{meta["date"]}",',
-        "  // OpenRouter spend for the metered models; subscription-billed models",
-        "  // (costEstimated: true) are not included.",
+        "  // Billed + console spend; estimated/unknown rows are not included.",
+        "  // Plot Pareto only when costSource is billed|estimated|console.",
         f"  totalSpendUsd: {fmt(meta['totalSpendUsd'], 2)},",
         f"  baselineMeanTteDays: {meta['baselineMeanTteDays']},",
         f'  githubUrl: "{meta["githubUrl"]}",',
@@ -151,8 +209,10 @@ def emit_ts(meta: dict, models: list[dict], spread_dir: Path) -> str:
             f"    endDay: {m['endDay']}, rawActionSuccess: {fmt(m['rawActionSuccess'], 2)},"
             f" exArtifactSuccess: {fmt(m['exArtifactSuccess'], 2)},"
             f" avgLatencyS: {fmt(m['avgLatencyS'], 1)}, wallMin: {fmt(m['wallMin'], 1)},",
-            f"    costUsd: {fmt(m['costUsd'], 2)},"
-            f" costEstimated: {'true' if m['costEstimated'] else 'false'},",
+            f"    costUsd: {fmt(m['costUsd'], 2) if m['costUsd'] is not None else 'null'},"
+            f" costEstimated: {'true' if m['costEstimated'] else 'false'},"
+            f" costSource: \"{m['costSource']}\","
+            f" paretoEligible: {'true' if m['paretoEligible'] else 'false'},",
             "  },",
         ]
     lines += ["];", ""]
@@ -185,7 +245,10 @@ def main() -> None:
 
     json_path = out / "site_data.json"
     json_path.write_text(
-        json.dumps({"meta": meta, "models": models}, indent=2) + "\n",
+        json.dumps(
+            {"meta": meta, "models": models, "costBackfill": PACK_COST_BACKFILL},
+            indent=2,
+        ) + "\n",
         encoding="utf-8")
 
     print(f"Wrote {ts_path}")
 
@@ -535,15 +535,18 @@ async def main(args: argparse.Namespace) -> None:  # noqa: PLR0912, PLR0915
         # Reconcile estimates against OpenRouter's billed ground truth
         # (token-count estimates diverged up to 4x on the v0.3.0 spread).
         billed_report = None
-        effective_base_url = config.provider_base_url or ""
         openai_key = os.environ.get("OPENAI_API_KEY", "")
         generation_ids = cost_tracker.generation_ids
-        if "openrouter.ai" in effective_base_url and openai_key and generation_ids:
+        # Provider-truth: generation IDs + key are enough. CLI/ACP harnesses
+        # often report localhost as base_url while still billing through OpenRouter.
+        if openai_key and generation_ids:
             print(
                 f"\nReconciling billed cost for {len(generation_ids)} "
                 "generations against OpenRouter...",
             )
             billed_report = await fetch_billed_costs(generation_ids, openai_key)
+            if billed_report is not None:
+                cost_tracker.apply_billed(billed_report.billed_cost_usd)
 
         clean_results = [r for r in results if not r.get("harness_failed")]
         metadata = collect_metadata(random_seed=args.seed)
 
@@ -298,15 +298,18 @@ async def main(args: argparse.Namespace) -> None:
     # token-count estimator diverged up to 4x in both directions on the
     # v0.3.0 spread (thinking-model usage shapes, caching discounts).
     billed_report = None
-    effective_base_url = config.provider_base_url or ""
     openai_key = os.environ.get("OPENAI_API_KEY", "")
     generation_ids = cost_tracker.generation_ids
-    if "openrouter.ai" in effective_base_url and openai_key and generation_ids:
+    # Provider-truth: generation IDs + key are enough. CLI/ACP harnesses
+    # often report localhost as base_url while still billing through OpenRouter.
+    if openai_key and generation_ids:
         print(
             f"\nReconciling billed cost for {len(generation_ids)} generations "
             "against OpenRouter...",
         )
         billed_report = await fetch_billed_costs(generation_ids, openai_key)
+        if billed_report is not None:
+            cost_tracker.apply_billed(billed_report.billed_cost_usd)
 
     if args.output:
         output_dir = Path(args.output)
 
@@ -32,6 +32,7 @@
 from rle.orchestration.action_executor import ActionExecutor
 from rle.rimapi.schemas import GameState
 from rle.rimapi.sse_client import RimAPIEvent
+from rle.tracking.cost_tracker import CostSource, CostTracker
 from rle.tracking.event_log import EventType
 
 logger = logging.getLogger(__name__)
@@ -121,7 +122,12 @@ def mcp_listen(self, config: RLEConfig) -> McpListenSettings:
 
 @dataclass
 class TurnResult:
-    """What the agent produced for one prompt."""
+    """What the agent produced for one prompt.
+
+    ``extras`` may carry provider-truth metering that is independent of
+    token counts: ``cost_usd``, ``cost_source`` (``billed`` / ``console`` /
+    ``estimated``), and ``generation_id`` / ``generation_ids``.
+    """
 
     text: str = ""
     prompt_tokens: int = 0
@@ -130,6 +136,85 @@ class TurnResult:
     extras: dict[str, Any] = field(default_factory=dict)
 
 
+def _extras_generation_ids(extras: dict[str, Any]) -> list[str]:
+    """Collect generation IDs from extras (singular, plural, or nested)."""
+    ids: list[str] = []
+    raw = extras.get("generation_ids", extras.get("generation_id"))
+    if raw is None:
+        raw = extras.get("generationId")
+    if isinstance(raw, str):
+        if raw:
+            ids.append(raw)
+    elif isinstance(raw, (list, tuple)):
+        ids.extend(str(item) for item in raw if item)
+    return ids
+
+
+def _extras_cost_usd(extras: dict[str, Any]) -> float | None:
+    raw = extras.get("cost_usd", extras.get("costUsd"))
+    if raw is None:
+        return None
+    try:
+        return float(raw)
+    except (TypeError, ValueError):
+        return None
+
+
+def _extras_cost_source(extras: dict[str, Any]) -> CostSource:
+    raw = extras.get("cost_source", extras.get("costSource", "console"))
+    try:
+        return CostSource(str(raw))
+    except ValueError:
+        return CostSource.CONSOLE
+
+
+def apply_turn_metering(tracker: CostTracker | None, turn: TurnResult) -> dict[str, Any]:
+    """Record tokens, extras.cost_usd, and generation IDs on ``tracker``.
+
+    Cost-only turns (tokens=0 but ``cost_usd`` / generation IDs present) are
+    first-class — nothing here is gated on a non-zero token count. Returns
+    the kwargs for a ``provider_call`` event, or ``{}`` when there is
+    nothing to emit.
+    """
+    extras = turn.extras
+    cost_usd = _extras_cost_usd(extras)
+    gen_ids = _extras_generation_ids(extras)
+    has_tokens = bool(turn.prompt_tokens or turn.completion_tokens or turn.reasoning_tokens)
+    if tracker is not None:
+        for gen_id in gen_ids:
+            tracker.record_generation_id(gen_id)
+        if cost_usd is not None:
+            tracker.record_provider_cost(
+                cost_usd,
+                source=_extras_cost_source(extras),
+                count_call=not has_tokens,
+            )
+        if has_tokens:
+            tracker.record_raw(
+                turn.prompt_tokens, turn.completion_tokens, turn.reasoning_tokens,
+            )
+    estimated = 0.0
+    if tracker is not None:
+        estimated = tracker.estimate_call_cost(
+            turn.prompt_tokens, turn.completion_tokens, turn.reasoning_tokens,
+        )
+    if not (has_tokens or cost_usd is not None or gen_ids):
+        return {}
+    payload: dict[str, Any] = {
+        "prompt_tokens": turn.prompt_tokens,
+        "completion_tokens": turn.completion_tokens,
+        "reasoning_tokens": turn.reasoning_tokens,
+        "estimated_cost": estimated,
+        "raw_output": turn.text[:_RAW_OUTPUT_CHARS],
+        "raw_output_truncated": len(turn.text) > _RAW_OUTPUT_CHARS,
+    }
+    if cost_usd is not None:
+        payload["cost_usd"] = cost_usd
+    if gen_ids:
+        payload["generation_ids"] = gen_ids
+    return payload
+
+
 class HeadlessCliHarness(BaseHarness, ABC):
     name: ClassVar[str] = "headless-cli"
 
@@ -280,18 +365,9 @@ async def step(
             agent=self.name, latency_ms=latency_ms, num_actions=n_actions,
             summary=step.plan.summary, error_type=None if status == "success" else status,
         )
-        if turn.prompt_tokens or turn.completion_tokens:
-            if self.ctx.cost_tracker:
-                self.ctx.cost_tracker.record_raw(
-                    turn.prompt_tokens, turn.completion_tokens, turn.reasoning_tokens,
-                )
-            self.ctx.emit(
-                EventType.PROVIDER_CALL, tick, agent=self.name,
-                prompt_tokens=turn.prompt_tokens, completion_tokens=turn.completion_tokens,
-                reasoning_tokens=turn.reasoning_tokens,
-                raw_output=turn.text[:_RAW_OUTPUT_CHARS],
-                raw_output_truncated=len(turn.text) > _RAW_OUTPUT_CHARS,
-            )
+        metering = apply_turn_metering(self.ctx.cost_tracker, turn)
+        if metering:
+            self.ctx.emit(EventType.PROVIDER_CALL, tick, agent=self.name, **metering)
 
         extras = {**step.extras, "status": status, "latency_ms": latency_ms, **turn.extras}
         return StepResult(
 
@@ -429,8 +429,10 @@ async def _deliberate_agent(
             if not isinstance(rt, int):
                 rt = 0
             if isinstance(pt, int) and isinstance(ct, int):
+                estimated_cost = 0.0
                 if self.ctx.cost_tracker:
                     self.ctx.cost_tracker.record_raw(pt, ct, rt)
+                    estimated_cost = self.ctx.cost_tracker.estimate_call_cost(pt, ct, rt)
                 raw_output = agent._last_raw_output
                 raw_output_truncated = (
                     raw_output[:_RAW_OUTPUT_CHARS] if raw_output else None
@@ -442,6 +444,7 @@ async def _deliberate_agent(
                     EventType.PROVIDER_CALL, tick, agent=plan.role,
                     prompt_tokens=pt, completion_tokens=ct,
                     reasoning_tokens=rt,
+                    estimated_cost=estimated_cost,
                     raw_output=raw_output_truncated,
                     raw_output_truncated=was_truncated,
                 )