Merge pull request #22 from abducodez/feat/hall-of-fame-leaderboard

feat: Add Hall of Fame leaderboard backed by a dedicated results table

docs/adr/0035-hall-of-fame-leaderboard.md

@@ -0,0 +1,248 @@
+# ADR-0035: Hall of Fame — Dedicated Scoreboard Table, Detached from the Event Ledger
+
+**Status:** Accepted
+**Date:** 2026-06-14
+
+## Context
+
+Every competitive run now crowns a winner ([ADR-0029](0029-structured-verdicts.md),
+[ADR-0030](0030-arena-scenarios-and-offline-winners.md)). What was missing was a
+place to *remember*. Without a leaderboard the question "which model wins Debate Duel
+the most?" has no answer — wins happen, are faithfully recorded on the ledger, and
+then vanish from view the moment the next run starts.
+
+The original design (the initial version of this ADR) proposed the leaderboard as a
+*pure projection over the event stream* — a read-only fold with no new storage. That
+approach was replaced, at the operator's explicit request, with the dedicated-table
+design described here. The core trade-off: pure projections are elegant and
+philosophically clean, but at page-load time they must fold the *entire* events log
+— every utterance, thought, and verdict in every run — just to count wins. As the
+ledger grows, that becomes an O(all-events) query on every Hall of Fame tab refresh.
+A dedicated scoreboard table turns that into a cheap `SELECT` over a small,
+already-decided set of rows.
+
+Four constraints shaped the final design:
+
+1. **One row per decided run, written once, at finish.** The scoreboard is not a live
+   aggregate; it is a durable receipt. Writing at finalization time, under an explicit
+   eligibility gate, keeps the table small and its rows trustworthy.
+2. **Detached from the event ledger, linked by `run_id`.** The `events` table stays
+   the source of truth for *what happened* in a run (the full trace — every utterance,
+   thought, verdict, and poke). The `leaderboard_entries` table is a separate,
+   denormalised record of *who won*. They share a database instance (the same
+   `DATABASE_URL` / Postgres instance) but never share rows. The `run_id` foreign key
+   on every leaderboard entry links back to the full trace for replay — so the
+   separation is clean without being lossy.
+3. **An explicit write gate.** A row is recorded only when the run is FINISHED, has a
+   WINNER, carries at least one concrete WINNING MODEL endpoint, and is COMPETITIVE
+   (`competition.kind != "none"`). This gate is the single choke point that keeps
+   the scoreboard honest: abandoned runs, budget closures with no verdict, and
+   exhibition-mode (`kind: none`) sessions never produce a row.
+4. **Fairness is first-class.** Raw win counts mislead when seats are not symmetric.
+   The `LeaderboardEntry` row carries the full competition shape (`kind`, `teams`,
+   `symmetric_seats`), so the fairness rollup in `leaderboard.py` needs no registry
+   lookup and no event replay.
+
+Workstream 6 of the [arena roadmap](../architecture/next-steps/arena-roadmap.md)
+specified the "Hall of Fame" UI tab. This ADR records what shipped.
+
+## Decision
+
+### 1. `src/core/leaderboard_store.py` — the dedicated, durable table
+
+`LeaderboardEntry` (Pydantic v2) is the denormalised scoreboard row — one per decided
+competitive run. It carries:
+
+- `run_id` — links back to `ledger.events_for_run(run_id)` for replay (ADR-0027).
+- `scenario`, `seed`, `cast` (cast→model bindings from the `run.started` stamp,
+  ADR-0030) — everything needed to describe the run without touching the events log.
+- `winner`, `winner_kind`, `winning_model`, `winning_models` — the structured verdict
+  fields from ADR-0029.
+- `competition_kind`, `teams`, `symmetric_seats` — the competition shape from
+  ADR-0030, needed for per-seat fairness rollups.
+- `reason`, `turns`, `tokens`, `started_at`, `finished_at`, `recorded_at`.
+
+`LeaderboardStore` (SQLAlchemy, mirroring `SqlAlchemyLedger`'s lazy-import pattern)
+owns the `leaderboard_entries` table. Its `record()` method is an idempotent upsert
+keyed on `run_id` — delete-then-insert in one transaction, so a verdict that
+supersedes a budget close replaces the row rather than duplicating it. `entries()` and
+`entries_for_scenario()` are the two read paths.
+
+`make_leaderboard_store()` is a memoised factory that resolves the same `DATABASE_URL`
+as `ledger_factory.make_ledger`. No extra configuration is needed: the store is a
+separate table in the same Postgres instance. The in-memory (`sqlite://`) stage demo
+works end-to-end because the factory memoises by URL — the write at `finalize` and the
+Hall of Fame read share the same in-memory engine.
+
+`build_entry(summary, competition)` is the eligibility gate. It accepts a `RunSummary`
+(folded from the run's events by `index_runs`) and the scenario's `CompetitionConfig`.
+It returns `None` — producing no row — unless all four conditions are met: `finished_at`
+is set, `winner` is non-empty, at least one winning model endpoint is non-empty, and
+`competition.kind != "none"`.
+
+### 2. The write path — `FishbowlSession._record_leaderboard()`
+
+The write happens exactly once per run, inside `FishbowlSession.finalize()`, called
+when the run reaches `"verdict"` or `"budget"`:
+
+```python
+def _record_leaderboard(self) -> None:
+    # Folds the run's events into a RunSummary, checks eligibility via build_entry,
+    # and writes one row to leaderboard_entries.  Idempotent.  Fully defensive —
+    # any failure is swallowed so a store hiccup never breaks the show.
+    run_events = self.conductor.ledger.events_for_run(self.conductor.run_id)
+    summary = next((s for s in index_runs(run_events) if s.run_id == ...), None)
+    entry = build_entry(summary, getattr(scenario, "competition", None))
+    if entry is not None:
+        store.record(entry)
+```
+
+The method is fully defensive: any store failure is logged and swallowed. A
+leaderboard write hiccup never breaks a live run.
+
+### 3. `src/core/leaderboard.py` — aggregations over `LeaderboardEntry` rows
+
+The five public aggregation functions take `Sequence[LeaderboardEntry]` (not an event
+stream). They never touch the `events` table.
+
+| Function | Returns | Sort order |
+|---|---|---|
+| `scenario_sessions(entries, scenario_name)` | `list[LeaderboardEntry]` | newest-first by `finished_at`, `run_id` tiebreak |
+| `model_table(entries)` | `list[ModelRow]` | `(-win_rate, -wins, -plays, model)` |
+| `agent_table(entries, scenario_name)` | `list[AgentRow]` | `(-win_rate, -wins, -plays, agent)` |
+| `fairness_table(entries, scenario_name)` | `list[SeatRow]` | `(-win_rate, -wins, -plays, seat_type)` |
+| `headline(entries)` | `str \| None` | single summary sentence |
+
+`headline` considers only symmetric-seat scenarios, requires ≥2 distinct models that
+have each won ≥1 game, picks the scenario with the most decided games, and shortens
+model endpoint slugs to the segment after the last `/`. It returns `None` when the
+table holds no qualifying data — safe at app start.
+
+Attribution rules are identical to the previous pure-projection design: a model earns
+one play per run (endpoint set deduplicated); win credit goes to every endpoint in
+`winning_models ∪ {winning_model}`. `fairness_table` counts only declared seats
+(team members and `symmetric_seats` members); cast members with no seat type (judges,
+narrators) are excluded so they never appear as zero-percent rows.
+
+### 4. "Hall of Fame" Gradio tab in `src/ui/fishbowl/hall_of_fame.py`
+
+The tab calls `make_leaderboard_store().entries()` on render, passes the resulting
+`list[LeaderboardEntry]` to the five aggregation functions, and renders HTML. It never
+touches the event ledger or the live `Conductor`. The per-row **Replay** button calls
+`load_replay(run_id)` from `src/ui/fishbowl/archive.py` (ADR-0027) — the full event
+trace is still in the ledger, accessible via `run_id`, so replay requires no change to
+the transport mechanism.
+
+## Consequences
+
+### Positive
+
+- **Cheap reads.** Hall of Fame renders are a `SELECT * FROM leaderboard_entries`,
+  not an O(all-events) fold of the event log. The table stays small by design: only
+  finished, won, competitive runs produce a row.
+- **Clean separation of trace and scoreboard.** The `events` table is the authoritative
+  record of what every agent said and thought. The `leaderboard_entries` table is the
+  permanent record of who won. Neither needs the other to do its job.
+- **Rebuildable.** The scoreboard is derived from events: every `LeaderboardEntry` can
+  be reconstructed by replaying `events_for_run(run_id)` through `index_runs` and
+  `build_entry`. The table is not a competing source of truth; it is a materialised
+  view that happens to live in a dedicated table. If the table is lost or corrupted, a
+  rebuild script using ADR-0026's `index_runs` can regenerate it.
+- **Idempotent write.** The upsert-on-`run_id` means a corrective re-finalize (a
+  budget close later superseded by a verdict — the ADR-0026 "last-wins" pattern)
+  produces exactly one, current row. No duplicates; no gaps.
+- **Fairness is first-class.** Per-seat win rates are built into the row schema, not
+  bolted on later. The competition shape travels with the result, so no registry lookup
+  is needed at render time.
+- **Replay falls out for free.** `run_id` links every scoreboard row back to its full
+  trace. ADR-0027's `load_replay` / `ReplaySession` already knows how to feed
+  historical events into The Show; the Hall of Fame is just a new call site.
+- **Deterministic tiebreaks.** Every sort ends on a string column (`model`, `agent`,
+  `seat_type`, `run_id`) so table order is reproducible across re-renders.
+
+### Negative / trade-offs
+
+- **A second table can drift from the ledger.** The events log and the scoreboard are
+  separate tables. If a run's events are manually edited or a schema migration changes
+  the `run.finished` payload, the scoreboard row for that run will not update
+  automatically. The `run_id` link and the idempotent upsert mitigate this: a
+  re-finalize call regenerates the row from the current event state, and a rebuild
+  script can do the same in bulk. But the drift risk is real and was not present in a
+  pure-projection design.
+- **Write-time eligibility is a point-in-time decision.** `build_entry` evaluates
+  eligibility at `finalize` time, against the competition config that was loaded into
+  the registry at that moment. A scenario YAML change that retroactively alters
+  `competition.kind` will not affect already-written rows. This is generally the
+  correct behaviour (the row reflects the game that was actually played), but operators
+  should be aware of it.
+- **SQLAlchemy is now required on the write path.** The store's lazy-import pattern
+  (`SQLAlchemy` imported inside `__init__`) keeps the offline/stub path import-clean,
+  but any production `finalize` call on a Postgres deployment requires the driver.
+  This was already true of the `SqlAlchemyLedger` (ADR-0014); this ADR extends that
+  dependency to the write side of the Hall of Fame.
+
+### Neutral
+
+- `headline` returns `None` at startup (no qualifying data). The UI renders a
+  cheerful empty state; nothing is fabricated.
+- Sort order is stable but opinionated: win-rate before raw wins, then plays, then
+  name. A future "sort by column" affordance can override this without changing the
+  aggregations.
+- The store is co-located with the ledger (same `DATABASE_URL`) but is architecturally
+  independent: it could be moved to a separate database by changing the URL passed to
+  `make_leaderboard_store()`.
+
+## Alternatives considered
+
+- **Pure ledger projection (the original design).** The first version of this ADR
+  described five pure functions over `Iterable[Event]` — no new table, no new storage,
+  a perfect fit for ADR-0001's "ledger as source of truth" axiom. This was the
+  correct starting point. It was set aside because the O(all-events) cost per render
+  becomes perceptible as the ledger grows, and because the operator's explicit
+  requirement was a dedicated, durable scoreboard row rather than a live computation.
+  The pure-Python functions in `leaderboard.py` survive as aggregations over the
+  dedicated table's rows, so the computation model is preserved — only the input
+  changed from raw events to pre-decided `LeaderboardEntry` rows.
+
+- **Extend `RunSummary` to carry the competition block.** This would have let a
+  pure-projection leaderboard reuse `index_runs` output cleanly (the original design's
+  main awkwardness). It was deferred rather than rejected: the change is mechanical but
+  touches ADR-0026's public surface. With the dedicated-table design, the competition
+  shape travels on the `LeaderboardEntry` row itself, making this less urgent.
+
+- **SQL aggregate query as the primary path.** Faster at scale than folding Python
+  objects, but adds a backend-specific code path and a `SqlAlchemyLedger`-only
+  dependency into the aggregation module. The dedicated table achieves the same
+  read-performance goal with a simpler interface (fold a small list of Pydantic
+  objects). Revisit if the leaderboard's aggregation logic becomes a bottleneck.
+
+- **Elo instead of win rate.** More statistically meaningful once session counts
+  grow, but requires at least ~30 decided games per model pair to be trustworthy.
+  Raw win rate is honest at small N and does not mislead when shown alongside the
+  play count. Elo is noted in the arena roadmap's "Beyond" section.
+
+## References
+
+- [ADR-0001](0001-event-ledger.md) — event ledger as the single source of truth for
+  *the trace*. The scoreboard is a derived, rebuildable materialisation keyed by
+  `run_id`, not a competing source of truth.
+- [ADR-0014](0014-postgres-event-store.md) — durable Postgres store behind the ledger
+  interface; the `DATABASE_URL` the leaderboard store shares.
+- [ADR-0026](0026-run-lifecycle-and-history.md) — run lifecycle; `run.started` /
+  `run.finished`; `RunSummary`; `index_runs` — the fold `build_entry` calls.
+- [ADR-0027](0027-per-user-sessions-and-archive-replay.md) — `ReplaySession` and
+  `load_replay`; the replay transport the Hall of Fame Replay button reuses via `run_id`.
+- [ADR-0029](0029-structured-verdicts.md) — structured `winner` / `winner_kind` /
+  `winning_models` on `run.finished`; the source of the scoreboard's attribution fields.
+- [ADR-0030](0030-arena-scenarios-and-offline-winners.md) — `competition` block
+  stamped on `run.started`; `symmetric_seats`; the eight arena-grade scenarios. The
+  competition shape travels onto every `LeaderboardEntry` row.
+- `src/core/leaderboard_store.py` — `LeaderboardEntry`, `LeaderboardStore`,
+  `build_entry`, `make_leaderboard_store`.
+- `src/core/leaderboard.py` — the five aggregation functions over `LeaderboardEntry`
+  rows.
+- `src/ui/fishbowl/session.py` — `FishbowlSession._record_leaderboard()`, the write
+  path.
+- `src/ui/fishbowl/hall_of_fame.py` — the Gradio tab.
+- [arena roadmap § Workstream 6](../architecture/next-steps/arena-roadmap.md) — the
+  original specification these projections realise.

docs/architecture/fishbowl-ui.md

@@ -38,11 +38,11 @@ app.py (repo root)         thin shim → from src.ui.fishbowl.app import demo
 The dependency arrow is one-way: `src/ui/fishbowl/` reads the engine's public surface;
 **the engine never imports the UI** (test-enforced by `tests/test_modularity.py`).
 
-## The two tabs
+## The three tabs
 
-Fishbowl is a `gr.Blocks` with a top bar and a `gr.Tabs` holding **The Lab** and
-**The Show**. A per-session `gr.State` carries the live `FishbowlSession` and the
-play-head, so concurrent visitors never share a world.
+Fishbowl is a `gr.Blocks` with a top bar and a `gr.Tabs` holding **The Lab**,
+**The Show**, and **Hall of Fame**. A per-session `gr.State` carries the live
+`FishbowlSession` and the play-head, so concurrent visitors never share a world.
 
 ### The Lab — compose a run
 
@@ -73,6 +73,37 @@ Split); a **"Read their minds" `gr.Checkbox`**; a transport (scrubber `gr.Slider
 disturbances. `build_show` returns component handles only — every callback is wired in
 `app.py`.
 
+### Hall of Fame — the permanent record
+
+`hall_of_fame.py` (`build_hall_of_fame`) is a read-only tab backed by the dedicated
+`leaderboard_entries` table ([ADR-0035](../adr/0035-hall-of-fame-leaderboard.md)).
+On each render it calls `make_leaderboard_store().entries()` to fetch the rows, then
+passes them to the five aggregation functions in `src/core/leaderboard.py`. It never
+reads the event ledger and never touches the live `Conductor` or the session state.
+The `events` log stays the trace; this table is the scoreboard — linked back via
+`run_id` for replay, not duplicated.
+
+- **Scenario picker** (`gr.Dropdown`) filters all tables to one scenario. The "All
+  scenarios" view is the model leaderboard's default — the cross-scenario headline.
+- **Sessions table** (`gr.Dataframe` of `SessionRow`) lists every finished competitive
+  run: date, cast summary, winner, winning model endpoint, turns, tokens, and end
+  reason. Newest first.
+- **Replay button** — each row carries a run id; clicking it calls `load_replay` from
+  `src/ui/fishbowl/archive.py` (ADR-0027) and hands the `ReplaySession` to The Show.
+  No new transport mechanism; replay is the same path the Archive drawer uses.
+- **Model leaderboard** (`gr.Dataframe` of `ModelRow`) — plays, wins, win rate, and
+  scenarios per model endpoint. This is the headline demo artifact: a single ledger
+  fold turns "MiniCPM-8B has beaten Gemma-12B 7–3 at Debate Duel" into a table cell.
+- **Agent / fairness tables** (`gr.Dataframe` of `AgentRow` and `SeatRow`) — per-seat
+  win rates for the selected scenario. Judges and other non-seat cast members are
+  excluded from `SeatRow` counts so the asymmetry is honest, not hidden.
+- **Headline** — the `headline()` projection renders a single prose sentence above the
+  tables when the ledger holds ≥1 symmetric-seat scenario with ≥2 models having won.
+  Returns `None` at app start (no runs yet) and renders nothing; the UI handles both.
+
+The Hall of Fame refreshes on tab focus, not on a timer. It holds no derived state —
+every render is a fresh projection fold.
+
 ## The render loop — `gr.HTML` + `gr.Timer`
 
 The Show does not stream component diffs; it **re-renders one `gr.HTML` block** each
@@ -265,3 +296,6 @@ stays green by construction.
 - [observer-pattern.md](observer-pattern.md) — the decoupled-rendering contract this
   realizes.
 - [ADR-0002](../adr/0002-gradio-first.md) — chose Gradio and anticipated this migration.
+- [ADR-0035](../adr/0035-hall-of-fame-leaderboard.md) — Hall of Fame: dedicated
+  `leaderboard_entries` table detached from the event ledger; the five aggregation
+  functions in `leaderboard.py` and the replay reuse via `run_id`.

docs/architecture/next-steps/arena-roadmap.md

@@ -257,8 +257,16 @@ here.
 
 ## Workstream 6 — Hall of Fame (leaderboard)
 
-Pure projection over the ledger — no new storage, fits ADR-0001 exactly.
-Requires W1 (run lifecycle) + W2 (structured winner).
+> ✅ *Shipped — 2026-06-14.* The dedicated `leaderboard_entries` table, the five
+> aggregation functions, and the Gradio tab are live.
+> See [ADR-0035](../../adr/0035-hall-of-fame-leaderboard.md) for the as-built record.
+> The plan below is preserved as the original spec.
+
+Dedicated detached table — not a pure projection. A separate `leaderboard_entries`
+table (same Postgres instance as the event ledger, never sharing rows with `events`)
+stores one denormalised result row per decided competitive run. The Hall of Fame reads
+this small table directly; the `events` log stays the trace. `run_id` on every row
+links back to the full trace for replay. Requires W1 (run lifecycle) + W2 (structured winner).
 
 ### 6.1 `src/core/leaderboard.py` — pure functions
 

src/core/leaderboard.py

@@ -0,0 +1,372 @@
+"""Leaderboard — competitive-results aggregations over the dedicated scoreboard table.
+
+This module is the *read model* of the Hall of Fame.  It is deliberately **detached from
+the event ledger**: it folds a list of :class:`~src.core.leaderboard_store.LeaderboardEntry`
+rows — the materialised scoreboard persisted in the ``leaderboard_entries`` table — into
+the model / agent / fairness tables the UI renders.  It never touches the ``events`` log.
+
+The split, in one line: :mod:`src.core.leaderboard_store` owns *persistence* (one durable
+row per decided run, written at finish), and this module owns *aggregation* (cheap folds
+over those rows).  Because a row is only ever written for a finished, won, competitive run
+(see ``build_entry`` and ``FishbowlSession.finalize``), the functions here can trust every
+entry they receive is already "ranked" — they re-check ``winner`` only defensively.
+
+Each entry is self-describing: it carries the cast→model bindings *and* the competition
+shape (``competition_kind`` / ``teams`` / ``symmetric_seats``), so the per-seat fairness
+rollup needs no registry lookup and no event replay.
+
+Schema is additive only; ``schema_version`` is unaffected (this reads a separate table).
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from datetime import datetime
+from typing import Iterable, Sequence
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from src.core.leaderboard_store import LeaderboardEntry
+
+
+# ── competition shape (built per entry for seat mapping) ─────────────────────────
+
+
+class CompetitionBlock(BaseModel):
+    """The competition shape of one run (built from a :class:`LeaderboardEntry`).
+
+    ``kind`` is ``"versus"`` / ``"judged"`` / ``"none"``; ``teams`` (versus only) maps a
+    team label → member agent names; ``symmetric_seats`` (versus only) lists identical
+    seats that differ only by model.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    kind: str = "none"
+    teams: dict[str, list[str]] | None = None
+    symmetric_seats: list[str] | None = None
+
+
+def _block(entry: LeaderboardEntry) -> CompetitionBlock:
+    """The competition shape carried by *entry* (no registry / ledger lookup)."""
+    return CompetitionBlock(
+        kind=entry.competition_kind,
+        teams=entry.teams,
+        symmetric_seats=entry.symmetric_seats,
+    )
+
+
+# ── row models ─────────────────────────────────────────────────────────────────
+
+
+class ModelRow(BaseModel):
+    """A model endpoint's record across *all* competitive decided runs."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    model: str
+    plays: int = 0
+    """Decided competitive runs whose cast contained this endpoint."""
+    wins: int = 0
+    """Of those, how many this endpoint was credited with winning."""
+    win_rate: float = 0.0
+    """``wins / plays`` (0.0 when ``plays == 0``)."""
+    scenarios: list[str] = Field(default_factory=list)
+    """Sorted distinct scenario names this endpoint appeared in."""
+
+
+class AgentRow(BaseModel):
+    """A persona's (cast seat *name*) record within a single scenario."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    agent: str
+    """The cast member name — the seat, not the model."""
+    seat_type: str = ""
+    """Team label, symmetric-seat name, or ``""`` when the seat maps to neither."""
+    plays: int = 0
+    wins: int = 0
+    win_rate: float = 0.0
+    model_endpoints: list[str] = Field(default_factory=list)
+    """Sorted distinct model endpoints that filled this seat."""
+
+
+class SeatRow(BaseModel):
+    """Win rate per *seat type* within a scenario (the 6.3 fairness footnote).
+
+    Surfaces structural asymmetry: spy vs herd, debater-a vs debater-b, the judge that
+    never wins.  ``seat_type`` is a team label (versus-teams) or a symmetric-seat name.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    seat_type: str
+    plays: int = 0
+    wins: int = 0
+    win_rate: float = 0.0
+
+
+# ── internal helpers ───────────────────────────────────────────────────────────
+
+
+def _win_rate(wins: int, plays: int) -> float:
+    """``wins / plays``, or ``0.0`` when *plays* is zero (never divide by zero)."""
+    return (wins / plays) if plays else 0.0
+
+
+def _ranked(entries: Iterable[LeaderboardEntry]) -> list[LeaderboardEntry]:
+    """Defensive gate: keep only entries that actually name a winner.
+
+    The store only ever persists finished + won + competitive runs, so this is belt-and-
+    suspenders — it drops any malformed/empty row rather than crediting a phantom win.
+    """
+    return [e for e in entries if e and e.winner]
+
+
+def _seat_type_for(agent: str, block: CompetitionBlock) -> str:
+    """Map a cast member *name* to its seat type within *block*.
+
+    For ``versus`` teams the seat type is the team label the agent belongs to.  For
+    ``symmetric_seats`` each named seat is its own type (the agent name == the seat).  A
+    cast member that belongs to neither (e.g. a judge, a narrator) maps to ``""``.
+    """
+    if block.teams:
+        for label, members in block.teams.items():
+            if agent in (members or []):
+                return label
+    if block.symmetric_seats and agent in block.symmetric_seats:
+        return agent
+    return ""
+
+
+def _winning_seat_types(entry: LeaderboardEntry, block: CompetitionBlock) -> set[str]:
+    """The seat type(s) credited with the win for fairness accounting."""
+    winner = entry.winner or ""
+    if not winner:
+        return set()
+    if block.teams and winner in block.teams:
+        return {winner}
+    seat = _seat_type_for(winner, block)
+    return {seat} if seat else set()
+
+
+def _winning_agents(entry: LeaderboardEntry, block: CompetitionBlock) -> set[str]:
+    """Cast member name(s) credited with the win, for per-seat accounting.
+
+    A ``team`` winner credits every member of the winning team; an ``agent`` winner
+    (judged pick / symmetric-seat winner) credits just that name.  Falls back to treating
+    ``winner`` as a bare agent name when ``winner_kind`` is absent.
+    """
+    winner = entry.winner or ""
+    if not winner:
+        return set()
+    if entry.winner_kind == "team" or (block.teams and winner in block.teams):
+        return set((block.teams or {}).get(winner) or [])
+    return {winner}
+
+
+def _credited_models(entry: LeaderboardEntry) -> set[str]:
+    """The model endpoint(s) credited with this run's win (``winning_models`` ∪ single)."""
+    credited = {m for m in entry.winning_models if m}
+    if entry.winning_model:
+        credited.add(entry.winning_model)
+    return credited
+
+
+# ── public aggregations (fold the scoreboard rows) ───────────────────────────────
+
+
+def scenario_sessions(entries: Sequence[LeaderboardEntry], scenario_name: str) -> list[LeaderboardEntry]:
+    """The decided sessions of *scenario_name*, newest first.
+
+    A thin filter + deterministic sort over the stored rows: by ``finished_at``
+    descending (newest first), runs missing a finish time sorted last, ``run_id`` breaking
+    ties.  Returns the :class:`LeaderboardEntry` rows themselves — they already carry the
+    winner, cast→model bindings and cost the sessions table renders.
+    """
+    rows = [e for e in _ranked(entries) if e.scenario == scenario_name]
+    rows.sort(key=lambda e: (e.finished_at is None, _neg_ts(e.finished_at), e.run_id))
+    return rows
+
+
+def model_table(entries: Sequence[LeaderboardEntry]) -> list[ModelRow]:
+    """One :class:`ModelRow` per model endpoint across *all* decided competitive runs.
+
+    A model *plays* a run when its endpoint appears in that run's cast; it *wins* when its
+    endpoint is among the run's credited winners (``winning_models`` / ``winning_model``).
+    ``scenarios`` lists the distinct scenario names the model appeared in (sorted).  Sorted
+    by ``win_rate`` desc, then ``wins`` desc, then ``plays`` desc, then ``model`` asc.
+    """
+    plays: dict[str, int] = defaultdict(int)
+    wins: dict[str, int] = defaultdict(int)
+    scenarios: dict[str, set[str]] = defaultdict(set)
+    for entry in _ranked(entries):
+        credited = _credited_models(entry)
+        seen: set[str] = set()
+        for binding in entry.cast.values():
+            endpoint = binding.model_endpoint
+            if not endpoint or endpoint in seen:
+                continue  # one play per endpoint per run, even if it fills two seats
+            seen.add(endpoint)
+            plays[endpoint] += 1
+            scenarios[endpoint].add(entry.scenario)
+            if endpoint in credited:
+                wins[endpoint] += 1
+    rows = [
+        ModelRow(
+            model=endpoint,
+            plays=plays[endpoint],
+            wins=wins[endpoint],
+            win_rate=_win_rate(wins[endpoint], plays[endpoint]),
+            scenarios=sorted(scenarios[endpoint]),
+        )
+        for endpoint in plays
+    ]
+    rows.sort(key=lambda r: (-r.win_rate, -r.wins, -r.plays, r.model))
+    return rows
+
+
+def agent_table(entries: Sequence[LeaderboardEntry], scenario_name: str) -> list[AgentRow]:
+    """Per-persona (cast seat *name*) wins within *scenario_name*.
+
+    One :class:`AgentRow` per cast member name that appears in a decided run of the
+    scenario.  A seat *plays* a run when its name is in the cast and *wins* when it is the
+    run's winning agent, or a member of the winning team.  ``seat_type`` is the seat's team
+    label / symmetric-seat name (or ``""``); ``model_endpoints`` lists the distinct models
+    that filled the seat.  Deterministic sort matching :func:`model_table`.
+    """
+    plays: dict[str, int] = defaultdict(int)
+    wins: dict[str, int] = defaultdict(int)
+    seat_types: dict[str, str] = {}
+    endpoints: dict[str, set[str]] = defaultdict(set)
+    for entry in _ranked(entries):
+        if entry.scenario != scenario_name:
+            continue
+        block = _block(entry)
+        winners = _winning_agents(entry, block)
+        for name, binding in entry.cast.items():
+            plays[name] += 1
+            seat_types.setdefault(name, _seat_type_for(name, block))
+            if binding.model_endpoint:
+                endpoints[name].add(binding.model_endpoint)
+            if name in winners:
+                wins[name] += 1
+    rows = [
+        AgentRow(
+            agent=name,
+            seat_type=seat_types.get(name, ""),
+            plays=plays[name],
+            wins=wins[name],
+            win_rate=_win_rate(wins[name], plays[name]),
+            model_endpoints=sorted(endpoints[name]),
+        )
+        for name in plays
+    ]
+    rows.sort(key=lambda r: (-r.win_rate, -r.wins, -r.plays, r.agent))
+    return rows
+
+
+def fairness_table(entries: Sequence[LeaderboardEntry], scenario_name: str) -> list[SeatRow]:
+    """Win rate per *seat type* within *scenario_name* — the 6.3 fairness footnote.
+
+    Aggregates the per-persona view up to seat types so structural asymmetry is visible:
+    spy vs herd, debater-a vs debater-b, a judge that never wins.  Seat membership comes
+    from each entry's stored competition shape (``teams`` → label per member;
+    ``symmetric_seats`` → each seat its own type).  A run contributes one *play* to each
+    seat type present in its cast, and one *win* to whichever seat type the winner maps to.
+    Unmapped cast members (``seat_type == ""``) are not counted — only declared seats
+    appear.  Sorted by ``win_rate`` desc, ``wins`` desc, ``plays`` desc, ``seat_type`` asc.
+    """
+    plays: dict[str, int] = defaultdict(int)
+    wins: dict[str, int] = defaultdict(int)
+    for entry in _ranked(entries):
+        if entry.scenario != scenario_name:
+            continue
+        block = _block(entry)
+        seats_present = {st for st in (_seat_type_for(n, block) for n in entry.cast) if st}
+        for seat in seats_present:
+            plays[seat] += 1
+        for seat in _winning_seat_types(entry, block):
+            if seat in seats_present:
+                wins[seat] += 1
+    rows = [
+        SeatRow(
+            seat_type=seat,
+            plays=plays[seat],
+            wins=wins[seat],
+            win_rate=_win_rate(wins[seat], plays[seat]),
+        )
+        for seat in plays
+    ]
+    rows.sort(key=lambda r: (-r.win_rate, -r.wins, -r.plays, r.seat_type))
+    return rows
+
+
+def headline(entries: Sequence[LeaderboardEntry]) -> str | None:
+    """The killer demo line, or ``None`` when there isn't enough data.
+
+    Looks for the most-played *symmetric-seat* scenario (the "which model argues better"
+    comparison) and, within it, the two models with the most head-to-head wins.  Renders
+    e.g. ``"MiniCPM-8B beats Gemma-12B · 7-3 at Debate Duel"``.  Returns ``None`` when no
+    competitive symmetric scenario has at least two distinct models that have each won at
+    least once (so the line is never a hollow "0-0").
+    """
+    ranked = _ranked(entries)
+    if not ranked:
+        return None
+
+    by_scenario: dict[str, list[LeaderboardEntry]] = defaultdict(list)
+    for entry in ranked:
+        if entry.symmetric_seats:  # the model-vs-model comparison only
+            by_scenario[entry.scenario].append(entry)
+    if not by_scenario:
+        return None
+
+    best_line: str | None = None
+    best_key: tuple[int, int] = (-1, -1)
+    for scenario in sorted(by_scenario):  # ascending scan: ties resolve to the first (alphabetical) name
+        runs = by_scenario[scenario]
+        wins: dict[str, int] = defaultdict(int)
+        plays: dict[str, int] = defaultdict(int)
+        for entry in runs:
+            credited = _credited_models(entry)
+            for endpoint in {b.model_endpoint for b in entry.cast.values() if b.model_endpoint}:
+                plays[endpoint] += 1
+                if endpoint in credited:
+                    wins[endpoint] += 1
+        winners = sorted((m for m in plays if wins[m] > 0), key=lambda m: (-wins[m], -plays[m], m))
+        if len(winners) < 2:
+            continue
+        top, runner = winners[0], winners[1]
+        decided = wins[top] + wins[runner]
+        candidate_key = (decided, wins[top])
+        if candidate_key > best_key:  # strict: a full tie keeps the earlier (alphabetical) scenario
+            best_key = candidate_key
+            best_line = f"{_short(top)} beats {_short(runner)} · {wins[top]}-{wins[runner]} at {scenario}"
+    return best_line
+
+
+# ── tiny formatting helpers ─────────────────────────────────────────────────────
+
+
+def _neg_ts(value: datetime | None) -> float:
+    """Negated POSIX timestamp for descending sort; ``0.0`` for ``None`` (sorted last)."""
+    return -value.timestamp() if value is not None else 0.0
+
+
+def _short(endpoint: str) -> str:
+    """Compact a model endpoint for the headline (``"openai/openbmb/X"`` → ``"X"``)."""
+    return endpoint.rsplit("/", 1)[-1] if endpoint else endpoint
+
+
+__all__ = [
+    "AgentRow",
+    "CompetitionBlock",
+    "ModelRow",
+    "SeatRow",
+    "agent_table",
+    "fairness_table",
+    "headline",
+    "model_table",
+    "scenario_sessions",
+]

src/core/leaderboard_store.py

@@ -0,0 +1,380 @@
+"""Leaderboard store — a dedicated, durable table for competitive run results.
+
+Unlike :mod:`src.core.leaderboard` (which *aggregates* results), this module owns the
+**persistence** of one row per decided competitive run.  It is deliberately **detached
+from the event ledger**: the append-only ``events`` table stays the source of truth for
+*what happened* in a run (every utterance, thought, verdict — the full logs), while this
+``leaderboard_entries`` table is a separate, denormalised record of *who won* — a
+materialised scoreboard the Hall of Fame reads without ever folding the event log.
+
+Why a separate table (not a pure projection)
+---------------------------------------------
+A run's result is written **once**, at finish, only when it is genuinely decided — so the
+Hall of Fame is a cheap ``SELECT`` over a small table rather than an O(all-events) fold of
+the whole ledger on every page load.  The two tables share one database (the same
+``DATABASE_URL`` / Postgres instance) but never share rows: ``events`` is the trace,
+``leaderboard_entries`` is the scoreboard.  The ``run_id`` on each entry links a row back
+to its full trace (``ledger.events_for_run(run_id)``) for replay.
+
+The write gate (the operator's explicit requirement)
+----------------------------------------------------
+A row is recorded **only if** the run is finished AND a winner with a concrete winning
+model is selected.  Unfinished runs, abandoned runs (a budget close with no verdict), and
+runs whose winner has no bound model endpoint never produce a row — see
+:func:`build_entry` and the call site in ``FishbowlSession.finalize``.
+
+SQLAlchemy is imported lazily inside ``LeaderboardStore.__init__`` so importing this
+module — and therefore ``src.core.*`` — never requires SQLAlchemy or a DB driver.  The
+:class:`LeaderboardEntry` Pydantic model is import-clean and is reused by both the store
+(persistence) and :mod:`src.core.leaderboard` (aggregation).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from src.core.run_index import CastBinding, RunSummary
+
+if TYPE_CHECKING:  # types only — never imported at runtime on the offline path
+    from sqlalchemy import Engine, MetaData, Table
+
+    from src.scenarios.base import CompetitionConfig
+
+
+# ── the row model (shared by the store and the aggregations) ─────────────────────
+
+
+class LeaderboardEntry(BaseModel):
+    """One decided competitive run — the durable scoreboard row.
+
+    Carries everything the Hall of Fame needs without touching the event ledger: the
+    cast→model bindings, the winner and the model(s) behind it, the competition shape
+    (``kind`` / ``teams`` / ``symmetric_seats`` — needed for per-seat fairness), and the
+    run's cost/timing.  ``run_id`` links the row back to its full trace for replay.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    run_id: str
+    session_id: str | None = None
+    scenario: str = ""
+    seed: str = ""
+
+    # Competition shape (mirrors CompetitionConfig — needed for seat/fairness rollups).
+    competition_kind: str = "none"
+    teams: dict[str, list[str]] | None = None
+    symmetric_seats: list[str] | None = None
+
+    cast: dict[str, CastBinding] = Field(default_factory=dict)
+
+    winner: str | None = None
+    winner_kind: str | None = None
+    winning_model: str | None = None
+    winning_models: list[str] = Field(default_factory=list)
+
+    reason: str | None = None
+    turns: int = 0
+    tokens: int = 0
+
+    started_at: datetime | None = None
+    finished_at: datetime | None = None
+    recorded_at: datetime | None = None
+    """When this scoreboard row was written (insert time)."""
+
+
+def build_entry(summary: RunSummary, competition: "CompetitionConfig | None") -> LeaderboardEntry | None:
+    """Build a :class:`LeaderboardEntry` from a finished run, or ``None`` if not eligible.
+
+    The single eligibility gate (the operator's requirement): the run must be **finished**
+    (``finished_at`` set), have a **winner**, carry at least one **winning model**, and be
+    **competitive** (``competition.kind != "none"``).  Returns ``None`` otherwise, so the
+    caller simply doesn't record a row.
+
+    ``summary`` is the :class:`~src.core.run_index.RunSummary` folded from the run's events
+    (it already resolves winner / winner_kind / winning_model(s) / cast / turns / tokens);
+    ``competition`` is the scenario's config (for the seat/team shape).  This function adds
+    no new attribution — it only decides eligibility and copies the fields across.
+    """
+    kind = getattr(competition, "kind", "none") or "none"
+    winning_models = [m for m in (summary.winning_models or []) if m]
+    if summary.winning_model and summary.winning_model not in winning_models:
+        winning_models.append(summary.winning_model)
+
+    finished = summary.finished_at is not None
+    if not finished or not summary.winner or not winning_models or kind == "none":
+        return None
+
+    return LeaderboardEntry(
+        run_id=summary.run_id,
+        session_id=summary.session_id,
+        scenario=summary.scenario,
+        seed=summary.seed,
+        competition_kind=kind,
+        teams=getattr(competition, "teams", None),
+        symmetric_seats=getattr(competition, "symmetric_seats", None),
+        cast=dict(summary.cast),
+        winner=summary.winner,
+        winner_kind=summary.winner_kind,
+        winning_model=summary.winning_model,
+        winning_models=winning_models,
+        reason=summary.reason,
+        turns=summary.turns,
+        tokens=summary.tokens,
+        started_at=summary.started_at,
+        finished_at=summary.finished_at,
+    )
+
+
+# ── the durable store (mirrors SqlAlchemyLedger's lazy-SQLAlchemy pattern) ────────
+
+
+def _normalise_url(url: str | Path) -> str:
+    """Accept a SQLAlchemy URL or a bare filesystem path (mirrors the ledger)."""
+    text = str(url)
+    if "://" in text:
+        return text
+    if text == ":memory:":
+        return "sqlite://"
+    return f"sqlite:///{text}"
+
+
+class LeaderboardStore:
+    """Durable store for :class:`LeaderboardEntry` rows in a dedicated table.
+
+    Backed by SQLAlchemy (Postgres or SQLite), exactly like ``SqlAlchemyLedger`` — but it
+    owns the ``leaderboard_entries`` table, never ``events``.  ``record`` is an idempotent
+    upsert keyed on ``run_id`` (a re-finalised run — e.g. a budget close later superseded
+    by a verdict — replaces its row rather than duplicating it).
+    """
+
+    def __init__(self, url: str | Path = ":memory:") -> None:
+        # Lazy import: keeps src.core.* importable without SQLAlchemy installed.
+        from sqlalchemy import (
+            Column,
+            DateTime,
+            Integer,
+            MetaData,
+            String,
+            Table,
+            Text,
+            create_engine,
+        )
+
+        self._url = _normalise_url(url)
+        self._engine: Engine = create_engine(self._url, pool_pre_ping=True)
+        self._metadata: MetaData = MetaData()
+        self._table: Table = Table(
+            "leaderboard_entries",
+            self._metadata,
+            Column("offset", Integer, primary_key=True, autoincrement=True),
+            Column("run_id", String(64), unique=True, nullable=False, index=True),
+            Column("session_id", String, nullable=True, index=True),
+            Column("scenario", String, nullable=False, index=True),
+            Column("seed", String, nullable=False, server_default=""),
+            Column("competition_kind", String, nullable=False, server_default="none"),
+            Column("teams", Text, nullable=True),
+            Column("symmetric_seats", Text, nullable=True),
+            Column("cast", Text, nullable=False, server_default="{}"),
+            Column("winner", String, nullable=True),
+            Column("winner_kind", String, nullable=True),
+            Column("winning_model", String, nullable=True),
+            Column("winning_models", Text, nullable=False, server_default="[]"),
+            Column("reason", String, nullable=True),
+            Column("turns", Integer, nullable=False, server_default="0"),
+            Column("tokens", Integer, nullable=False, server_default="0"),
+            Column("started_at", DateTime(timezone=True), nullable=True),
+            Column("finished_at", DateTime(timezone=True), nullable=True),
+            Column("recorded_at", DateTime(timezone=True), nullable=False),
+        )
+        self._metadata.create_all(self._engine)
+
+    # ── write ──────────────────────────────────────────────────────────────────
+
+    def record(self, entry: LeaderboardEntry) -> LeaderboardEntry:
+        """Persist *entry*, upserting on ``run_id`` (idempotent — never duplicates a run).
+
+        Stamps ``recorded_at`` if unset.  A pre-existing row for the same ``run_id`` is
+        replaced (delete-then-insert in one transaction), so a corrective re-finalise
+        keeps exactly one, current scoreboard row per run.
+        """
+        recorded = entry.model_copy(update={"recorded_at": entry.recorded_at or datetime.now(timezone.utc)})
+        values = self._to_row(recorded)
+        with self._engine.begin() as conn:
+            conn.execute(self._table.delete().where(self._table.c.run_id == recorded.run_id))
+            conn.execute(self._table.insert().values(**values))
+        return recorded
+
+    # ── read ───────────────────────────────────────────────────────────────────
+
+    def entries(self) -> list[LeaderboardEntry]:
+        """Every recorded entry, newest finish first (``run_id`` breaks ties)."""
+        from sqlalchemy import select
+
+        t = self._table
+        stmt = select(t).order_by(t.c.offset)
+        with self._engine.connect() as conn:
+            rows = conn.execute(stmt).mappings().all()
+        out = [self._row_to_entry(row) for row in rows]
+        out.sort(key=lambda e: (e.finished_at is None, _neg_ts(e.finished_at), e.run_id))
+        return out
+
+    def entries_for_scenario(self, scenario: str) -> list[LeaderboardEntry]:
+        """The recorded entries for one scenario (indexed query), newest finish first."""
+        from sqlalchemy import select
+
+        t = self._table
+        stmt = select(t).where(t.c.scenario == scenario).order_by(t.c.offset)
+        with self._engine.connect() as conn:
+            rows = conn.execute(stmt).mappings().all()
+        out = [self._row_to_entry(row) for row in rows]
+        out.sort(key=lambda e: (e.finished_at is None, _neg_ts(e.finished_at), e.run_id))
+        return out
+
+    def close(self) -> None:
+        self._engine.dispose()
+
+    # ── internal (de)serialisation ───────────────────────────────────────────────
+
+    @staticmethod
+    def _to_row(entry: LeaderboardEntry) -> dict[str, Any]:
+        return {
+            "run_id": entry.run_id,
+            "session_id": entry.session_id,
+            "scenario": entry.scenario,
+            "seed": entry.seed,
+            "competition_kind": entry.competition_kind,
+            "teams": json.dumps(entry.teams) if entry.teams is not None else None,
+            "symmetric_seats": (json.dumps(entry.symmetric_seats) if entry.symmetric_seats is not None else None),
+            "cast": json.dumps({name: binding.model_dump() for name, binding in entry.cast.items()}),
+            "winner": entry.winner,
+            "winner_kind": entry.winner_kind,
+            "winning_model": entry.winning_model,
+            "winning_models": json.dumps(list(entry.winning_models)),
+            "reason": entry.reason,
+            "turns": int(entry.turns),
+            "tokens": int(entry.tokens),
+            "started_at": _aware(entry.started_at),
+            "finished_at": _aware(entry.finished_at),
+            "recorded_at": _aware(entry.recorded_at) or datetime.now(timezone.utc),
+        }
+
+    @staticmethod
+    def _row_to_entry(row: Any) -> LeaderboardEntry:
+        cast_raw = _loads(row["cast"], {})
+        cast = {name: CastBinding(**(binding or {})) for name, binding in cast_raw.items()}
+        return LeaderboardEntry(
+            run_id=row["run_id"],
+            session_id=row.get("session_id"),
+            scenario=row["scenario"],
+            seed=row["seed"] or "",
+            competition_kind=row["competition_kind"] or "none",
+            teams=_loads(row.get("teams"), None),
+            symmetric_seats=_loads(row.get("symmetric_seats"), None),
+            cast=cast,
+            winner=row.get("winner"),
+            winner_kind=row.get("winner_kind"),
+            winning_model=row.get("winning_model"),
+            winning_models=_loads(row.get("winning_models"), []) or [],
+            reason=row.get("reason"),
+            turns=row["turns"] or 0,
+            tokens=row["tokens"] or 0,
+            started_at=_aware(_parse_dt(row.get("started_at"))),
+            finished_at=_aware(_parse_dt(row.get("finished_at"))),
+            recorded_at=_aware(_parse_dt(row.get("recorded_at"))),
+        )
+
+
+# ── factory (mirrors src.core.ledger_factory — same DATABASE_URL, separate table) ─
+
+# Memoise one store per resolved URL.  This is what makes the no-key, in-memory
+# (``sqlite://``) stage demo work end-to-end within a process: the write at finalize and
+# the Hall-of-Fame read share the *same* engine (a fresh in-memory engine would be a
+# different, empty database).  For a file/Postgres URL it just avoids re-opening engines.
+_STORES: dict[str, LeaderboardStore] = {}
+
+
+def make_leaderboard_store(url: str | None = None) -> LeaderboardStore:
+    """Construct (or reuse) the leaderboard store for the configured database.
+
+    Resolves the same ``DATABASE_URL`` as the event ledger (a separate *table* in the
+    same database), so no extra configuration is needed.  *url* overrides it (tests pass
+    ``"sqlite://"``).  Raises :class:`RuntimeError` when neither is set — like the ledger,
+    the durable store is not optional.
+    """
+    resolved = url or os.getenv("DATABASE_URL")
+    if not resolved:
+        raise RuntimeError(
+            "DATABASE_URL is required for the leaderboard store — it lives in the same "
+            "database as the event ledger (a separate table), so set DATABASE_URL or pass "
+            "an explicit url to make_leaderboard_store()."
+        )
+    from src.core.ledger_factory import _normalize_db_url
+
+    key = _normalize_db_url(resolved)
+    store = _STORES.get(key)
+    if store is None:
+        store = LeaderboardStore(key)
+        _STORES[key] = store
+    return store
+
+
+def _reset_store_cache() -> None:
+    """Drop memoised stores (test hook — production never needs this)."""
+    for store in _STORES.values():
+        try:
+            store.close()
+        except Exception:  # pragma: no cover - best-effort cleanup
+            pass
+    _STORES.clear()
+
+
+# ── tiny datetime helpers (mirror the ledger's tz coercion) ──────────────────────
+
+
+def _aware(dt: datetime | None) -> datetime | None:
+    """Coerce a datetime to tz-aware UTC; pass ``None`` through (SQLite drops tzinfo)."""
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def _parse_dt(value: Any) -> datetime | None:
+    if value is None or isinstance(value, datetime):
+        return value
+    try:
+        return datetime.fromisoformat(str(value))
+    except (ValueError, TypeError):  # pragma: no cover - defensive
+        return None
+
+
+def _neg_ts(value: datetime | None) -> float:
+    """Negated POSIX timestamp for descending sort; ``0.0`` for ``None`` (sorted last)."""
+    return -value.timestamp() if value is not None else 0.0
+
+
+def _loads(value: Any, default: Any) -> Any:
+    """JSON-decode a stored text column, tolerating already-decoded values / nulls."""
+    if value is None:
+        return default
+    if isinstance(value, (dict, list)):
+        return value
+    try:
+        return json.loads(value)
+    except (ValueError, TypeError):  # pragma: no cover - defensive
+        return default
+
+
+__all__ = [
+    "LeaderboardEntry",
+    "LeaderboardStore",
+    "build_entry",
+    "make_leaderboard_store",
+]

src/ui/fishbowl/app.py

@@ -49,6 +49,18 @@ except Exception:  # pragma: no cover - degrade gracefully if the archive unit i
         return "▶ (run)"
 
 
+try:  # hall of fame: the competitive high-score board (Workstream 6.2 + 6.3)
+    from src.ui.fishbowl.hall_of_fame import build_hall_of_fame, wire_sessions_render
+except Exception:  # pragma: no cover - degrade gracefully if the unit is absent
+
+    def build_hall_of_fame() -> dict:
+        gr.HTML('<div class="fishbowl"><div class="fishbowl-placeholder">🏆 Hall of Fame — coming soon.</div></div>')
+        return {}
+
+    def wire_sessions_render(*_args, **_kwargs) -> None:
+        return None
+
+
 # ── loop-safety backstop ────────────────────────────────────────────────────────
 # Belt-and-suspenders against a runaway autoplay loop: even when the governor never
 # trips (e.g. a generous budget) the timer halts after this many consecutive auto-ticks
@@ -709,6 +721,8 @@ def build_app() -> gr.Blocks:
                 show_handles = build_show()
             with gr.Tab("Telemetry", id="telemetry"):
                 build_telemetry()
+            with gr.Tab("🏆 Hall of Fame", id="hall"):
+                hall_handles = build_hall_of_fame()
 
         # CRT foreground layers (scanlines + vignette, above content, click-through).
         gr.HTML(_CRT_FG_HTML)
@@ -717,6 +731,23 @@ def build_app() -> gr.Blocks:
         # exists, so it reads the live panes through this ref.
         archive_refs["show_handles"] = show_handles or {}
 
+        # The Hall of Fame's Replay buttons target the Show panes; wire them after all
+        # tabs build (mirrors the Archive's deferred show_handles trick at :644).
+        wire_sessions_render(
+            hall_handles or {},
+            refs=archive_refs,
+            tabs=tabs,
+            states={
+                "session": session_state,
+                "k": k_state,
+                "scenario": scenario_state,
+                "layout": layout_state,
+                "mind": mind_reader_state,
+                "stopped": stopped_state,
+                "ticks": tick_count_state,
+            },
+        )
+
         _wire(
             tabs=tabs,
             lab_handles=lab_handles or {},

src/ui/fishbowl/hall_of_fame.py

@@ -0,0 +1,798 @@
+"""HALL OF FAME — the phosphor-arcade high-score board (Workstream 6.2 + 6.3).
+
+A cheerful, screenshot-worthy scoreboard for the competitive results the engine has
+recorded.  It is a *pure read surface* over the dedicated leaderboard table (ADR-0035):
+every number on the board comes from the aggregations in :mod:`src.core.leaderboard`
+(``headline`` / ``model_table`` / ``scenario_sessions`` / ``fairness_table``), which fold
+the :class:`~src.core.leaderboard_store.LeaderboardEntry` rows persisted in
+``leaderboard_entries`` — a table *detached from the event ledger* (the ``events`` log
+stays the trace; this is the materialised scoreboard).
+
+Design — "Phosphor Arcade High-Score Board"
+-------------------------------------------
+The tab lives inside the existing ``.fishbowl`` CRT-phosphor scope and reuses the
+theme's design tokens, fonts (Martian Mono display, IBM Plex Mono body) and existing
+classes (``eyebrow`` / ``chip`` / ``panel`` / verdict + winner chrome).  Champions glow
+**gold/amber** against the cool teal CRT — that warm/cool contrast is the whole
+identity.  Only two scoped vars are introduced (``--gold`` / ``--gold-soft``) plus the
+Hall-of-Fame layout classes, all under ``.fishbowl.fb-hall``.
+
+Everything here is **offline-safe**: pure HTML strings, an inlined ``<style>`` block,
+no network calls and no external assets.  When the store is empty or unconfigured (the
+deterministic stub path before any competitive run finishes) every pane degrades to a
+cheerful empty state rather than crashing.
+
+The per-row **Replay** button mirrors the Lab's Archive drawer exactly: it turns a run
+into a read-only :class:`~src.ui.fishbowl.session.ReplaySession` via
+:func:`src.ui.fishbowl.archive.load_replay` and pushes it into the Show transport
+through the same ``gr.render`` Load-button contract (see ``build_hall_of_fame``).
+"""
+
+from __future__ import annotations
+
+import html as _html
+from datetime import datetime
+
+import gradio as gr
+
+from src.core.leaderboard import (
+    ModelRow,
+    SeatRow,
+    fairness_table,
+    headline,
+    model_table,
+    scenario_sessions,
+)
+from src.core.leaderboard_store import LeaderboardEntry
+from src.core.registry import default_registry
+
+
+# ── data access (defensive: empty store / no backend → empty projections) ────────
+
+
+def _entries() -> list[LeaderboardEntry]:
+    """Every scoreboard row from the dedicated leaderboard table, or ``[]`` if unavailable.
+
+    Reads the ``leaderboard_entries`` table (ADR-0035) — *detached from the event ledger*
+    — via :func:`make_leaderboard_store`.  Defensive on every axis: a missing/unconfigured
+    store or any read error degrades to an empty list so the board shows its cheerful empty
+    state instead of raising.
+    """
+    try:
+        from src.core.leaderboard_store import make_leaderboard_store
+
+        return list(make_leaderboard_store().entries())
+    except Exception:  # pragma: no cover - no store configured / read error (defensive)
+        return []
+
+
+def competitive_scenarios() -> list[tuple[str, str]]:
+    """``(title, internal_name)`` pairs for scenarios whose ``competition.kind != none``.
+
+    These are the only worlds that can ever crown a champion, so the scenario picker
+    is scoped to them.  Returns ``[]`` when the registry can't be read.
+    """
+    try:
+        registry = default_registry()
+    except Exception:  # pragma: no cover - registry unavailable (defensive)
+        return []
+    out: list[tuple[str, str]] = []
+    for name in sorted(registry.scenarios):
+        cfg = registry.scenarios[name]
+        comp = getattr(cfg, "competition", None)
+        if getattr(comp, "kind", "none") not in ("none", None):
+            out.append(((getattr(cfg, "title", "") or name), name))
+    return out
+
+
+# ── tiny formatting helpers ──────────────────────────────────────────────────────
+
+
+def _esc(text: object) -> str:
+    """HTML-escape any value (defensive — inputs may be ``None`` / non-str)."""
+    return _html.escape(str(text if text is not None else ""))
+
+
+def _short_model(endpoint: str) -> str:
+    """Compact a model endpoint to its last path segment (``a/b/Model`` → ``Model``)."""
+    if not endpoint:
+        return "—"
+    return endpoint.rsplit("/", 1)[-1] or endpoint
+
+
+def _pct(rate: float) -> str:
+    """A win-rate float as a whole-percent label (``0.7`` → ``"70%"``)."""
+    try:
+        return f"{round(rate * 100)}%"
+    except Exception:  # pragma: no cover - non-numeric (defensive)
+        return "0%"
+
+
+def _bar_width(rate: float) -> float:
+    """Clamp a win-rate to a 0–100 bar width."""
+    try:
+        return max(0.0, min(100.0, float(rate) * 100.0))
+    except Exception:  # pragma: no cover - non-numeric (defensive)
+        return 0.0
+
+
+def _short_id(run_id: str) -> str:
+    """A glanceable run handle — last 4 of its uuid (matches the Archive)."""
+    tail = run_id.replace("-", "")[-4:] if run_id else "????"
+    return f"#{tail}"
+
+
+def _fmt_when(value: datetime | None) -> str:
+    """A compact ``Jun 12 · 14:03`` timestamp, ``—`` when missing."""
+    if not isinstance(value, datetime):
+        return "—"
+    try:
+        return value.strftime("%b %-d · %H:%M")
+    except ValueError:  # pragma: no cover - platforms without %-d
+        return value.strftime("%b %d · %H:%M")
+
+
+def _fmt_tokens(tokens: int) -> str:
+    try:
+        tokens = int(tokens)
+    except Exception:  # pragma: no cover - non-numeric (defensive)
+        return "0"
+    if tokens >= 1000:
+        return f"{tokens / 1000:.1f}k"
+    return str(tokens)
+
+
+_REASON_LABEL = {
+    "verdict": "verdict",
+    "budget": "budget",
+    "tick_cap": "tick-cap",
+    "user_stop": "stopped",
+}
+
+
+def _cast_models(row: LeaderboardEntry) -> str:
+    """A compact roster of the distinct models that played a session."""
+    seen: list[str] = []
+    for binding in (row.cast or {}).values():
+        endpoint = getattr(binding, "model_endpoint", None)
+        if endpoint:
+            short = _short_model(endpoint)
+            if short not in seen:
+                seen.append(short)
+    return ", ".join(seen) if seen else "—"
+
+
+# ── scoped stylesheet (offline; reuses theme tokens, adds only --gold) ────────────
+
+_HALL_STYLE = """
+<style>
+.fishbowl.fb-hall { display:block; }
+.fishbowl.fb-hall {
+  --gold:#ffcf6b;            /* reuse the theme's --amber gold token */
+  --gold-soft:rgba(255,207,107,0.18);
+}
+.fishbowl.fb-hall .hall-wrap { display:flex; flex-direction:column; gap:18px; }
+
+/* Headline marquee — the killer demo line, big and glowing. */
+.fishbowl.fb-hall .hall-headline {
+  position:relative; overflow:hidden;
+  padding:20px 26px; border-radius:16px;
+  border:1px solid rgba(255,207,107,0.42);
+  background:
+    radial-gradient(120% 120% at 50% -20%, var(--gold-soft), transparent 60%),
+    rgba(6,20,27,0.96);
+  box-shadow:0 0 44px rgba(255,207,107,0.22), inset 0 1px 0 rgba(255,207,107,0.12);
+}
+.fishbowl.fb-hall .hall-headline .eyebrow { color:var(--gold); margin-bottom:8px; }
+.fishbowl.fb-hall .hall-line {
+  font-family:var(--font-display); font-weight:800;
+  font-size:clamp(20px, 3vw, 34px); line-height:1.18;
+  color:var(--ink);
+  text-shadow:0 0 18px rgba(255,207,107,0.45);
+}
+.fishbowl.fb-hall .hall-line .hl-gold { color:var(--gold); }
+/* A shimmer sweep across the headline (CSS-only). */
+.fishbowl.fb-hall .hall-headline::after {
+  content:""; position:absolute; inset:0; pointer-events:none;
+  background:linear-gradient(105deg, transparent 30%,
+    rgba(255,207,107,0.16) 48%, transparent 66%);
+  transform:translateX(-120%);
+  animation:hallShimmer 5.5s ease-in-out infinite;
+}
+@keyframes hallShimmer { 0%,55% { transform:translateX(-120%);} 78%,100% { transform:translateX(120%);} }
+
+/* Empty states — cheerful, never a dead screen. */
+.fishbowl.fb-hall .hall-empty {
+  padding:22px 26px; border-radius:14px;
+  border:1px dashed var(--line); background:var(--panel);
+}
+.fishbowl.fb-hall .hall-empty .eyebrow { color:var(--gold); margin-bottom:8px; }
+.fishbowl.fb-hall .hall-empty .he-body { color:var(--ink-mid); line-height:1.55; }
+
+/* Section panels reuse the theme's card chrome. */
+.fishbowl.fb-hall .hall-panel {
+  padding:18px 20px 20px; border-radius:var(--r-lg);
+  border:1px solid var(--line); background:var(--panel);
+  box-shadow:inset 0 1px 0 rgba(120,222,214,0.07), 0 16px 38px -32px rgba(0,0,0,0.9);
+}
+.fishbowl.fb-hall .hall-panel > .eyebrow { margin-bottom:14px; }
+
+/* ── Podium (top 3): gold / silver / bronze phosphor ── */
+.fishbowl.fb-hall .podium {
+  display:grid; grid-template-columns:1fr 1.2fr 1fr; gap:14px; align-items:end;
+  margin-bottom:18px;
+}
+.fishbowl.fb-hall .podium-slot {
+  display:flex; flex-direction:column; align-items:center; gap:8px;
+  padding:16px 12px; border-radius:14px; text-align:center;
+  border:1px solid var(--line); background:rgba(6,20,27,0.7);
+  animation:hallRise 0.5s cubic-bezier(0.2,0.9,0.3,1) both;
+}
+.fishbowl.fb-hall .podium-slot .ps-medal { font-size:30px; line-height:1; }
+.fishbowl.fb-hall .podium-slot .ps-name {
+  font-family:var(--font-display); font-weight:700; font-size:14px; color:var(--ink);
+  word-break:break-word;
+}
+.fishbowl.fb-hall .podium-slot .ps-rate {
+  font-family:var(--font-display); font-weight:800; font-variant-numeric:tabular-nums;
+  font-size:22px;
+}
+.fishbowl.fb-hall .podium-slot .ps-sub { font-size:11px; color:var(--ink-dim); }
+/* #1 — gold, taller, with a soft pulse. */
+.fishbowl.fb-hall .podium-slot.rank-1 {
+  border-color:rgba(255,207,107,0.5);
+  background:radial-gradient(120% 120% at 50% -10%, var(--gold-soft), transparent 60%), rgba(6,20,27,0.92);
+  box-shadow:0 0 40px rgba(255,207,107,0.3); padding-top:26px; animation-delay:0.05s;
+}
+.fishbowl.fb-hall .podium-slot.rank-1 .ps-rate { color:var(--gold); text-shadow:0 0 14px rgba(255,207,107,0.6); }
+.fishbowl.fb-hall .podium-slot.rank-1 .ps-medal { animation:hallChampPulse 2.4s ease-in-out infinite; }
+.fishbowl.fb-hall .podium-slot.rank-2 {
+  border-color:rgba(159,220,210,0.45); animation-delay:0.16s;
+}
+.fishbowl.fb-hall .podium-slot.rank-2 .ps-rate { color:var(--ink-mid); }
+.fishbowl.fb-hall .podium-slot.rank-3 {
+  border-color:rgba(255,143,125,0.4); animation-delay:0.27s;
+}
+.fishbowl.fb-hall .podium-slot.rank-3 .ps-rate { color:var(--coral); }
+
+/* ── Ranked table with glowing win-rate bars ── */
+.fishbowl.fb-hall .hall-table { display:flex; flex-direction:column; gap:2px; }
+.fishbowl.fb-hall .ht-head, .fishbowl.fb-hall .ht-row {
+  display:grid; grid-template-columns:46px 1.6fr 0.7fr 0.7fr 1.5fr; gap:12px;
+  align-items:center; padding:9px 12px; border-radius:var(--r);
+}
+.fishbowl.fb-hall .ht-head {
+  font-family:var(--font-display); font-size:8.5px; letter-spacing:0.2em;
+  text-transform:uppercase; color:var(--ink-faint);
+  border-bottom:1px solid var(--line-soft); border-radius:0;
+}
+.fishbowl.fb-hall .ht-row { animation:hallRise 0.45s ease both; }
+.fishbowl.fb-hall .ht-row:hover { background:var(--glass); }
+.fishbowl.fb-hall .ht-row .ht-rank {
+  font-family:var(--font-display); font-weight:700; color:var(--ink-dim);
+  font-variant-numeric:tabular-nums;
+}
+.fishbowl.fb-hall .ht-row.is-champ .ht-rank { color:var(--gold); }
+.fishbowl.fb-hall .ht-row .ht-model {
+  font-family:var(--font-display); font-weight:600; color:var(--ink); word-break:break-word;
+}
+.fishbowl.fb-hall .ht-row .ht-num { font-variant-numeric:tabular-nums; color:var(--ink-mid); }
+.fishbowl.fb-hall .ht-bar {
+  position:relative; height:14px; border-radius:999px;
+  background:rgba(120,222,214,0.08); overflow:hidden;
+}
+.fishbowl.fb-hall .ht-bar .ht-fill {
+  position:absolute; inset:0 auto 0 0; height:100%; border-radius:999px;
+  background:linear-gradient(90deg, rgba(255,207,107,0.55), var(--gold));
+  box-shadow:0 0 12px rgba(255,207,107,0.45);
+}
+.fishbowl.fb-hall .ht-bar .ht-bar-label {
+  position:absolute; right:8px; top:50%; transform:translateY(-50%);
+  font-family:var(--font-display); font-size:9px; font-weight:700;
+  color:var(--bg-0); text-shadow:0 0 3px rgba(255,207,107,0.8);
+  font-variant-numeric:tabular-nums;
+}
+
+/* ── Sessions table ── */
+.fishbowl.fb-hall .sess-head, .fishbowl.fb-hall .sess-row {
+  display:grid; grid-template-columns:0.7fr 1.4fr 1.1fr 0.9fr 0.7fr 0.9fr;
+  gap:10px; align-items:center; padding:9px 12px; border-radius:var(--r);
+}
+.fishbowl.fb-hall .sess-head {
+  font-family:var(--font-display); font-size:8.5px; letter-spacing:0.2em;
+  text-transform:uppercase; color:var(--ink-faint);
+  border-bottom:1px solid var(--line-soft); border-radius:0;
+}
+.fishbowl.fb-hall .sess-row:hover { background:var(--glass); }
+.fishbowl.fb-hall .sess-row .sr-id {
+  font-family:var(--font-display); color:var(--ink-dim); font-size:12px;
+}
+.fishbowl.fb-hall .sess-row .sr-cast { color:var(--ink-mid); font-size:12px; word-break:break-word; }
+.fishbowl.fb-hall .sess-row .sr-num { font-variant-numeric:tabular-nums; color:var(--ink-mid); }
+.fishbowl.fb-hall .sr-won {
+  display:inline-flex; align-items:center; gap:5px;
+  font-family:var(--font-display); font-size:11px; font-weight:700;
+  text-transform:uppercase; letter-spacing:0.08em;
+  color:var(--gold); text-shadow:0 0 10px rgba(255,207,107,0.5);
+}
+.fishbowl.fb-hall .sr-reason { color:var(--ink-faint); font-size:11px; }
+
+/* ── Fairness footnote panel ── */
+.fishbowl.fb-hall .fair-grid {
+  display:grid; grid-template-columns:1.4fr 0.7fr 0.7fr 1.5fr; gap:10px;
+  align-items:center; padding:8px 12px; border-radius:var(--r);
+}
+.fishbowl.fb-hall .fair-head {
+  font-family:var(--font-display); font-size:8.5px; letter-spacing:0.2em;
+  text-transform:uppercase; color:var(--ink-faint);
+  border-bottom:1px solid var(--line-soft); border-radius:0;
+}
+.fishbowl.fb-hall .fair-grid:hover { background:var(--glass); }
+.fishbowl.fb-hall .fair-seat { font-family:var(--font-display); font-weight:600; color:var(--ink); }
+.fishbowl.fb-hall .fair-num { font-variant-numeric:tabular-nums; color:var(--ink-mid); }
+.fishbowl.fb-hall .fair-bar { position:relative; height:10px; border-radius:999px;
+  background:rgba(120,222,214,0.08); overflow:hidden; }
+.fishbowl.fb-hall .fair-bar .fair-fill { position:absolute; inset:0 auto 0 0; height:100%;
+  border-radius:999px; background:linear-gradient(90deg, var(--cyan), var(--teal));
+  box-shadow:0 0 8px rgba(79,230,210,0.4); }
+.fishbowl.fb-hall .fair-note {
+  margin-top:14px; padding:10px 12px; border-radius:var(--r);
+  border:1px solid var(--line-soft); background:rgba(255,207,107,0.06);
+  color:var(--ink-dim); font-size:11px; line-height:1.5;
+}
+
+@keyframes hallRise { from { opacity:0; transform:translateY(8px);} to { opacity:1; transform:none;} }
+@keyframes hallChampPulse {
+  0%,100% { transform:scale(1); filter:drop-shadow(0 0 6px rgba(255,207,107,0.5)); }
+  50% { transform:scale(1.12); filter:drop-shadow(0 0 14px rgba(255,207,107,0.85)); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .fishbowl.fb-hall .hall-headline::after,
+  .fishbowl.fb-hall .podium-slot,
+  .fishbowl.fb-hall .podium-slot.rank-1 .ps-medal,
+  .fishbowl.fb-hall .ht-row { animation:none !important; }
+}
+</style>
+"""
+
+
+# ── render functions (pure HTML strings, defensive, .fishbowl-scoped) ─────────────
+
+
+def _wrap(inner: str) -> str:
+    """Wrap a Hall-of-Fame pane in the ``.fishbowl.fb-hall`` scope root.
+
+    Mirrors :func:`src.ui.fishbowl.app._fishbowl` so the theater stylesheet (and the
+    inlined Hall-of-Fame ``<style>``) win over Gradio's cascade.
+    """
+    return f'<div class="fishbowl fb-hall">{_HALL_STYLE}{inner}</div>'
+
+
+def render_headline(entries) -> str:
+    """The big glowing demo line from :func:`leaderboard.headline`, or an empty state.
+
+    Renders e.g. ``MiniCPM-8B beats Gemma-12B · 7-3 at Debate Duel`` with the two model
+    names gilded.  When ``headline`` returns ``None`` (no symmetric scenario with two
+    models that have each won), shows a cheerful "no champions yet" call to action.
+    """
+    try:
+        line = headline(entries)
+    except Exception:  # pragma: no cover - projection error (defensive)
+        line = None
+    if not line:
+        return _wrap(
+            '<div class="hall-empty">'
+            '<div class="eyebrow">&#127942; Hall of Fame</div>'
+            '<div class="he-body">No champions crowned yet — run a competitive scenario '
+            "(a versus duel or a judged contest) to fill the Hall.</div>"
+            "</div>"
+        )
+    # Gild the two model names: the line is "<A> beats <B> · X-Y at <Scenario>".
+    safe = _esc(line)
+    if " beats " in line:
+        left, _, rest = line.partition(" beats ")
+        runner, _, tail = rest.partition(" · ")
+        safe = (
+            f'<span class="hl-gold">{_esc(left)}</span> beats '
+            f'<span class="hl-gold">{_esc(runner)}</span> · {_esc(tail)}'
+        )
+    return _wrap(
+        '<div class="hall-headline">'
+        '<div class="eyebrow">&#127942; Today\'s Champion</div>'
+        f'<div class="hall-line">{safe}</div>'
+        "</div>"
+    )
+
+
+def _podium_html(rows: list[ModelRow]) -> str:
+    """The gold/silver/bronze top-3 podium (visual order: 2nd · 1st · 3rd)."""
+    if not rows:
+        return ""
+    top = rows[:3]
+    medals = {0: "&#129351;", 1: "&#129352;", 2: "&#129353;"}  # 🥇 🥈 🥉
+
+    def slot(idx: int) -> str:
+        if idx >= len(top):
+            return '<div class="podium-slot" style="visibility:hidden"></div>'
+        row = top[idx]
+        return (
+            f'<div class="podium-slot rank-{idx + 1}">'
+            f'<div class="ps-medal">{medals.get(idx, "")}</div>'
+            f'<div class="ps-name">{_esc(_short_model(row.model))}</div>'
+            f'<div class="ps-rate">{_pct(row.win_rate)}</div>'
+            f'<div class="ps-sub">{row.wins}/{row.plays} won</div>'
+            "</div>"
+        )
+
+    # Visual order puts #1 in the centre, raised.
+    order = [1, 0, 2]
+    return '<div class="podium">' + "".join(slot(i) for i in order) + "</div>"
+
+
+def render_model_board(entries) -> str:
+    """The model podium + ranked table with glowing gold win-rate bars.
+
+    Folds :func:`leaderboard.model_table` (already sorted by win-rate) into the podium
+    for the top 3 and a ranked table below.  Each row carries rank, model, plays, wins
+    and a horizontal bar whose width is the win-rate.  Empty store → empty state.
+    """
+    try:
+        rows = model_table(entries)
+    except Exception:  # pragma: no cover - projection error (defensive)
+        rows = []
+    if not rows:
+        return _wrap(
+            '<div class="hall-empty">'
+            '<div class="eyebrow">&#128202; Model Leaderboard</div>'
+            '<div class="he-body">No decided competitive runs yet. Once a versus or judged '
+            "scenario crowns a winner, the models climb the board here.</div>"
+            "</div>"
+        )
+    head = '<div class="ht-head"><div>#</div><div>Model</div><div>Plays</div><div>Wins</div><div>Win rate</div></div>'
+    body_rows: list[str] = []
+    for idx, row in enumerate(rows):
+        champ = " is-champ" if idx == 0 else ""
+        width = _bar_width(row.win_rate)
+        body_rows.append(
+            f'<div class="ht-row{champ}" style="animation-delay:{min(idx, 12) * 0.04:.2f}s">'
+            f'<div class="ht-rank">{idx + 1}</div>'
+            f'<div class="ht-model">{_esc(_short_model(row.model))}</div>'
+            f'<div class="ht-num">{row.plays}</div>'
+            f'<div class="ht-num">{row.wins}</div>'
+            '<div class="ht-bar">'
+            f'<div class="ht-fill" style="width:{width:.1f}%"></div>'
+            f'<div class="ht-bar-label">{_pct(row.win_rate)}</div>'
+            "</div>"
+            "</div>"
+        )
+    return _wrap(
+        '<div class="hall-panel">'
+        '<div class="eyebrow">&#128202; Model Leaderboard</div>'
+        + _podium_html(rows)
+        + '<div class="hall-table">'
+        + head
+        + "".join(body_rows)
+        + "</div></div>"
+    )
+
+
+def render_sessions(entries, scenario_name: str) -> str:
+    """The sessions table for *scenario_name* (without the Replay buttons).
+
+    Lists each finished, won, competitive run newest-first: a short id, the cast's
+    models, the gold WON badge, why it ended, turns/tokens and the date.  The Replay
+    buttons themselves are real Gradio components rendered alongside this HTML by
+    ``build_hall_of_fame`` (gr.HTML can't host working buttons); this pane is the
+    glanceable record.  Empty / non-competitive scenario → empty state.
+    """
+    if not scenario_name:
+        return _wrap(
+            '<div class="hall-empty">'
+            '<div class="eyebrow">&#9654; Sessions</div>'
+            '<div class="he-body">Pick a competitive world above to see its decided '
+            "matches and replay any of them.</div>"
+            "</div>"
+        )
+    try:
+        rows = scenario_sessions(entries, scenario_name)
+    except Exception:  # pragma: no cover - projection error (defensive)
+        rows = []
+    title = _esc(_scenario_title(scenario_name))
+    if not rows:
+        return _wrap(
+            '<div class="hall-panel">'
+            f'<div class="eyebrow">&#9654; {title} · Sessions</div>'
+            '<div class="hall-empty" style="border:none;background:transparent;padding:8px 0">'
+            '<div class="he-body">No decided matches in this world yet. Run it as a '
+            "competition and the results land here, replayable.</div>"
+            "</div></div>"
+        )
+    head = (
+        '<div class="sess-head">'
+        "<div>Run</div><div>Cast models</div><div>Winner</div>"
+        "<div>Why</div><div>Turns</div><div>When</div>"
+        "</div>"
+    )
+    body_rows = "".join(_session_row_html(row) for row in rows)
+    return _wrap(
+        '<div class="hall-panel">'
+        f'<div class="eyebrow">&#9654; {title} · Sessions</div>'
+        f'<div class="hall-table">{head}{body_rows}</div>'
+        "</div>"
+    )
+
+
+def _session_row_html(row: LeaderboardEntry) -> str:
+    """One sessions-table row (glanceable; the Replay button sits beside it)."""
+    reason = _REASON_LABEL.get(row.reason or "", row.reason or "—")
+    won = (
+        f'<span class="sr-won">&#127942; {_esc(row.winner)}</span>'
+        if row.winner
+        else '<span class="sr-reason">—</span>'
+    )
+    return (
+        '<div class="sess-row">'
+        f'<div class="sr-id">{_esc(_short_id(row.run_id))}</div>'
+        f'<div class="sr-cast">{_esc(_cast_models(row))}</div>'
+        f"<div>{won}</div>"
+        f'<div class="sr-reason">{_esc(reason)}</div>'
+        f'<div class="sr-num">{row.turns}t · {_esc(_fmt_tokens(row.tokens))}</div>'
+        f'<div class="sr-num">{_esc(_fmt_when(row.finished_at))}</div>'
+        "</div>"
+    )
+
+
+def render_fairness(entries, scenario_name: str) -> str:
+    """The 6.3 fairness footnote: win rate per seat type, with the asymmetry note.
+
+    Folds :func:`leaderboard.fairness_table` (only *declared* seats — teams /
+    symmetric seats; judges and other unmapped seats are excluded by design).  A
+    footnote reminds viewers that asymmetric seats (spy vs herd) skew raw win rates.
+    Empty → a quiet empty state.
+    """
+    if not scenario_name:
+        return ""
+    try:
+        rows = fairness_table(entries, scenario_name)
+    except Exception:  # pragma: no cover - projection error (defensive)
+        rows = []
+    if not rows:
+        return _wrap(
+            '<div class="hall-panel">'
+            '<div class="eyebrow">&#9878;&#65039; Seat Fairness</div>'
+            '<div class="he-body" style="color:var(--ink-mid)">No per-seat data yet — '
+            "this footnote fills in once this world has decided competitive runs.</div>"
+            "</div>"
+        )
+    head = (
+        '<div class="fair-grid fair-head"><div>Seat type</div><div>Plays</div><div>Wins</div><div>Win rate</div></div>'
+    )
+    body = "".join(_fairness_row_html(row) for row in rows)
+    note = (
+        '<div class="fair-note">&#9888;&#65039; Seats are not always symmetric — a spy '
+        "faces a whole herd, a lone debater a panel. Raw seat win rates show the structural "
+        "tilt of the game, not just who played well.</div>"
+    )
+    return _wrap(
+        '<div class="hall-panel">'
+        '<div class="eyebrow">&#9878;&#65039; Seat Fairness</div>'
+        f'<div class="hall-table">{head}{body}</div>'
+        f"{note}</div>"
+    )
+
+
+def _fairness_row_html(row: SeatRow) -> str:
+    """One fairness row: seat type, plays, wins, and a cyan win-rate bar."""
+    width = _bar_width(row.win_rate)
+    return (
+        '<div class="fair-grid">'
+        f'<div class="fair-seat">{_esc(row.seat_type)}</div>'
+        f'<div class="fair-num">{row.plays}</div>'
+        f'<div class="fair-num">{row.wins}</div>'
+        '<div class="fair-bar">'
+        f'<div class="fair-fill" style="width:{width:.1f}%"></div>'
+        "</div>"
+        "</div>"
+    )
+
+
+def _scenario_title(scenario_name: str) -> str:
+    """The display title for an internal scenario name, falling back to the name."""
+    try:
+        cfg = default_registry().scenarios.get(scenario_name)
+        return (getattr(cfg, "title", "") or scenario_name) if cfg else scenario_name
+    except Exception:  # pragma: no cover - registry unavailable (defensive)
+        return scenario_name
+
+
+# ── builder ──────────────────────────────────────────────────────────────────────
+
+
+def build_hall_of_fame() -> dict:
+    """Lay out the Hall of Fame tab and return a handles dict for the app to wire.
+
+    Layout (top → bottom): the glowing **headline marquee**, a **scenario picker**
+    (only competitive worlds), the **model podium + ranked table**, the per-scenario
+    **sessions area** (an HTML record + a ``gr.render`` of per-run Replay buttons),
+    the **fairness footnote**, and a **refresh** control.
+
+    Returns a handles dict the app wires into the Show transport:
+
+    ``{"scenario_dd", "refresh", "headline_html", "model_html", "sessions_html",
+       "fairness_html", "sessions_render_anchor", "default_scenario"}``
+
+    The Replay buttons are *not* built here — they need the Show's pane handles, which
+    only exist after the Show tab builds.  The app calls :func:`wire_sessions_render`
+    (below) with the shared ``archive_refs`` + states after all tabs build, mirroring
+    how ``_build_archive_drawer`` defers its ``show_handles`` lookup.
+    """
+    scenarios = competitive_scenarios()
+    choices = [(title, name) for title, name in scenarios]
+    default_scenario = choices[0][1] if choices else None
+    entries = _entries()
+
+    handles: dict = {"default_scenario": default_scenario}
+
+    with gr.Column(elem_classes=["hall-wrap"]):
+        handles["headline_html"] = gr.HTML(render_headline(entries))
+
+        handles["scenario_dd"] = gr.Dropdown(
+            choices=choices,
+            value=default_scenario,
+            label="World",
+            elem_classes=["hall-scenario"],
+            interactive=True,
+            visible=bool(choices),
+        )
+        handles["refresh"] = gr.Button("⟳ refresh", size="sm", scale=0)
+
+        handles["model_html"] = gr.HTML(render_model_board(entries))
+
+        handles["sessions_html"] = gr.HTML(render_sessions(entries, default_scenario))
+        # The per-run Replay buttons live in this column; the app fills it with a
+        # gr.render (it needs the Show panes, populated after all tabs build).
+        handles["sessions_render_anchor"] = gr.Column(elem_classes=["hall-replays"])
+
+        handles["fairness_html"] = gr.HTML(render_fairness(entries, default_scenario))
+
+    return handles
+
+
+def wire_sessions_render(handles: dict, *, refs: dict, tabs, states: dict) -> None:
+    """Wire the Hall's data refresh + the per-run Replay buttons into the Show.
+
+    Called by the app **after all tabs build** so ``refs["show_handles"]`` is live
+    (mirrors ``_build_archive_drawer``'s deferred-ref trick).  Three behaviours:
+
+    * Changing the scenario picker (or refresh) re-reads the ledger and repaints the
+      model board, sessions table and fairness panel.
+    * A ``gr.render`` keyed on (scenario, refresh) lists per-run **Replay** buttons.
+    * Each Replay click loads the run via :func:`load_replay` and pushes it into the
+      Show — the *exact* output contract from ``_build_archive_drawer`` (session, k,
+      scenario, switch Tabs to "show", repaint panes, stopped=False, ticks=0).
+
+    Defensive throughout: missing handles or an unavailable store degrade to no-ops /
+    empty states rather than raising.
+    """
+    if not handles:
+        return
+    # Late imports of the app's render/replay helpers — they live in app.py and importing
+    # them at module top would create an import cycle (app imports this module).
+    try:
+        from src.ui.fishbowl.app import (
+            _pad_values,
+            _registry,
+            _render_at,
+            _show_outs,
+            _title_for,
+            _tools,
+            load_replay,
+        )
+    except Exception:  # pragma: no cover - app helpers unavailable (defensive)
+        return
+
+    scenario_dd = handles.get("scenario_dd")
+    refresh = handles.get("refresh")
+    model_html = handles.get("model_html")
+    sessions_html = handles.get("sessions_html")
+    fairness_html = handles.get("fairness_html")
+    anchor = handles.get("sessions_render_anchor")
+    if scenario_dd is None:
+        return
+
+    # ── refresh the boards on scenario change / refresh click ──────────────────────
+    def _repaint(scenario_name):
+        entries = _entries()
+        return (
+            render_model_board(entries),
+            render_sessions(entries, scenario_name),
+            render_fairness(entries, scenario_name),
+        )
+
+    repaint_outputs = [c for c in (model_html, sessions_html, fairness_html) if c is not None]
+    if repaint_outputs:
+        # Always emit a full tuple, but only route to present panes (defensive padding).
+        def _repaint_present(scenario_name):
+            full = _repaint(scenario_name)
+            picked = []
+            for comp, value in zip((model_html, sessions_html, fairness_html), full):
+                if comp is not None:
+                    picked.append(value)
+            return tuple(picked) if len(picked) != 1 else picked[0]
+
+        scenario_dd.change(_repaint_present, inputs=[scenario_dd], outputs=repaint_outputs)
+        if refresh is not None:
+            refresh.click(_repaint_present, inputs=[scenario_dd], outputs=repaint_outputs)
+
+    # ── per-run Replay buttons (gr.render → Show transport) ────────────────────────
+    if anchor is None:
+        return
+
+    with anchor:
+
+        @gr.render(
+            inputs=[scenario_dd],
+            triggers=[scenario_dd.change] + ([refresh.click] if refresh is not None else []),
+        )
+        def _render_replays(scenario_name):
+            if not scenario_name:
+                return
+            entries = _entries()
+            try:
+                rows = scenario_sessions(entries, scenario_name)
+            except Exception:  # pragma: no cover - projection error (defensive)
+                rows = []
+            if not rows:
+                return
+
+            show_outs = _show_outs(refs.get("show_handles") or {})
+            n_out = 6 + len(show_outs)  # session, k, scenario, tabs, *panes, stopped, ticks
+
+            def _loader(run_id: str):
+                def _load(layout, mind_reader):
+                    session = load_replay(run_id, registry=_registry, tools=_tools)
+                    if session is None:
+                        return tuple(gr.update() for _ in range(n_out))
+                    k = session.head  # land on the full discussion; ▶ replays it
+                    out = _render_at(session, k, layout=layout, mind_reader=mind_reader)
+                    return (
+                        session,
+                        k,
+                        _title_for(session.scenario_name),
+                        gr.update(selected="show"),
+                        *_pad_values(out, show_outs),
+                        False,
+                        0,
+                    )
+
+                return _load
+
+            for row in rows:
+                label = f"▶ Replay {_short_id(row.run_id)}"
+                if row.winner:
+                    label += f"  ·  WON {row.winner}"
+                btn = gr.Button(label, elem_classes=["archive-card"], size="sm")
+                btn.click(
+                    _loader(row.run_id),
+                    inputs=[states["layout"], states["mind"]],
+                    outputs=[
+                        states["session"],
+                        states["k"],
+                        states["scenario"],
+                        tabs,
+                        *show_outs,
+                        states["stopped"],
+                        states["ticks"],
+                    ],
+                )
+
+
+__all__ = [
+    "build_hall_of_fame",
+    "competitive_scenarios",
+    "render_fairness",
+    "render_headline",
+    "render_model_board",
+    "render_sessions",
+    "wire_sessions_render",
+]

src/ui/fishbowl/session.py

@@ -15,8 +15,10 @@ from __future__ import annotations
 from src import observability as obs
 from src.core.conductor import Conductor
 from src.core.ledger_factory import make_ledger
+from src.core.leaderboard_store import build_entry, make_leaderboard_store
 from src.core.manifest import AgentManifest
 from src.core.registry import Registry, default_registry
+from src.core.run_index import index_runs
 from src.tools.builtins import default_tool_registry
 from src.ui.fishbowl.view_model import view_model_at
 
@@ -50,6 +52,14 @@ class FishbowlSession:
             governor=self._registry.governor_for(scenario_name),
             ledger=make_ledger(),
         )
+        # The leaderboard's dedicated scoreboard table (ADR-0035) — a *separate* table in
+        # the same database as the event ledger, never the events log.  Built defensively
+        # so a store/config hiccup can never break a live run; a None store just means no
+        # scoreboard row is recorded.
+        try:
+            self._leaderboard = make_leaderboard_store()
+        except Exception:  # pragma: no cover - no store configured (defensive)
+            self._leaderboard = None
         obs.log(
             "session.created",
             scenario=scenario_name,
@@ -182,6 +192,34 @@ class FishbowlSession:
             winning_model=winning_model,
             winning_models=winning_models,
         )
+        self._record_leaderboard()
+
+    def _record_leaderboard(self) -> None:
+        """Write this run's scoreboard row to the dedicated leaderboard table (ADR-0035).
+
+        Detached from the event ledger: the run's events stay the source of truth for the
+        trace, while this persists one denormalised result row to ``leaderboard_entries``
+        — but only when :func:`build_entry` deems the run eligible (finished, a winner, a
+        concrete winning model, and a competitive scenario).  Idempotent via the store's
+        upsert-on-``run_id``, so a verdict that supersedes a budget close replaces the row.
+
+        Fully defensive: any failure is logged and swallowed so a leaderboard hiccup never
+        breaks the show."""
+        store = getattr(self, "_leaderboard", None)
+        if store is None:
+            return
+        try:
+            run_events = self.conductor.ledger.events_for_run(self.conductor.run_id)
+            summary = next((s for s in index_runs(run_events) if s.run_id == self.conductor.run_id), None)
+            if summary is None:
+                return
+            scenario = self._registry.scenarios.get(self._scenario_name)
+            entry = build_entry(summary, getattr(scenario, "competition", None))
+            if entry is not None:
+                store.record(entry)
+                obs.log("leaderboard.recorded", run_id=entry.run_id, scenario=entry.scenario, winner=entry.winner)
+        except Exception:  # pragma: no cover - never let a scoreboard write break a run
+            obs.log("leaderboard.record_failed", level="warning", run_id=self.conductor.run_id)
 
     @property
     def cast(self) -> list[AgentManifest]:

tests/test_leaderboard.py

@@ -0,0 +1,977 @@
+"""Leaderboard aggregations over LeaderboardEntry rows — zero-mock, deterministic.
+
+This suite verifies the leaderboard's read-model invariants: that aggregations over a
+list of LeaderboardEntry objects produce correct tables, win_rate math, sorting, and that
+projections are deterministic regardless of input order.
+
+Test strategy: Build LeaderboardEntry objects directly (no events, no ledger), call the
+public aggregation functions, and assert on the resulting rows. This guards against:
+
+  - Incorrect model endpoint deduplication (one play per endpoint per run, even when
+    filling multiple seats).
+  - Team wins crediting every member's model vs single-agent wins.
+  - Judges and other unmapped cast members affecting fairness and agent tables.
+  - Sorting regressions (determinism is a contract).
+  - Headline generation requiring symmetric seats + ≥2 models with ≥1 win each.
+  - Edge cases: empty input, zero plays, missing fields, out-of-order entries.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+from src.core.leaderboard import (
+    agent_table,
+    fairness_table,
+    headline,
+    model_table,
+    scenario_sessions,
+)
+from src.core.leaderboard_store import LeaderboardEntry
+from src.core.run_index import CastBinding
+
+
+# ── LeaderboardEntry builders ──────────────────────────────────────────────────────
+
+
+def _entry(
+    run_id: str = "r1",
+    scenario: str = "Debate Duel",
+    seed: str = "seed123",
+    session_id: str | None = None,
+    competition_kind: str = "versus",
+    teams: dict[str, list[str]] | None = None,
+    symmetric_seats: list[str] | None = None,
+    cast: dict[str, CastBinding] | None = None,
+    winner: str | None = "alice",
+    winner_kind: str | None = "agent",
+    winning_model: str | None = "openai/openbmb/MiniCPM-8B",
+    winning_models: list[str] | None = None,
+    reason: str | None = "verdict",
+    turns: int = 5,
+    tokens: int = 200,
+    started_at: datetime | None = None,
+    finished_at: datetime | None = None,
+) -> LeaderboardEntry:
+    """Build a minimal LeaderboardEntry for testing."""
+    if started_at is None:
+        started_at = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+    if finished_at is None:
+        finished_at = started_at + timedelta(minutes=5)
+    if cast is None:
+        cast = {"alice": CastBinding(model_endpoint=winning_model)}
+    if winning_models is None:
+        winning_models = [winning_model] if winning_model else []
+    return LeaderboardEntry(
+        run_id=run_id,
+        session_id=session_id,
+        scenario=scenario,
+        seed=seed,
+        competition_kind=competition_kind,
+        teams=teams,
+        symmetric_seats=symmetric_seats,
+        cast=cast,
+        winner=winner,
+        winner_kind=winner_kind,
+        winning_model=winning_model,
+        winning_models=winning_models,
+        reason=reason,
+        turns=turns,
+        tokens=tokens,
+        started_at=started_at,
+        finished_at=finished_at,
+    )
+
+
+# ── Tests: scenario_sessions (newest-first filtering) ─────────────────────────────
+
+
+class TestScenarioSessions:
+    """Verify scenario_sessions filters, orders, and projects correctly."""
+
+    def test_empty_entries_returns_empty_list(self):
+        """Empty entry list returns no sessions."""
+        result = scenario_sessions([], "Debate Duel")
+        assert result == []
+
+    def test_no_winner_entry_excluded(self):
+        """An entry with no winner is dropped (defensive gate)."""
+        entry = _entry(winner=None)
+        result = scenario_sessions([entry], "Debate Duel")
+        assert result == []
+
+    def test_scenario_filter_excludes_other_scenarios(self):
+        """Sessions from other scenarios are not returned."""
+        entry = _entry(scenario="Debate Duel")
+        result = scenario_sessions([entry], "Trivia Night")
+        assert result == []
+
+    def test_one_entry_has_all_fields(self):
+        """A single entry is projected with all fields intact."""
+        cast = {
+            "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B", model_profile="large"),
+            "bob": CastBinding(model_endpoint="google/gemma-12B", model_profile="medium"),
+        }
+        started_at = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+        finished_at = started_at + timedelta(minutes=5)
+        entry = _entry(
+            run_id="r1",
+            scenario="Debate Duel",
+            seed="abc123",
+            cast=cast,
+            symmetric_seats=["debater_a", "debater_b"],
+            winner="alice",
+            winner_kind="agent",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            winning_models=["openai/openbmb/MiniCPM-8B"],
+            turns=7,
+            tokens=320,
+            started_at=started_at,
+            finished_at=finished_at,
+        )
+        result = scenario_sessions([entry], "Debate Duel")
+        assert len(result) == 1
+        row = result[0]
+        assert row.run_id == "r1"
+        assert row.scenario == "Debate Duel"
+        assert row.seed == "abc123"
+        assert row.winner == "alice"
+        assert row.winner_kind == "agent"
+        assert row.turns == 7
+        assert row.tokens == 320
+        assert row.started_at == started_at
+        assert row.finished_at == finished_at
+        assert "alice" in row.cast
+        assert row.cast["alice"].model_endpoint == "openai/openbmb/MiniCPM-8B"
+
+    def test_newest_first_order(self):
+        """Sessions are sorted newest first by finished_at."""
+        old = datetime(2025, 6, 1, 10, 0, 0, tzinfo=timezone.utc)
+        new = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+        entries = [
+            _entry(run_id="r1", finished_at=old + timedelta(minutes=1)),
+            _entry(run_id="r2", finished_at=new + timedelta(minutes=1)),
+        ]
+        result = scenario_sessions(entries, "Debate Duel")
+        assert len(result) == 2
+        assert result[0].run_id == "r2"  # newer first
+        assert result[1].run_id == "r1"
+
+    def test_run_id_tiebreak_when_finished_at_same(self):
+        """When finished_at is equal, run_id is the tiebreaker (ascending alphabetical)."""
+        same_time = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+        entries = [
+            _entry(run_id="r2", finished_at=same_time + timedelta(minutes=1)),
+            _entry(run_id="r1", finished_at=same_time + timedelta(minutes=1)),
+        ]
+        result = scenario_sessions(entries, "Debate Duel")
+        assert len(result) == 2
+        # Same finished_at; run_id breaks ties in ascending order (r1 < r2)
+        assert result[0].run_id == "r1"
+        assert result[1].run_id == "r2"
+
+
+# ── Tests: model_table (endpoint-level stats across all scenarios) ──────────────────
+
+
+class TestModelTable:
+    """Verify model aggregation: plays, wins, win_rate, scenarios, deterministic sort."""
+
+    def test_empty_entries_returns_empty_list(self):
+        """No entries → no rows."""
+        result = model_table([])
+        assert result == []
+
+    def test_no_winner_entry_not_counted(self):
+        """An entry with no winner contributes no stats."""
+        entry = _entry(winner=None)
+        result = model_table([entry])
+        assert result == []
+
+    def test_one_model_one_play_one_win(self):
+        """A single-entry win: plays=1, wins=1, win_rate=1.0."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+            winner="alice",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            winning_models=["openai/openbmb/MiniCPM-8B"],
+        )
+        result = model_table([entry])
+        assert len(result) == 1
+        assert result[0].model == "openai/openbmb/MiniCPM-8B"
+        assert result[0].plays == 1
+        assert result[0].wins == 1
+        assert result[0].win_rate == 1.0
+        assert result[0].scenarios == ["Debate Duel"]
+
+    def test_one_model_mixed_wins_and_losses(self):
+        """A model with 2 wins / 3 plays has win_rate ≈ 0.667."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+                winning_model="openai/openbmb/MiniCPM-8B",
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+                winning_model="openai/openbmb/MiniCPM-8B",
+            ),
+            _entry(
+                run_id="r3",
+                scenario="Debate Duel",
+                cast={
+                    "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "bob": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="bob",
+                winning_model="google/gemma-12B",
+            ),
+        ]
+        result = model_table(entries)
+        m8b = next((r for r in result if r.model == "openai/openbmb/MiniCPM-8B"), None)
+        assert m8b is not None
+        assert m8b.plays == 3
+        assert m8b.wins == 2
+        assert abs(m8b.win_rate - (2 / 3)) < 0.001
+
+    def test_model_endpoint_deduplication_one_play_per_endpoint_per_run(self):
+        """A model filling two seats in one run counts as one play (dedup by endpoint)."""
+        entry = _entry(
+            run_id="r1",
+            scenario="Some Scenario",
+            cast={
+                "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "bob": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),  # same endpoint
+            },
+            winner="alice",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["seat_a", "seat_b"],
+        )
+        result = model_table([entry])
+        assert len(result) == 1
+        assert result[0].plays == 1  # not 2!
+        assert result[0].wins == 1
+
+    def test_scenarios_lists_all_distinct_scenarios_sorted(self):
+        """A model in multiple scenarios lists all of them (sorted)."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Zebra Debate",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+                winning_model="openai/openbmb/MiniCPM-8B",
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Alpha Trivia",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+                winning_model="openai/openbmb/MiniCPM-8B",
+            ),
+        ]
+        result = model_table(entries)
+        assert len(result) == 1
+        assert result[0].scenarios == ["Alpha Trivia", "Zebra Debate"]
+
+    def test_deterministic_sort_win_rate_then_wins_then_plays_then_model(self):
+        """model_table sorts by (-win_rate, -wins, -plays, model asc)."""
+        entries = [
+            # MiniCPM-8B: 2 wins / 2 plays = 1.0
+            _entry(
+                run_id="r1",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+                winning_model="openai/openbmb/MiniCPM-8B",
+            ),
+            _entry(
+                run_id="r2",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+                winning_model="openai/openbmb/MiniCPM-8B",
+            ),
+            # Gemma: 1 win / 2 plays = 0.5
+            _entry(
+                run_id="r3",
+                cast={"alice": CastBinding(model_endpoint="google/gemma-12B")},
+                winner="alice",
+                winning_model="google/gemma-12B",
+            ),
+            _entry(
+                run_id="r4",
+                cast={
+                    "alice": CastBinding(model_endpoint="google/gemma-12B"),
+                    "bob": CastBinding(model_endpoint="openai/openbmb/MiniCPM-4B"),
+                },
+                winner="bob",
+                winning_model="openai/openbmb/MiniCPM-4B",  # MiniCPM-4B wins here
+            ),
+            # MiniCPM-4B: 0 wins / 2 plays = 0.0 (plays in r4 winning, but that's a different calc)
+            _entry(
+                run_id="r5",
+                cast={
+                    "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-4B"),
+                    "bob": CastBinding(model_endpoint="meta/llama-7B"),
+                },
+                winner="bob",
+                winning_model="meta/llama-7B",
+            ),
+            _entry(
+                run_id="r6",
+                cast={
+                    "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-4B"),
+                    "bob": CastBinding(model_endpoint="meta/llama-7B"),
+                },
+                winner="alice",  # MiniCPM-4B wins (but alice is the seat, need to check...)
+                winning_model="openai/openbmb/MiniCPM-4B",
+            ),
+        ]
+        result = model_table(entries)
+        result_models = [r.model for r in result]
+        assert result_models[0] == "openai/openbmb/MiniCPM-8B"  # 1.0, 2 wins, 2 plays
+        # MiniCPM-4B: 2 wins / 3 plays ≈ 0.67, Gemma: 1 win / 2 plays = 0.5, Llama: 1 win / 2 plays = 0.5
+        # Sort: MiniCPM-8B (1.0) > MiniCPM-4B (0.67) > Gemma (0.5, "gemma" < "llama") > Llama (0.5)
+        assert result_models[1] == "openai/openbmb/MiniCPM-4B"  # 0.67, 2 wins
+        assert result_models[2] == "google/gemma-12B"  # 0.5, 1 win
+        assert result_models[3] == "meta/llama-7B"  # 0.5, 1 win
+
+    def test_winning_models_includes_all_credited_endpoints(self):
+        """A run with winning_models=[a,b] credits both with a win."""
+        entry = _entry(
+            run_id="r1",
+            scenario="Debate Duel",
+            cast={
+                "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "bob": CastBinding(model_endpoint="google/gemma-12B"),
+            },
+            winner="team_a",
+            winner_kind="team",
+            winning_model=None,
+            winning_models=["openai/openbmb/MiniCPM-8B", "google/gemma-12B"],
+            symmetric_seats=["seat_a", "seat_b"],
+        )
+        result = model_table([entry])
+        assert len(result) == 2
+        m8b = next((r for r in result if r.model == "openai/openbmb/MiniCPM-8B"), None)
+        assert m8b is not None and m8b.wins == 1
+        gemma = next((r for r in result if r.model == "google/gemma-12B"), None)
+        assert gemma is not None and gemma.wins == 1
+
+
+# ── Tests: agent_table (per-scenario, per-persona stats) ────────────────────────────
+
+
+class TestAgentTable:
+    """Verify agent attribution: plays, wins, seat_type, model_endpoints, sort."""
+
+    def test_empty_entries_returns_empty_list(self):
+        """No entries → no rows."""
+        result = agent_table([], "Debate Duel")
+        assert result == []
+
+    def test_agent_filtered_by_scenario(self):
+        """agent_table only includes agents from the named scenario."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Other Scenario",
+                cast={"bob": CastBinding(model_endpoint="google/gemma-12B")},
+                winner="bob",
+            ),
+        ]
+        result = agent_table(entries, "Debate Duel")
+        agents = [r.agent for r in result]
+        assert agents == ["alice"]
+
+    def test_agent_single_play_single_win(self):
+        """An agent with one win: plays=1, wins=1, win_rate=1.0."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+            winner="alice",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["debater_a"],
+        )
+        result = agent_table([entry], "Debate Duel")
+        assert len(result) == 1
+        assert result[0].agent == "alice"
+        assert result[0].plays == 1
+        assert result[0].wins == 1
+        assert result[0].win_rate == 1.0
+
+    def test_agent_seat_type_from_symmetric_seats(self):
+        """In symmetric-seat scenarios, agent's seat_type is the seat name."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={"debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+            winner="debater_a",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["debater_a", "debater_b"],
+        )
+        result = agent_table([entry], "Debate Duel")
+        assert result[0].agent == "debater_a"
+        assert result[0].seat_type == "debater_a"
+
+    def test_agent_seat_type_from_teams(self):
+        """In team scenarios, agent's seat_type is the team label they belong to."""
+        entry = _entry(
+            scenario="Team Game",
+            cast={
+                "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "bob": CastBinding(model_endpoint="google/gemma-12B"),
+            },
+            teams={"team_a": ["alice", "charlie"], "team_b": ["bob"]},
+            winner="alice",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            winner_kind="agent",
+            competition_kind="versus",
+        )
+        result = agent_table([entry], "Team Game")
+        alice = next((r for r in result if r.agent == "alice"), None)
+        bob = next((r for r in result if r.agent == "bob"), None)
+        assert alice is not None and alice.seat_type == "team_a"
+        assert bob is not None and bob.seat_type == "team_b"
+
+    def test_agent_seat_type_empty_when_unmapped(self):
+        """An agent not in teams or symmetric_seats (e.g., judge) has seat_type=''."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={
+                "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "judge": CastBinding(model_endpoint=None),
+            },
+            winner="debater_a",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["debater_a"],
+            competition_kind="judged",
+        )
+        result = agent_table([entry], "Debate Duel")
+        judge_row = next((r for r in result if r.agent == "judge"), None)
+        assert judge_row is not None
+        assert judge_row.seat_type == ""
+
+    def test_agent_model_endpoints_deduped_sorted(self):
+        """An agent's model_endpoints is sorted, distinct models that filled the seat."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={"alice": CastBinding(model_endpoint="google/gemma-12B")},
+                winner="alice",
+                winning_model="google/gemma-12B",
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+                winning_model="openai/openbmb/MiniCPM-8B",
+            ),
+            _entry(
+                run_id="r3",
+                scenario="Debate Duel",
+                cast={"alice": CastBinding(model_endpoint="google/gemma-12B")},  # repeat
+                winner="alice",
+                winning_model="google/gemma-12B",
+            ),
+        ]
+        result = agent_table(entries, "Debate Duel")
+        assert len(result) == 1
+        assert result[0].model_endpoints == ["google/gemma-12B", "openai/openbmb/MiniCPM-8B"]
+
+    def test_team_win_credits_all_team_members(self):
+        """A team win credits every member of the winning team with a win."""
+        entry = _entry(
+            scenario="Team Game",
+            cast={
+                "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "bob": CastBinding(model_endpoint="google/gemma-12B"),
+            },
+            teams={"team_a": ["alice"], "team_b": ["bob"]},
+            winner="team_a",
+            winner_kind="team",
+            winning_models=["openai/openbmb/MiniCPM-8B"],
+            winning_model=None,
+            competition_kind="versus",
+        )
+        result = agent_table([entry], "Team Game")
+        alice = next((r for r in result if r.agent == "alice"), None)
+        bob = next((r for r in result if r.agent == "bob"), None)
+        assert alice is not None and alice.wins == 1
+        assert bob is not None and bob.wins == 0
+
+
+# ── Tests: fairness_table (seat-type aggregation) ─────────────────────────────────
+
+
+class TestFairnessTable:
+    """Verify fairness_table: seat-type aggregation, unmapped excluded, sort."""
+
+    def test_empty_entries_returns_empty_list(self):
+        """No entries → no rows."""
+        result = fairness_table([], "Debate Duel")
+        assert result == []
+
+    def test_only_declared_seat_types_appear(self):
+        """Only declared seat_types (teams or symmetric_seats) appear."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={
+                "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "judge": CastBinding(model_endpoint=None),
+            },
+            winner="debater_a",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["debater_a"],
+            competition_kind="judged",
+        )
+        result = fairness_table([entry], "Debate Duel")
+        seat_types = [r.seat_type for r in result]
+        # Only "debater_a" is declared; "judge" is unmapped.
+        assert seat_types == ["debater_a"]
+
+    def test_symmetric_seat_plays_and_wins(self):
+        """In symmetric-seat scenarios, each seat contributes one play per run."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={
+                "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+            },
+            winner="debater_a",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["debater_a", "debater_b"],
+        )
+        result = fairness_table([entry], "Debate Duel")
+        debater_a = next((r for r in result if r.seat_type == "debater_a"), None)
+        debater_b = next((r for r in result if r.seat_type == "debater_b"), None)
+        assert debater_a is not None and debater_a.plays == 1 and debater_a.wins == 1
+        assert debater_b is not None and debater_b.plays == 1 and debater_b.wins == 0
+
+    def test_team_seats_aggregation(self):
+        """In team scenarios, each team contributes one play; wins go to winning team."""
+        entry = _entry(
+            scenario="Team Game",
+            cast={
+                "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "bob": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "charlie": CastBinding(model_endpoint="google/gemma-12B"),
+            },
+            teams={"team_a": ["alice", "bob"], "team_b": ["charlie"]},
+            winner="team_a",
+            winner_kind="team",
+            winning_models=["openai/openbmb/MiniCPM-8B"],
+            winning_model=None,
+            competition_kind="versus",
+        )
+        result = fairness_table([entry], "Team Game")
+        team_a = next((r for r in result if r.seat_type == "team_a"), None)
+        team_b = next((r for r in result if r.seat_type == "team_b"), None)
+        assert team_a is not None and team_a.plays == 1 and team_a.wins == 1
+        assert team_b is not None and team_b.plays == 1 and team_b.wins == 0
+
+    def test_judge_not_counted_in_fairness(self):
+        """A judge (unmapped cast member) does not appear in fairness_table."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={
+                "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "judge": CastBinding(model_endpoint=None),
+            },
+            winner="debater_a",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["debater_a"],
+            competition_kind="judged",
+        )
+        result = fairness_table([entry], "Debate Duel")
+        assert len(result) == 1
+        assert result[0].seat_type == "debater_a"
+
+    def test_win_rate_calculated_per_seat_type(self):
+        """A seat winning 1 of 2 runs has win_rate=0.5."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_a",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_b",
+                winning_model="google/gemma-12B",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+        ]
+        result = fairness_table(entries, "Debate Duel")
+        debater_a = next((r for r in result if r.seat_type == "debater_a"), None)
+        debater_b = next((r for r in result if r.seat_type == "debater_b"), None)
+        assert debater_a is not None and abs(debater_a.win_rate - 0.5) < 0.001
+        assert debater_b is not None and abs(debater_b.win_rate - 0.5) < 0.001
+
+
+# ── Tests: headline (model-vs-model narrative) ─────────────────────────────────────
+
+
+class TestHeadline:
+    """Verify headline: symmetric seats + ≥2 models with ≥1 win each."""
+
+    def test_empty_entries_returns_none(self):
+        """No entries → no headline."""
+        result = headline([])
+        assert result is None
+
+    def test_no_symmetric_seat_scenarios_returns_none(self):
+        """Headline needs symmetric-seat scenario (model-vs-model); team scenarios excluded."""
+        entry = _entry(
+            scenario="Team Game",
+            cast={
+                "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "bob": CastBinding(model_endpoint="google/gemma-12B"),
+            },
+            teams={"team_a": ["alice"], "team_b": ["bob"]},
+            winner="team_a",
+            winner_kind="team",
+            winning_models=["openai/openbmb/MiniCPM-8B"],
+            winning_model=None,
+            competition_kind="versus",
+        )
+        result = headline([entry])
+        assert result is None
+
+    def test_only_one_model_in_scenario_returns_none(self):
+        """A scenario with only one model (even if winning) doesn't qualify."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={
+                "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "debater_b": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+            },
+            winner="debater_a",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            symmetric_seats=["debater_a", "debater_b"],
+        )
+        result = headline([entry])
+        assert result is None  # only 1 distinct model
+
+    def test_two_models_but_loser_has_zero_wins_returns_none(self):
+        """Headline needs ≥2 models that have each won ≥1."""
+        entry = _entry(
+            scenario="Debate Duel",
+            cast={
+                "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+            },
+            winner="debater_a",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            winning_models=["openai/openbmb/MiniCPM-8B"],
+            symmetric_seats=["debater_a", "debater_b"],
+        )
+        result = headline([entry])
+        assert result is None  # gemma has 0 wins
+
+    def test_headline_with_two_models_both_winning(self):
+        """Headline is generated when ≥2 models have each won ≥1 in symmetric scenario."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_a",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                winning_models=["openai/openbmb/MiniCPM-8B"],
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_b",
+                winning_model="google/gemma-12B",
+                winning_models=["google/gemma-12B"],
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+        ]
+        result = headline(entries)
+        assert result is not None
+        assert "MiniCPM" in result
+        assert "gemma" in result.lower()
+        assert "Debate Duel" in result
+        assert "1-1" in result
+
+    def test_headline_picks_most_played_scenario(self):
+        """When multiple scenarios qualify, headline picks the one with most games decided."""
+        entries = [
+            # Debate Duel: 1 game
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_a",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+            # Trivia Night: 3 games (most)
+            _entry(
+                run_id="r2",
+                scenario="Trivia Night",
+                cast={
+                    "player_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "player_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="player_a",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                symmetric_seats=["player_a", "player_b"],
+            ),
+            _entry(
+                run_id="r3",
+                scenario="Trivia Night",
+                cast={
+                    "player_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "player_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="player_b",
+                winning_model="google/gemma-12B",
+                symmetric_seats=["player_a", "player_b"],
+            ),
+            _entry(
+                run_id="r4",
+                scenario="Trivia Night",
+                cast={
+                    "player_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "player_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="player_b",
+                winning_model="google/gemma-12B",
+                symmetric_seats=["player_a", "player_b"],
+            ),
+        ]
+        result = headline(entries)
+        assert result is not None
+        assert "Trivia Night" in result
+
+    def test_headline_alphabetical_tiebreak_when_same_wins(self):
+        """When scenarios tie on wins, pick the alphabetically-first scenario name."""
+        entries = [
+            # "Aardvark": 1 win for MiniCPM, 1 for Gemma
+            _entry(
+                run_id="a1",
+                scenario="Aardvark Duel",
+                cast={
+                    "p1": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "p2": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="p1",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                symmetric_seats=["p1", "p2"],
+            ),
+            _entry(
+                run_id="a2",
+                scenario="Aardvark Duel",
+                cast={
+                    "p1": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "p2": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="p2",
+                winning_model="google/gemma-12B",
+                symmetric_seats=["p1", "p2"],
+            ),
+            # "Zebra": same record, but alphabetically later
+            _entry(
+                run_id="z1",
+                scenario="Zebra Duel",
+                cast={
+                    "p1": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "p2": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="p1",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                symmetric_seats=["p1", "p2"],
+            ),
+            _entry(
+                run_id="z2",
+                scenario="Zebra Duel",
+                cast={
+                    "p1": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "p2": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="p2",
+                winning_model="google/gemma-12B",
+                symmetric_seats=["p1", "p2"],
+            ),
+        ]
+        result = headline(entries)
+        assert result is not None
+        assert "Aardvark Duel" in result  # alphabetically first
+
+    def test_headline_format(self):
+        """Headline format: 'ModelA beats ModelB · X-Y at Scenario'."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_a",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_a",
+                winning_model="openai/openbmb/MiniCPM-8B",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+            _entry(
+                run_id="r3",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_b",
+                winning_model="google/gemma-12B",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+        ]
+        result = headline(entries)
+        assert result is not None
+        assert "beats" in result
+        assert "·" in result
+        assert "Debate Duel" in result
+        assert "2-1" in result  # MiniCPM beats Gemma 2-1
+
+
+# ── Tests: Purity (determinism and idempotency) ────────────────────────────────────
+
+
+class TestProjectionPurity:
+    """Verify that projections are deterministic regardless of entry order."""
+
+    def test_scenario_sessions_idempotent(self):
+        """Calling scenario_sessions twice returns the same result."""
+        entry = _entry(scenario="Debate Duel")
+        result1 = scenario_sessions([entry], "Debate Duel")
+        result2 = scenario_sessions([entry], "Debate Duel")
+        assert result1 == result2
+
+    def test_model_table_idempotent(self):
+        """Calling model_table twice returns the same result."""
+        entry = _entry()
+        result1 = model_table([entry])
+        result2 = model_table([entry])
+        assert result1 == result2
+
+    def test_agent_table_deterministic_order_independent(self):
+        """agent_table produces the same result regardless of entry order."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+                winner="alice",
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={"bob": CastBinding(model_endpoint="google/gemma-12B")},
+                winner="bob",
+            ),
+        ]
+        result1 = agent_table(entries, "Debate Duel")
+        result2 = agent_table(list(reversed(entries)), "Debate Duel")
+        assert result1 == result2
+
+    def test_fairness_table_deterministic_order_independent(self):
+        """fairness_table produces the same result regardless of entry order."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_a",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_b",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+        ]
+        result1 = fairness_table(entries, "Debate Duel")
+        result2 = fairness_table(list(reversed(entries)), "Debate Duel")
+        assert result1 == result2
+
+    def test_headline_deterministic_order_independent(self):
+        """headline produces the same result regardless of entry order."""
+        entries = [
+            _entry(
+                run_id="r1",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_a",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+            _entry(
+                run_id="r2",
+                scenario="Debate Duel",
+                cast={
+                    "debater_a": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B"),
+                    "debater_b": CastBinding(model_endpoint="google/gemma-12B"),
+                },
+                winner="debater_b",
+                symmetric_seats=["debater_a", "debater_b"],
+            ),
+        ]
+        result1 = headline(entries)
+        result2 = headline(list(reversed(entries)))
+        assert result1 == result2

tests/test_leaderboard_store.py

@@ -0,0 +1,531 @@
+"""Leaderboard store tests — persistence, round-trip, idempotence, E2E write path.
+
+This suite verifies:
+  - LeaderboardStore round-trip: record → read back via .entries() and .entries_for_scenario()
+  - Idempotent upsert on run_id (no duplicates, corrective records replace)
+  - Ordering: newest finished_at first, run_id tiebreak
+  - build_entry gating: only finished + winner + winning_model + competitive runs recorded
+  - Separate-table isolation: leaderboard_entries ≠ events (independent tables)
+  - End-to-end write path: FishbowlSession drive + finalize + leaderboard.recorded assertion
+
+Test strategy: Build entries directly for unit tests; drive a real FishbowlSession offline
+(deterministic stub) for the E2E test, reaching a verdict, calling finalize, and asserting
+the scoreboard row landed in the store.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import pytest
+
+from src.core.leaderboard_store import (
+    LeaderboardEntry,
+    LeaderboardStore,
+    _reset_store_cache,
+    build_entry,
+    make_leaderboard_store,
+)
+from src.core.run_index import CastBinding, RunSummary
+
+
+@pytest.fixture(autouse=True)
+def _reset_leaderboard_store():
+    """Reset the memoised store cache before and after each test to prevent cross-test leakage."""
+    _reset_store_cache()
+    yield
+    _reset_store_cache()
+
+
+def _entry(
+    run_id: str = "r1",
+    scenario: str = "Debate Duel",
+    seed: str = "seed123",
+    session_id: str | None = None,
+    competition_kind: str = "versus",
+    teams: dict[str, list[str]] | None = None,
+    symmetric_seats: list[str] | None = None,
+    cast: dict[str, CastBinding] | None = None,
+    winner: str | None = "alice",
+    winner_kind: str | None = "agent",
+    winning_model: str | None = "openai/openbmb/MiniCPM-8B",
+    winning_models: list[str] | None = None,
+    reason: str | None = "verdict",
+    turns: int = 5,
+    tokens: int = 200,
+    started_at: datetime | None = None,
+    finished_at: datetime | None = None,
+) -> LeaderboardEntry:
+    """Build a minimal LeaderboardEntry for testing."""
+    if started_at is None:
+        started_at = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+    if finished_at is None:
+        finished_at = started_at
+    if cast is None:
+        cast = {"alice": CastBinding(model_endpoint=winning_model)}
+    if winning_models is None:
+        winning_models = [winning_model] if winning_model else []
+    return LeaderboardEntry(
+        run_id=run_id,
+        session_id=session_id,
+        scenario=scenario,
+        seed=seed,
+        competition_kind=competition_kind,
+        teams=teams,
+        symmetric_seats=symmetric_seats,
+        cast=cast,
+        winner=winner,
+        winner_kind=winner_kind,
+        winning_model=winning_model,
+        winning_models=winning_models,
+        reason=reason,
+        turns=turns,
+        tokens=tokens,
+        started_at=started_at,
+        finished_at=finished_at,
+    )
+
+
+# ── Tests: LeaderboardStore round-trip and ordering ────────────────────────────────
+
+
+class TestLeaderboardStoreRoundTrip:
+    """Verify record → read-back: all fields survive serialization."""
+
+    def test_record_and_entries_round_trip(self):
+        """Recording an entry and reading back returns all fields intact."""
+        store = make_leaderboard_store(url="sqlite://")
+        entry = _entry(
+            run_id="r1",
+            scenario="Debate Duel",
+            seed="abc123",
+            cast={
+                "alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B", model_profile="large"),
+                "bob": CastBinding(model_endpoint="google/gemma-12B", model_profile="medium"),
+            },
+            teams={"team_a": ["alice"], "team_b": ["bob"]},
+            symmetric_seats=["seat_a", "seat_b"],
+            winner="alice",
+            winner_kind="agent",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            winning_models=["openai/openbmb/MiniCPM-8B"],
+        )
+        store.record(entry)
+        entries = store.entries()
+        assert len(entries) == 1
+        row = entries[0]
+        assert row.run_id == "r1"
+        assert row.scenario == "Debate Duel"
+        assert row.seed == "abc123"
+        assert row.winner == "alice"
+        assert row.winner_kind == "agent"
+        assert row.winning_model == "openai/openbmb/MiniCPM-8B"
+        assert row.winning_models == ["openai/openbmb/MiniCPM-8B"]
+        assert "alice" in row.cast
+        assert row.cast["alice"].model_endpoint == "openai/openbmb/MiniCPM-8B"
+        assert row.cast["alice"].model_profile == "large"
+        assert row.teams == {"team_a": ["alice"], "team_b": ["bob"]}
+        assert row.symmetric_seats == ["seat_a", "seat_b"]
+
+    def test_entries_for_scenario_filters_correctly(self):
+        """entries_for_scenario returns only entries from that scenario."""
+        store = make_leaderboard_store(url="sqlite://")
+        store.record(_entry(run_id="r1", scenario="Debate Duel"))
+        store.record(_entry(run_id="r2", scenario="Trivia Night"))
+        store.record(_entry(run_id="r3", scenario="Debate Duel"))
+        debate_entries = store.entries_for_scenario("Debate Duel")
+        assert len(debate_entries) == 2
+        assert all(e.scenario == "Debate Duel" for e in debate_entries)
+        trivia_entries = store.entries_for_scenario("Trivia Night")
+        assert len(trivia_entries) == 1
+        assert trivia_entries[0].scenario == "Trivia Night"
+
+    def test_recorded_at_stamped_when_unset(self):
+        """recorded_at is stamped to UTC now if unset (inside record)."""
+        store = make_leaderboard_store(url="sqlite://")
+        entry = _entry(run_id="r1")
+        # Entry has recorded_at=None (from _entry default)
+        assert entry.recorded_at is None
+        recorded = store.record(entry)
+        # After recording, recorded_at is stamped
+        assert recorded.recorded_at is not None
+        assert recorded.recorded_at.tzinfo is not None
+        # Read back should have the same timestamp
+        entries = store.entries()
+        assert entries[0].recorded_at is not None
+        assert entries[0].recorded_at.tzinfo is not None
+
+
+# ── Tests: Idempotent upsert on run_id ────────────────────────────────────────────
+
+
+class TestLeaderboardStoreIdempotence:
+    """Verify that recording the same run_id twice produces one row, and second replaces."""
+
+    def test_recording_same_run_id_twice_produces_one_row(self):
+        """Recording the same run_id twice yields exactly one row (no duplicate)."""
+        store = make_leaderboard_store(url="sqlite://")
+        entry1 = _entry(run_id="r1", winner="alice", winning_model="ModelA")
+        store.record(entry1)
+        entry2 = _entry(run_id="r1", winner="bob", winning_model="ModelB")  # same run_id, different winner
+        store.record(entry2)
+        entries = store.entries()
+        assert len(entries) == 1
+        assert entries[0].run_id == "r1"
+
+    def test_second_record_replaces_winner(self):
+        """A second record with the same run_id replaces the row (e.g., verdict supersedes budget close)."""
+        store = make_leaderboard_store(url="sqlite://")
+        entry1 = _entry(run_id="r1", winner="alice", winning_model="ModelA", reason="budget")
+        store.record(entry1)
+        entry2 = _entry(run_id="r1", winner="bob", winning_model="ModelB", reason="verdict")  # corrective
+        store.record(entry2)
+        entries = store.entries()
+        assert len(entries) == 1
+        assert entries[0].winner == "bob"
+        assert entries[0].winning_model == "ModelB"
+        assert entries[0].reason == "verdict"
+
+    def test_second_record_same_data_is_idempotent(self):
+        """Recording the same entry twice is idempotent (no changes)."""
+        store = make_leaderboard_store(url="sqlite://")
+        entry = _entry(run_id="r1")
+        store.record(entry)
+        entries1 = store.entries()
+        store.record(entry)
+        entries2 = store.entries()
+        assert len(entries1) == len(entries2) == 1
+        assert entries1[0].run_id == entries2[0].run_id
+
+
+# ── Tests: Ordering (newest finished_at first, run_id tiebreak) ───────────────────
+
+
+class TestLeaderboardStoreOrdering:
+    """Verify .entries() and .entries_for_scenario() ordering."""
+
+    def test_entries_newest_first(self):
+        """entries() returns newest finished_at first."""
+        store = make_leaderboard_store(url="sqlite://")
+        old = datetime(2025, 6, 1, 10, 0, 0, tzinfo=timezone.utc)
+        new = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+        store.record(_entry(run_id="r1", finished_at=old))
+        store.record(_entry(run_id="r2", finished_at=new))
+        entries = store.entries()
+        assert len(entries) == 2
+        assert entries[0].run_id == "r2"  # newer
+        assert entries[1].run_id == "r1"  # older
+
+    def test_entries_run_id_tiebreak_when_finished_at_same(self):
+        """When finished_at is equal, run_id breaks ties (ascending lexicographically)."""
+        store = make_leaderboard_store(url="sqlite://")
+        same_time = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+        store.record(_entry(run_id="r2", finished_at=same_time))
+        store.record(_entry(run_id="r1", finished_at=same_time))
+        entries = store.entries()
+        assert len(entries) == 2
+        # Both have same finished_at; run_id breaks ties in ascending order (r1 < r2)
+        assert entries[0].run_id == "r1"
+        assert entries[1].run_id == "r2"
+
+    def test_entries_for_scenario_ordering(self):
+        """entries_for_scenario also respects newest-first ordering."""
+        store = make_leaderboard_store(url="sqlite://")
+        old = datetime(2025, 6, 1, 10, 0, 0, tzinfo=timezone.utc)
+        new = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
+        store.record(_entry(run_id="r1", scenario="Debate Duel", finished_at=old))
+        store.record(_entry(run_id="r2", scenario="Debate Duel", finished_at=new))
+        store.record(_entry(run_id="r3", scenario="Trivia Night", finished_at=new))
+        debate = store.entries_for_scenario("Debate Duel")
+        assert len(debate) == 2
+        assert debate[0].run_id == "r2"  # newer
+        assert debate[1].run_id == "r1"  # older
+
+
+# ── Tests: build_entry gating (operator's requirement) ──────────────────────────────
+
+
+class TestBuildEntryGating:
+    """Verify build_entry returns None unless finished + winner + winning_model + competitive."""
+
+    def test_build_entry_returns_none_when_not_finished(self):
+        """build_entry returns None when finished_at is None."""
+        summary = RunSummary(
+            run_id="r1",
+            scenario="Debate Duel",
+            winner="alice",
+            winning_model="ModelA",
+            finished_at=None,
+        )
+
+        class MockCompetition:
+            kind = "versus"
+            teams = None
+            symmetric_seats = None
+
+        result = build_entry(summary, MockCompetition())
+        assert result is None
+
+    def test_build_entry_returns_none_when_no_winner(self):
+        """build_entry returns None when winner is None or empty."""
+        summary = RunSummary(
+            run_id="r1",
+            scenario="Debate Duel",
+            winner=None,
+            winning_model="ModelA",
+            finished_at=datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc),
+        )
+
+        class MockCompetition:
+            kind = "versus"
+            teams = None
+            symmetric_seats = None
+
+        result = build_entry(summary, MockCompetition())
+        assert result is None
+
+    def test_build_entry_returns_none_when_no_winning_model(self):
+        """build_entry returns None when neither winning_model nor winning_models has a value."""
+        summary = RunSummary(
+            run_id="r1",
+            scenario="Debate Duel",
+            winner="alice",
+            winning_model=None,
+            winning_models=[],
+            finished_at=datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc),
+        )
+
+        class MockCompetition:
+            kind = "versus"
+            teams = None
+            symmetric_seats = None
+
+        result = build_entry(summary, MockCompetition())
+        assert result is None
+
+    def test_build_entry_returns_none_when_competition_kind_is_none(self):
+        """build_entry returns None when competition.kind == 'none' (non-competitive)."""
+        summary = RunSummary(
+            run_id="r1",
+            scenario="Exploratory Run",
+            winner="alice",
+            winning_model="ModelA",
+            finished_at=datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc),
+        )
+
+        class MockCompetition:
+            kind = "none"
+            teams = None
+            symmetric_seats = None
+
+        result = build_entry(summary, MockCompetition())
+        assert result is None
+
+    def test_build_entry_returns_entry_when_all_gates_pass(self):
+        """build_entry returns a populated entry when finished + winner + winning_model + competitive."""
+        summary = RunSummary(
+            run_id="r1",
+            scenario="Debate Duel",
+            seed="seed123",
+            winner="alice",
+            winner_kind="agent",
+            winning_model="openai/openbmb/MiniCPM-8B",
+            winning_models=[],
+            finished_at=datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc),
+            started_at=datetime(2025, 6, 14, 9, 55, 0, tzinfo=timezone.utc),
+            cast={"alice": CastBinding(model_endpoint="openai/openbmb/MiniCPM-8B")},
+            turns=5,
+            tokens=200,
+        )
+
+        class MockCompetition:
+            kind = "versus"
+            teams = None
+            symmetric_seats = ["debater_a"]
+
+        entry = build_entry(summary, MockCompetition())
+        assert entry is not None
+        assert entry.run_id == "r1"
+        assert entry.scenario == "Debate Duel"
+        assert entry.winner == "alice"
+        assert entry.winning_model == "openai/openbmb/MiniCPM-8B"
+        assert entry.competition_kind == "versus"
+
+    def test_build_entry_merges_winning_model_into_winning_models(self):
+        """build_entry includes both winning_model and winning_models in the merged list."""
+        summary = RunSummary(
+            run_id="r1",
+            scenario="Debate Duel",
+            winner="alice",
+            winning_model="ModelA",
+            winning_models=["ModelB"],
+            finished_at=datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc),
+        )
+
+        class MockCompetition:
+            kind = "versus"
+            teams = None
+            symmetric_seats = None
+
+        entry = build_entry(summary, MockCompetition())
+        assert entry is not None
+        assert entry.winning_model == "ModelA"
+        assert set(entry.winning_models) == {"ModelA", "ModelB"}
+
+
+# ── Tests: Separate-table isolation (leaderboard_entries ≠ events) ────────────────
+
+
+class TestLeaderboardStoreTableIsolation:
+    """Verify leaderboard_entries and events tables are independent."""
+
+    def test_leaderboard_store_creates_leaderboard_entries_table(self):
+        """LeaderboardStore creates a dedicated leaderboard_entries table, not events."""
+        store = make_leaderboard_store(url="sqlite://")
+        entry = _entry(run_id="r1")
+        store.record(entry)
+        # Query the store's table to ensure it's leaderboard_entries
+        entries = store.entries()
+        assert len(entries) == 1
+        assert entries[0].run_id == "r1"
+
+    def test_multiple_databases_do_not_share_store(self):
+        """Two stores on different SQLite files have independent data."""
+        store1 = LeaderboardStore(url="sqlite:///:memory:")
+        store2 = LeaderboardStore(url="sqlite:///:memory:")  # different in-memory DB
+        store1.record(_entry(run_id="r1"))
+        entries1 = store1.entries()
+        entries2 = store2.entries()
+        assert len(entries1) == 1
+        assert len(entries2) == 0  # store2 was never written to
+
+
+# ── Tests: E2E write path (FishbowlSession → finalize → store) ────────────────────
+
+
+class TestLeaderboardE2E:
+    """End-to-end: drive a FishbowlSession, finalize, assert leaderboard row recorded."""
+
+    def test_e2e_write_path_via_build_entry(self):
+        """Test the write path: build_entry → store.record → leaderboard_entries table."""
+        from src.core.leaderboard_store import build_entry
+
+        store = make_leaderboard_store(url="sqlite://")
+
+        # Simulate a finished competitive run with a winner + winning_models
+        summary = RunSummary(
+            run_id="e2e-r1",
+            scenario="twenty-sprouts",
+            seed="test_seed_e2e",
+            winner="keeper",  # Team winner
+            winner_kind="team",
+            winning_model=None,
+            winning_models=["stub:balanced", "stub:fast"],
+            finished_at=datetime(2025, 6, 14, 10, 5, 0, tzinfo=timezone.utc),
+            started_at=datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc),
+            cast={
+                "secret-keeper": CastBinding(model_endpoint="stub:balanced", model_profile="balanced"),
+                "sprout-guesser": CastBinding(model_endpoint="stub:fast", model_profile="fast"),
+            },
+            turns=10,
+            tokens=5000,
+        )
+
+        # Mock competition config
+        class MockCompetition:
+            kind = "versus"
+            teams = {"guesser": ["sprout-guesser"], "keeper": ["secret-keeper"]}
+            symmetric_seats = None
+
+        # Build and record the entry
+        entry = build_entry(summary, MockCompetition())
+        assert entry is not None, "Entry should pass the eligibility gate"
+
+        recorded = store.record(entry)
+        assert recorded.run_id == "e2e-r1"
+
+        # Read back from store
+        entries = store.entries()
+        assert len(entries) == 1
+        row = entries[0]
+        assert row.run_id == "e2e-r1"
+        assert row.scenario == "twenty-sprouts"
+        assert row.winner == "keeper"
+        assert row.winner_kind == "team"
+        assert row.winning_models == ["stub:balanced", "stub:fast"]
+        assert row.competition_kind == "versus"
+        assert row.finished_at is not None
+
+    def test_e2e_non_competitive_scenario_not_recorded(self):
+        """Drive a non-competitive scenario (if any) and verify no row is recorded."""
+        from src.ui.fishbowl.session import FishbowlSession
+
+        # "thousand-token-wood" is non-competitive (kind="none")
+        store = make_leaderboard_store(url="sqlite://")
+        session = FishbowlSession("thousand-token-wood")
+        session._leaderboard = store
+
+        session.reset(seed="test_seed_456")
+        session.step(5)
+
+        # Finalize without forcing verdict (or with a budget close)
+        session.finalize("budget")
+
+        # No row should be recorded for a non-competitive run
+        entries = store.entries()
+        assert len(entries) == 0
+
+    def test_e2e_abandoned_run_not_recorded(self):
+        """Drive a run, finalize with no winner, verify no row recorded."""
+        from src.ui.fishbowl.session import FishbowlSession
+
+        store = make_leaderboard_store(url="sqlite://")
+        session = FishbowlSession("twenty-sprouts")
+        session._leaderboard = store
+
+        session.reset(seed="test_seed_789")
+        session.step(2)
+
+        # Finalize without a verdict (user stops, no winner)
+        session.finalize("user_stop")
+
+        # No row should be recorded
+        entries = store.entries()
+        assert len(entries) == 0
+
+    def test_e2e_competitive_verdict_records_row(self):
+        """Positive E2E: a real FishbowlSession reaching a verdict writes exactly one row.
+
+        Drives "twenty-sprouts" (a versus, code-decided ground-truth game) offline with the
+        deterministic stub.  Each seat is bound to an explicit ``model_endpoint`` (what the
+        Lab does via ``cast_models``) so the run.started cast map carries endpoints and the
+        "winning model selected" gate is satisfied — without that, the run is finished and
+        won but has no concrete winning model, so no row is recorded (see
+        ``test_e2e_abandoned_run_not_recorded`` for the no-winner case).  Exercises the full
+        ``finalize → _record_leaderboard → build_entry → store.record`` glue.
+        """
+        from src.ui.fishbowl.session import FishbowlSession
+
+        store = make_leaderboard_store(url="sqlite://")
+        session = FishbowlSession("twenty-sprouts")
+        session._leaderboard = store
+        # Bind a distinct endpoint to every seat (the Lab's cast_models, in miniature).
+        for agent in session.conductor.scenario.agents:
+            agent.manifest = agent.manifest.model_copy(update={"model_endpoint": f"openai/test/{agent.manifest.name}"})
+
+        session.reset(seed="seed-e2e")
+        for _ in range(12):
+            session.step(1)
+        ruled = session.force_verdict()  # lands judge.verdict + finalize("verdict")
+        assert ruled is True
+
+        rows = [r for r in store.entries() if r.run_id == session.conductor.run_id]
+        assert len(rows) == 1
+        row = rows[0]
+        assert row.scenario == "twenty-sprouts"
+        assert row.competition_kind == "versus"
+        assert row.reason == "verdict"
+        assert row.winner  # a real seat was crowned by the code-decided judge
+        # The winner's bound endpoint is credited as the winning model.
+        assert row.winning_models == [f"openai/test/{row.winner}"]
+        assert row.winning_model == f"openai/test/{row.winner}"