fix vision

assets/pinchbench.css

@@ -347,6 +347,16 @@
   white-space: nowrap;
 }
 
+.wab-token-split-total {
+  display: block;
+  margin-top: 0.15rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--text);
+  font-weight: 600;
+}
+
 .wab-traces-placeholder {
   min-height: 120px;
 }

src/load_entries.py

@@ -14,7 +14,7 @@ from src.export_results import (
     ui_classes_from_payload,
 )
 from src.models import LeaderboardEntry
-from src.token_display import token_usage_from_run
+from src.token_display import reconcile_entry_usage_totals, token_usage_from_run
 
 _RAW_CACHE: dict[str, tuple[float, dict[str, Any]]] = {}
 
@@ -82,6 +82,7 @@ def _enrich_entry_from_raw(entry: LeaderboardEntry, raw: dict[str, Any]) -> None
             for slot, models in slots.items()
             if isinstance(models, list) and models
         }
+    reconcile_entry_usage_totals(entry)
 
 
 def load_entry_file(path: Path) -> LeaderboardEntry | None:
@@ -106,6 +107,8 @@ def load_entry_file(path: Path) -> LeaderboardEntry | None:
         raw = load_raw_results(entry, space_root(path.parent.parent))
         if raw:
             _enrich_entry_from_raw(entry, raw)
+    else:
+        reconcile_entry_usage_totals(entry)
     return entry
 
 

src/token_display.py

@@ -85,6 +85,46 @@ def token_usage_from_run(run: dict[str, Any] | None) -> dict[str, dict[str, Any]
     return compact_token_usage_by_model(run.get("token_usage_by_model"))
 
 
+def sum_usage_by_model(
+    usage_by_model: dict[str, dict[str, Any]] | None,
+) -> tuple[int, float | None]:
+    """Sum token and recorded cost counters across per-model buckets."""
+    tokens = 0
+    cost = 0.0
+    has_cost = False
+    for usage in (usage_by_model or {}).values():
+        if not isinstance(usage, dict):
+            continue
+        tokens += _usage_tokens(usage)
+        amount = usage.get("cost_usd")
+        if isinstance(amount, (int, float)) and float(amount) > 0:
+            cost += float(amount)
+            has_cost = True
+    return tokens, (cost if has_cost else None)
+
+
+def entry_recorded_totals(entry: LeaderboardEntry) -> tuple[int | None, float | None]:
+    """Return authoritative totals from per-model buckets, falling back to run totals."""
+    tokens, cost = sum_usage_by_model(entry.token_usage_by_model)
+    total_tokens = tokens if tokens > 0 else entry.total_tokens
+    total_cost = cost if cost is not None and cost > 0 else entry.total_cost_usd
+    return total_tokens, total_cost
+
+
+def reconcile_entry_usage_totals(entry: LeaderboardEntry) -> None:
+    """Keep run totals aligned with summed token_usage_by_model when recorded."""
+    by_model = entry.token_usage_by_model or {}
+    if not by_model:
+        return
+    tokens, cost = sum_usage_by_model(by_model)
+    if tokens > 0:
+        entry.total_tokens = tokens
+    if cost is not None and cost > 0:
+        entry.total_cost_usd = cost
+        if entry.total_tasks:
+            entry.avg_cost_per_task_usd = cost / entry.total_tasks
+
+
 def _short_model_name(model: str) -> str:
     return model.split("/")[-1] if "/" in model else model
 
@@ -162,17 +202,33 @@ def _compact_slot_label(model: str, roles: list[str], *, primary: str) -> str:
     return short
 
 
-def _ouroboros_slot_lines(entry: LeaderboardEntry) -> list[str]:
+def _ouroboros_slot_display_lines(entry: LeaderboardEntry) -> list[str]:
     index = _model_roles_index(entry.ouroboros_model_slots)
     if not index:
         return []
+
+    total_tokens, total_cost = entry_recorded_totals(entry)
+    total_bits: list[str] = []
+    if total_tokens:
+        total_bits.append(fmt_tokens(total_tokens))
+    if total_cost:
+        total_bits.append(fmt_cost(total_cost))
+    total_line = " · ".join(total_bits)
+
     if len(index) == 1:
-        return [_short_model_name(next(iter(index)))]
+        short = _short_model_name(next(iter(index)))
+        if total_line:
+            return [f"{short} {total_line}"]
+        return [short]
+
     primary = entry.model
-    return [
+    lines = [
         _compact_slot_label(model, index[model], primary=primary)
         for model in sorted(index, key=lambda name: (name != primary, name))
     ]
+    if total_line:
+        lines.append(f"{total_line} total")
+    return lines
 
 
 def _format_token_usage_breakdown(entry: LeaderboardEntry) -> str:
@@ -209,7 +265,7 @@ def _format_token_usage_breakdown(entry: LeaderboardEntry) -> str:
 
 
 def _format_ouroboros_slots_breakdown(entry: LeaderboardEntry) -> str:
-    lines = _ouroboros_slot_lines(entry)
+    lines = _ouroboros_slot_display_lines(entry)
     if not lines:
         return "—"
     return " · ".join(lines)
@@ -230,13 +286,15 @@ def format_model_usage_breakdown_html(entry: LeaderboardEntry) -> str:
         text = _format_token_usage_breakdown(entry)
         return f'<span class="wab-token-split" title="{html.escape(text)}">{html.escape(text)}</span>'
 
-    lines = _ouroboros_slot_lines(entry)
+    lines = _ouroboros_slot_display_lines(entry)
     if not lines:
         return "—"
     title = " · ".join(lines)
-    body = "".join(
-        f'<span class="wab-token-split-line">{html.escape(line)}</span>' for line in lines
-    )
+    body_parts: list[str] = []
+    for line in lines:
+        css_class = "wab-token-split-total" if line.endswith(" total") else "wab-token-split-line"
+        body_parts.append(f'<span class="{css_class}">{html.escape(line)}</span>')
+    body = "".join(body_parts)
     return f'<span class="wab-token-split" title="{html.escape(title)}">{body}</span>'
 
 
@@ -266,6 +324,7 @@ def format_task_token_usage(
         entry = LeaderboardEntry(
             model=primary_model,
             harness=harness,
+            token_usage_by_model=compact_token_usage_by_model(by_model if isinstance(by_model, dict) else None),
             ouroboros_model_slots=slots,
         )
         if _has_ouroboros_slot_split(entry):