fix cost

app.py

@@ -340,6 +340,7 @@ def build_demo(entries=None):
                         "Avg duration": entry.avg_duration_seconds,
                         "Avg steps": entry.avg_agent_steps,
                         "Tokens/task": entry.avg_tokens_per_task,
+                        "Total tokens": entry.total_tokens,
                         "Total $": entry.total_cost_usd,
                         "Pass@k": entry.pass_at_k,
                     }

assets/pinchbench.css

@@ -315,6 +315,22 @@
   min-width: 220px;
 }
 
+.wab-token-split-cell {
+  min-width: 180px;
+  max-width: 320px;
+  font-size: 0.78rem;
+  line-height: 1.35;
+  color: var(--text-muted);
+}
+
+.wab-token-split {
+  display: inline-block;
+}
+
+.wab-traces-placeholder {
+  min-height: 120px;
+}
+
 .wab-model-name {
   font-family: var(--mono);
   font-size: 0.86rem;

src/export_results.py

@@ -14,6 +14,7 @@ from typing import Any
 
 from src.bench_config import load_bench_config
 from src.models import LeaderboardEntry, SectionStats, reconcile_success_metrics
+from src.token_display import compact_token_usage_by_model, token_usage_from_run
 
 
 def _sanitize_name(value: str) -> str:
@@ -111,6 +112,9 @@ def _ui_badges(payload: dict[str, Any], limit: int = 4) -> list[str]:
 
 
 def _cost_from_payload(payload: dict[str, Any]) -> tuple[float | None, float | None]:
+    recorded = _recorded_cost_from_payload(payload)
+    if recorded is not None:
+        return recorded
     _ensure_repo_on_path()
     try:
         from bench_eval.llm_cost import compute_results_cost
@@ -121,6 +125,35 @@ def _cost_from_payload(payload: dict[str, Any]) -> tuple[float | None, float | N
         return None, None
 
 
+def _recorded_cost_from_payload(payload: dict[str, Any]) -> tuple[float | None, float | None] | None:
+    """Fast path: sum recorded cost_usd without fetching pricing tables."""
+    run = payload.get("run") or {}
+    tests = payload.get("tests") or []
+    total_tasks = int(run.get("total_tasks") or len(tests) or 0)
+    by_model = run.get("token_usage_by_model")
+    if isinstance(by_model, dict) and by_model:
+        total = 0.0
+        priced = False
+        for usage in by_model.values():
+            if not isinstance(usage, dict):
+                continue
+            cost = usage.get("cost_usd")
+            if isinstance(cost, (int, float)) and float(cost) > 0:
+                total += float(cost)
+                priced = True
+        if priced:
+            avg = (total / total_tasks) if total_tasks else None
+            return total, avg
+
+    for key in ("total_cost_usd", "total_cost", "cost_usd", "cost"):
+        value = run.get(key)
+        if isinstance(value, (int, float)) and float(value) > 0:
+            total = float(value)
+            avg = (total / total_tasks) if total_tasks else None
+            return total, avg
+    return None
+
+
 def _needs_cost_backfill(entry: LeaderboardEntry) -> bool:
     return entry.total_cost_usd is None or entry.total_cost_usd <= 0
 
@@ -212,6 +245,7 @@ def export_entry(payload: dict[str, Any], *, source_path: str | None = None) ->
         total_tokens=run.get("total_tokens"),
         total_cost_usd=total_cost,
         avg_cost_per_task_usd=avg_cost,
+        token_usage_by_model=token_usage_from_run(run),
         pass_at_k=float(pass_overall) if isinstance(pass_overall, (int, float)) else None,
         agent_completion_rate=extended.get("agent_completion_rate"),
         agent_dab_agreement_rate=extended.get("agent_dab_agreement_rate"),

src/load_entries.py

@@ -7,8 +7,16 @@ from pathlib import Path
 from typing import Any
 
 from src.bench_config import load_bench_config
-from src.export_results import _cost_from_payload, raw_results_path_for, ui_classes_from_payload
+from src.export_results import (
+    _cost_from_payload,
+    _recorded_cost_from_payload,
+    raw_results_path_for,
+    ui_classes_from_payload,
+)
 from src.models import LeaderboardEntry
+from src.token_display import token_usage_from_run
+
+_RAW_CACHE: dict[str, tuple[float, dict[str, Any]]] = {}
 
 
 def space_root(root: Path | None = None) -> Path:
@@ -19,6 +27,56 @@ def results_dir(root: Path | None = None) -> Path:
     return space_root(root) / "results"
 
 
+def _resolve_raw_path(entry: LeaderboardEntry, root: Path | None = None) -> Path | None:
+    base = space_root(root)
+    if entry.raw_results_path:
+        raw_path = base / entry.raw_results_path
+        if raw_path.is_file():
+            return raw_path
+    fallback = raw_results_path_for(entry, base)
+    if fallback.is_file():
+        return fallback
+    return None
+
+
+def load_raw_results(entry: LeaderboardEntry, root: Path | None = None) -> dict[str, Any] | None:
+    raw_path = _resolve_raw_path(entry, root)
+    if raw_path is None:
+        return None
+    cache_key = str(raw_path.resolve())
+    try:
+        mtime = raw_path.stat().st_mtime
+    except OSError:
+        mtime = 0.0
+    cached = _RAW_CACHE.get(cache_key)
+    if cached is not None and cached[0] == mtime:
+        return cached[1]
+    payload = json.loads(raw_path.read_text(encoding="utf-8"))
+    _RAW_CACHE[cache_key] = (mtime, payload)
+    return payload
+
+
+def _enrich_entry_from_raw(entry: LeaderboardEntry, raw: dict[str, Any]) -> None:
+    run = raw.get("run") or {}
+    if not entry.ui_classes:
+        entry.ui_classes = ui_classes_from_payload(raw)
+    if not entry.token_usage_by_model:
+        entry.token_usage_by_model = token_usage_from_run(run)
+    if entry.total_cost_usd is None or entry.total_cost_usd <= 0:
+        recorded = _recorded_cost_from_payload(raw)
+        if recorded is not None:
+            total_cost, avg_cost = recorded
+        else:
+            total_cost, avg_cost = _cost_from_payload(raw)
+        if total_cost is not None and total_cost > 0:
+            entry.total_cost_usd = total_cost
+            entry.avg_cost_per_task_usd = avg_cost
+    if entry.total_tokens is None and isinstance(run.get("total_tokens"), (int, float)):
+        entry.total_tokens = int(run["total_tokens"])
+    if entry.avg_tokens_per_task is None and isinstance(run.get("avg_tokens_per_task"), (int, float)):
+        entry.avg_tokens_per_task = float(run["avg_tokens_per_task"])
+
+
 def load_entry_file(path: Path) -> LeaderboardEntry | None:
     payload = json.loads(path.read_text(encoding="utf-8"))
     if "metrics" not in payload:
@@ -28,17 +86,18 @@ def load_entry_file(path: Path) -> LeaderboardEntry | None:
         raw_path = raw_results_path_for(entry, space_root(path.parent.parent))
         if raw_path.is_file():
             entry.raw_results_path = str(raw_path.relative_to(space_root(path.parent.parent)))
-    if not entry.ui_classes:
-        raw = load_raw_results(entry, space_root(path.parent.parent))
-        if raw:
-            entry.ui_classes = ui_classes_from_payload(raw)
-    if entry.total_cost_usd is None or entry.total_cost_usd <= 0:
+    needs_raw = (
+        not entry.ui_classes
+        or not entry.token_usage_by_model
+        or entry.total_cost_usd is None
+        or entry.total_cost_usd <= 0
+        or entry.total_tokens is None
+        or entry.avg_tokens_per_task is None
+    )
+    if needs_raw:
         raw = load_raw_results(entry, space_root(path.parent.parent))
         if raw:
-            total_cost, avg_cost = _cost_from_payload(raw)
-            if total_cost is not None and total_cost > 0:
-                entry.total_cost_usd = total_cost
-                entry.avg_cost_per_task_usd = avg_cost
+            _enrich_entry_from_raw(entry, raw)
     return entry
 
 
@@ -73,18 +132,6 @@ def entry_by_id(entries: list[LeaderboardEntry], entry_id: str) -> LeaderboardEn
     return None
 
 
-def load_raw_results(entry: LeaderboardEntry, root: Path | None = None) -> dict[str, Any] | None:
-    base = space_root(root)
-    if entry.raw_results_path:
-        raw_path = base / entry.raw_results_path
-        if raw_path.is_file():
-            return json.loads(raw_path.read_text(encoding="utf-8"))
-    fallback = raw_results_path_for(entry, base)
-    if fallback.is_file():
-        return json.loads(fallback.read_text(encoding="utf-8"))
-    return None
-
-
 def sort_entries(entries: list[LeaderboardEntry], view_id: str) -> list[LeaderboardEntry]:
     config = load_bench_config()
     view = next((row for row in config["views"] if row["id"] == view_id), config["views"][0])

src/models.py

@@ -56,6 +56,7 @@ class LeaderboardEntry:
     total_tokens: int | None = None
     total_cost_usd: float | None = None
     avg_cost_per_task_usd: float | None = None
+    token_usage_by_model: dict[str, dict[str, Any]] = field(default_factory=dict)
 
     pass_at_k: float | None = None
     agent_completion_rate: float | None = None
@@ -133,6 +134,7 @@ class LeaderboardEntry:
                 "total_tokens": self.total_tokens,
                 "total_cost_usd": self.total_cost_usd,
                 "avg_cost_per_task_usd": self.avg_cost_per_task_usd,
+                "token_usage_by_model": self.token_usage_by_model,
                 "pass_at_k": self.pass_at_k,
                 "agent_completion_rate": self.agent_completion_rate,
                 "agent_dab_agreement_rate": self.agent_dab_agreement_rate,
@@ -189,6 +191,7 @@ class LeaderboardEntry:
                 total_tokens=metrics.get("total_tokens"),
                 total_cost_usd=metrics.get("total_cost_usd"),
                 avg_cost_per_task_usd=metrics.get("avg_cost_per_task_usd"),
+                token_usage_by_model=dict(metrics.get("token_usage_by_model") or {}),
                 pass_at_k=metrics.get("pass_at_k"),
                 agent_completion_rate=metrics.get("agent_completion_rate"),
                 agent_dab_agreement_rate=metrics.get("agent_dab_agreement_rate"),

src/token_display.py

@@ -0,0 +1,154 @@
+"""Token counts and per-model usage labels for the leaderboard."""
+
+from __future__ import annotations
+
+import html
+from typing import Any
+
+from src.models import LeaderboardEntry
+
+_UNKNOWN_MODEL_KEYS = frozenset({"", "unknown", "unknown_model"})
+
+
+def _fmt_cost(value: float | None) -> str:
+    if value is None:
+        return "—"
+    if value <= 0:
+        return "FREE"
+    return f"${value:.3f}"
+
+
+def fmt_tokens(value: float | int | None) -> str:
+    if value is None:
+        return "—"
+    amount = float(value)
+    if amount <= 0:
+        return "0"
+    if amount >= 1_000_000:
+        return f"{amount / 1_000_000:.1f}M"
+    if amount >= 1_000:
+        return f"{amount / 1_000:.1f}K"
+    if abs(amount - round(amount)) < 0.05:
+        return str(int(round(amount)))
+    return f"{amount:.1f}"
+
+
+def _usage_tokens(usage: dict[str, Any]) -> int:
+    total = usage.get("total_tokens")
+    if isinstance(total, (int, float)) and total > 0:
+        return int(total)
+    prompt = int(usage.get("prompt_tokens") or 0)
+    completion = int(usage.get("completion_tokens") or 0)
+    return prompt + completion
+
+
+def _display_model_name(model: str, primary_model: str) -> str:
+    normalized = str(model or "").strip()
+    if normalized.lower() in _UNKNOWN_MODEL_KEYS:
+        return primary_model
+    return normalized
+
+
+def _role_label(model: str, primary_model: str, roles: list[str]) -> str:
+    display = _display_model_name(model, primary_model)
+    if display == primary_model and not roles:
+        return "primary"
+    if roles:
+        return "/".join(roles)
+    if display == primary_model:
+        return "primary"
+    return "aux"
+
+
+def compact_token_usage_by_model(
+    usage_by_model: dict[str, Any] | None,
+) -> dict[str, dict[str, Any]]:
+    if not isinstance(usage_by_model, dict):
+        return {}
+    compact: dict[str, dict[str, Any]] = {}
+    for model, usage in usage_by_model.items():
+        if not isinstance(usage, dict):
+            continue
+        row: dict[str, Any] = {
+            "prompt_tokens": int(usage.get("prompt_tokens") or 0),
+            "completion_tokens": int(usage.get("completion_tokens") or 0),
+            "total_tokens": int(usage.get("total_tokens") or 0),
+            "llm_calls": int(usage.get("llm_calls") or 0),
+        }
+        cost = usage.get("cost_usd")
+        if isinstance(cost, (int, float)) and cost > 0:
+            row["cost_usd"] = float(cost)
+        roles = usage.get("roles")
+        if isinstance(roles, list) and roles:
+            row["roles"] = [str(role) for role in roles]
+        compact[str(model)] = row
+    return compact
+
+
+def token_usage_from_run(run: dict[str, Any] | None) -> dict[str, dict[str, Any]]:
+    if not isinstance(run, dict):
+        return {}
+    return compact_token_usage_by_model(run.get("token_usage_by_model"))
+
+
+def format_model_usage_breakdown(entry: LeaderboardEntry) -> str:
+    by_model = entry.token_usage_by_model or {}
+    if not by_model:
+        return "—"
+
+    primary = entry.model
+    rows: list[tuple[str, str, str, str]] = []
+    for model, usage in sorted(by_model.items()):
+        if not isinstance(usage, dict):
+            continue
+        display = _display_model_name(str(model), primary)
+        short = display.split("/")[-1] if "/" in display else display
+        role = _role_label(str(model), primary, list(usage.get("roles") or []))
+        tokens = fmt_tokens(_usage_tokens(usage))
+        cost = usage.get("cost_usd")
+        cost_s = _fmt_cost(float(cost)) if isinstance(cost, (int, float)) and cost > 0 else ""
+        rows.append((short, role, tokens, cost_s))
+
+    if not rows:
+        return "—"
+
+    if len(rows) == 1 and rows[0][1] == "primary":
+        short, _, tokens, cost_s = rows[0]
+        extra = f" · {cost_s}" if cost_s and cost_s != "—" else ""
+        return f"{short} {tokens}{extra}"
+
+    parts: list[str] = []
+    for short, role, tokens, cost_s in rows:
+        label = "primary" if role == "primary" else role
+        bit = f"{short} {tokens} ({label})"
+        if cost_s and cost_s != "—":
+            bit += f" {cost_s}"
+        parts.append(bit)
+    return " · ".join(parts)
+
+
+def format_model_usage_breakdown_html(entry: LeaderboardEntry) -> str:
+    text = format_model_usage_breakdown(entry)
+    if text == "—":
+        return "—"
+    return f'<span class="wab-token-split" title="{html.escape(text)}">{html.escape(text)}</span>'
+
+
+def format_task_token_usage(
+    test: dict[str, Any],
+    *,
+    primary_model: str,
+) -> str:
+    by_model = test.get("token_usage_by_model")
+    if isinstance(by_model, dict) and by_model:
+        entry = LeaderboardEntry(
+            model=primary_model,
+            harness=str(test.get("agent_harness") or ""),
+            token_usage_by_model=compact_token_usage_by_model(by_model),
+        )
+        return format_model_usage_breakdown(entry)
+
+    usage = test.get("token_usage")
+    if isinstance(usage, dict):
+        return fmt_tokens(_usage_tokens(usage))
+    return "—"

src/traces.py

@@ -10,6 +10,7 @@ from typing import Any
 from src.bench_config import load_bench_config, section_label
 from src.load_entries import entry_by_id, entry_label, load_raw_results
 from src.models import LeaderboardEntry
+from src.token_display import format_task_token_usage
 from src.ui import fmt_cost
 
 
@@ -395,10 +396,15 @@ def build_traces_shell(
 
 
 def _build_traces_list(entries: list[LeaderboardEntry], selected_id: str) -> str:
+    selected_entry = entry_by_id(entries, selected_id) or entries[0]
+    selected_summaries = trace_summaries_for_entry(selected_entry)
     pills: list[str] = []
     for entry in entries:
-        summaries = trace_summaries_for_entry(entry)
-        count = len(summaries)
+        count = (
+            len(selected_summaries)
+            if entry.entry_id == selected_entry.entry_id
+            else int(entry.total_tasks or 0)
+        )
         active = entry.entry_id == selected_id
         label = html.escape(entry.model.split("/")[-1] if "/" in entry.model else entry.model)
         harness = html.escape(entry.harness)
@@ -410,32 +416,30 @@ def _build_traces_list(entries: list[LeaderboardEntry], selected_id: str) -> str
         pills.append(_trace_pill(entry.entry_id, inner, active=active))
 
     cards: list[str] = []
-    for entry in entries:
-        visible = entry.entry_id == selected_id
-        for row in trace_summaries_for_entry(entry):
-            test_name = row["test_name"]
-            short_name = test_name.replace("bench_", "", 1) if test_name.startswith("bench_") else test_name
-            tags = []
-            if row["domain"]:
-                tags.append(f'<span class="wab-badge domain">{_esc(row["domain"])}</span>')
-            if row["primary_class"]:
-                tags.append(f'<span class="wab-badge taxonomy">{_esc(row["primary_class"])}</span>')
-            tags_html = "".join(tags)
-            card_inner = (
-                f'<div class="wab-trace-card-accent {"pass" if row["success"] else "fail"}"></div>'
-                f'<div class="wab-trace-card-body">'
-                f'<div class="wab-trace-card-top">'
-                f'<span class="wab-trace-card-id">#{_esc(short_name)}</span>'
-                f'<span class="wab-trace-card-section">{_esc(row["section"])}</span>'
-                f"{_status_badge(row['success'])}"
-                f'<span class="wab-trace-card-duration">⏱ {_esc(format_duration(row["duration"]))}</span>'
-                f'<span class="wab-trace-card-steps">{row["agent_steps"]} steps · {row["dab_events"]} DAB</span>'
-                f"</div>"
-                f'<p class="wab-trace-card-task">{_esc(_truncate(row["input"], 220))}</p>'
-                f'<div class="wab-trace-card-tags">{tags_html}</div>'
-                f"</div>"
-            )
-            cards.append(_trace_card(entry.entry_id, test_name, card_inner, visible=visible))
+    for row in selected_summaries:
+        test_name = row["test_name"]
+        short_name = test_name.replace("bench_", "", 1) if test_name.startswith("bench_") else test_name
+        tags = []
+        if row["domain"]:
+            tags.append(f'<span class="wab-badge domain">{_esc(row["domain"])}</span>')
+        if row["primary_class"]:
+            tags.append(f'<span class="wab-badge taxonomy">{_esc(row["primary_class"])}</span>')
+        tags_html = "".join(tags)
+        card_inner = (
+            f'<div class="wab-trace-card-accent {"pass" if row["success"] else "fail"}"></div>'
+            f'<div class="wab-trace-card-body">'
+            f'<div class="wab-trace-card-top">'
+            f'<span class="wab-trace-card-id">#{_esc(short_name)}</span>'
+            f'<span class="wab-trace-card-section">{_esc(row["section"])}</span>'
+            f"{_status_badge(row['success'])}"
+            f'<span class="wab-trace-card-duration">⏱ {_esc(format_duration(row["duration"]))}</span>'
+            f'<span class="wab-trace-card-steps">{row["agent_steps"]} steps · {row["dab_events"]} DAB</span>'
+            f"</div>"
+            f'<p class="wab-trace-card-task">{_esc(_truncate(row["input"], 220))}</p>'
+            f'<div class="wab-trace-card-tags">{tags_html}</div>'
+            f"</div>"
+        )
+        cards.append(_trace_card(selected_entry.entry_id, test_name, card_inner))
 
     body = "".join(cards) if cards else '<p class="wab-detail-note">No task traces in this run.</p>'
     return (
@@ -485,6 +489,7 @@ def build_trace_detail(entries: list[LeaderboardEntry], entry_id: str, test_name
     section = _task_section_label(test_name)
     token_usage = test.get("token_usage") or agent.get("token_usage") or {}
     task_cost = _task_cost_usd(test, entry.model)
+    model_usage = format_task_token_usage(test, primary_model=entry.model)
     success = bool(test.get("success"))
 
     meta_grid = "".join(
@@ -497,6 +502,7 @@ def build_trace_detail(entries: list[LeaderboardEntry], entry_id: str, test_name
             _meta_cell("🌐", "Harness", harness),
             _meta_cell("👣", "Steps", test.get("agent_steps") or max(0, len(ui_steps) - 1)),
             _meta_cell("🪙", "Tokens", _format_tokens(token_usage)),
+            _meta_cell("🧩", "Model usage", model_usage),
             _meta_cell("💰", "Cost", fmt_cost(task_cost)),
             _meta_cell("⏱", "Duration", format_duration(test.get("duration_seconds"))),
             _meta_cell("🚩", "Result", "PASS" if success else "FAIL"),
@@ -697,7 +703,9 @@ element.addEventListener("click", (event) => {
   const pill = event.target.closest("[data-wab-trace-filter]");
   if (pill) {
     event.preventDefault();
-    filterTraceEntry(element, pill.getAttribute("data-wab-trace-filter"));
+    const entryId = pill.getAttribute("data-wab-trace-filter");
+    if (!entryId) return;
+    trigger("navigate", { payload: `traces:list:${entryId}` });
     return;
   }
 
@@ -707,12 +715,7 @@ element.addEventListener("click", (event) => {
   const payload = navBtn.getAttribute("data-wab-trace");
   if (!payload) return;
   if (payload.startsWith("traces:list:")) {
-    const entryId = payload.split(":").slice(2).join(":");
-    if (element.querySelector("#wab-trace-detail")) {
-      trigger("navigate", { payload });
-      return;
-    }
-    filterTraceEntry(element, entryId);
+    trigger("navigate", { payload });
     return;
   }
   if (window.wabOpenDetailTab) window.wabOpenDetailTab("traces");

src/ui.py

@@ -9,6 +9,7 @@ from typing import Any
 from src.bench_config import load_bench_config, task_count
 from src.load_entries import sort_entries
 from src.models import LeaderboardEntry
+from src.token_display import fmt_tokens, format_model_usage_breakdown_html
 
 _DETAIL_TAB_LABELS = {
     "submission": "Submission",
@@ -266,6 +267,9 @@ def _cost_row(idx: int, entry: LeaderboardEntry) -> str:
         <div class="wab-badges"><span class="wab-badge">{html.escape(entry.harness)}</span></div></td>
       <td>{html.escape(fmt_cost(entry.total_cost_usd))}</td>
       <td>{html.escape(fmt_cost(entry.avg_cost_per_task_usd))}</td>
+      <td>{html.escape(fmt_tokens(entry.total_tokens))}</td>
+      <td>{html.escape(fmt_tokens(entry.avg_tokens_per_task))}</td>
+      <td class="wab-token-split-cell">{format_model_usage_breakdown_html(entry)}</td>
       <td>{f"{value:.1f}" if value is not None else "—"}</td>
       <td class="wab-score-cell">
         <div class="wab-score-value wab-score-{tier}">{html.escape(fmt_pct_display(entry))}</div>
@@ -285,9 +289,17 @@ def build_table(entries: list[LeaderboardEntry], view_id: str) -> str:
         rows = [_speed_row(i, entry) for i, entry in enumerate(sorted_entries)]
         subtitle = "Average task duration from results.json run.avg_duration_seconds."
     elif view_id == "cost":
-        head = "<tr><th>#</th><th>Model</th><th>Total $</th><th>$/task</th><th>Value</th><th>Success %</th></tr>"
+        head = (
+            "<tr><th>#</th><th>Model</th><th>Total $</th><th>$/task</th>"
+            "<th>Total tokens</th><th>Tokens/task</th><th>Model usage</th>"
+            "<th>Value</th><th>Success %</th></tr>"
+        )
         rows = [_cost_row(i, entry) for i, entry in enumerate(sorted_entries)]
-        subtitle = "LLM cost estimated via bench_eval.llm_cost. Value = success_rate / total_cost_usd."
+        subtitle = (
+            "LLM cost via bench_eval.llm_cost. Tokens from run totals. "
+            "Model usage splits primary run model vs Ouroboros auxiliary slots (review, fallback, …). "
+            "Value = success_rate / total_cost_usd."
+        )
     else:
         head = "<tr><th>#</th><th>Model</th><th>Harness</th><th>Tasks</th><th>Success %</th></tr>"
         rows = [_success_row(i, entry) for i, entry in enumerate(sorted_entries)]
@@ -296,7 +308,7 @@ def build_table(entries: list[LeaderboardEntry], view_id: str) -> str:
             "See docs/EVAL_README.md."
         )
 
-    body = "".join(rows) if rows else f'<tr><td colspan="6">No results yet. Run export_results.py.</td></tr>'
+    body = "".join(rows) if rows else f'<tr><td colspan="9">No results yet. Run export_results.py.</td></tr>'
     return f"""
     <div class="wab-panel">
       <div class="wab-panel-head">