Raw elo

app.py

@@ -1,4 +1,4 @@
-"""g-Harmony - Galaxy Interestingness Tournament."""
+"""Perihelion - Galaxy Interestingness Ranking."""
 
 import logging
 
@@ -11,19 +11,17 @@ from src.callbacks import register_callbacks
 from src import elo
 from src.galaxy_data_loader import sample_pool_streaming, image_cache
 from src.galaxy_profiles import register_metadata
-from src.config import POOL_SIZE
+from src.config import POOL_SIZE, POOL_SEED
 
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
 )
-# Suppress noisy httpx request logs
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logger = logging.getLogger(__name__)
 
 
 def create_app() -> dash.Dash:
-    """Create and configure the Dash application."""
     app = dash.Dash(
         __name__,
         external_stylesheets=[dbc.themes.BOOTSTRAP, dbc.icons.FONT_AWESOME],
@@ -34,7 +32,6 @@ def create_app() -> dash.Dash:
 
     server = app.server
 
-    # Serve galaxy images from cache (populated at startup via streaming)
     @server.route("/galaxy-images/<int:row_index>.jpg")
     def serve_galaxy_image(row_index):
         path = image_cache.get_path(row_index)
@@ -42,41 +39,20 @@ def create_app() -> dash.Dash:
             abort(404)
         return send_file(path, mimetype="image/jpeg")
 
-    # Initialize tournament
-    logger.info("Loading tournament state...")
-    loaded = elo.load_tournament_state()
+    # Always stream with the fixed seed so every participant sees the same pool
+    logger.info("Streaming pool of %d galaxies (seed=%d)...", POOL_SIZE, POOL_SEED)
+    pool, metadata_map, _ = sample_pool_streaming(POOL_SIZE, seed=POOL_SEED)
+    register_metadata(metadata_map)
 
-    # Always re-stream the pool to populate the image + metadata caches.
-    # On reload we reuse the saved seed so the same galaxies are sampled in the
-    # same order, keeping ELO rankings consistent across restarts.
-    seed = elo.get_pool_seed() if loaded else None
-    logger.info(
-        "Streaming pool of %d galaxies (seed=%s)...",
-        POOL_SIZE,
-        seed if seed is not None else "random",
-    )
-    try:
-        pool, metadata_map, used_seed = sample_pool_streaming(POOL_SIZE, seed=seed)
-        register_metadata(metadata_map)
-        if not loaded:
-            elo.initialize_tournament(pool, pool_seed=used_seed)
-        else:
-            # Persist seed into existing state so future reloads can reuse it
-            elo.set_pool_seed(used_seed)
-            logger.info(
-                "Tournament state restored: round %d, %d active galaxies",
-                elo.get_tournament_info().get("current_round", 1),
-                len(pool),
-            )
-    except Exception as e:
-        logger.error("Failed to stream galaxy pool: %s", e)
-        raise
+    # Load persisted ELO state or start fresh
+    if not elo.load_elo_state():
+        logger.info("No saved state found — initializing fresh ELO rankings")
+        elo.initialize_elo(pool)
 
-    # Layout and callbacks
     app.layout = create_layout()
     register_callbacks(app)
 
-    logger.info("g-Harmony ready!")
+    logger.info("Perihelion ready!")
     return app
 
 

dataset_config.yaml

@@ -4,10 +4,6 @@ split: "train"
 image_column: "image"
 id_column: "id_str"
 pool_size: 1000
-min_comparisons_per_round: 3
-max_comparisons_per_round: 5
-elimination_fraction: 0.5
-final_pool_size: 100
+pool_seed: 42
 image_cache_dir: "cache/images"
 image_cache_max_bytes: 524288000  # 500 MB
-cache_prefetch_count: 20

src/callbacks.py

@@ -1,4 +1,4 @@
-"""Dash callbacks for g-Harmony tournament."""
+"""Dash callbacks for Perihelion."""
 
 import uuid
 import logging
@@ -17,43 +17,27 @@ logger = logging.getLogger(__name__)
 def register_callbacks(app):
     """Register all Dash callbacks."""
 
-    # Initial load: populate the arena with the first pair
     @app.callback(
         [
             Output("arena-container", "children"),
             Output("current-pair", "data"),
             Output("leaderboard-body", "children"),
             Output("session-id", "data"),
-            Output("tournament-info", "data"),
+            Output("elo-info", "data"),
             Output("progress-dashboard-container", "children"),
         ],
         Input("arena-container", "id"),
     )
     def initial_load(_):
         session_id = uuid.uuid4().hex
-
         pair = elo.select_pair(set())
-        if pair is None:
-            arena = create_arena(None, None)
-            current_pair_data = None
-        else:
-            arena = create_arena(pair[0], pair[1])
-            current_pair_data = list(pair)
-
+        arena = create_arena(pair[0], pair[1]) if pair else create_arena(None, None)
+        current_pair_data = list(pair) if pair else None
         leaderboard = create_leaderboard_rows(elo.get_leaderboard())
-        info = elo.get_tournament_info()
+        info = elo.get_info()
         dashboard = create_progress_dashboard(info)
+        return arena, current_pair_data, leaderboard, session_id, info, dashboard
 
-        return (
-            arena,
-            current_pair_data,
-            leaderboard,
-            session_id,
-            info,
-            dashboard,
-        )
-
-    # Card click: pick a winner, update ELO, load next pair
     @app.callback(
         [
             Output("arena-container", "children", allow_duplicate=True),
@@ -61,13 +45,10 @@ def register_callbacks(app):
             Output("seen-pairs", "data", allow_duplicate=True),
             Output("comparison-count", "data", allow_duplicate=True),
             Output("leaderboard-body", "children", allow_duplicate=True),
-            Output("tournament-info", "data", allow_duplicate=True),
+            Output("elo-info", "data", allow_duplicate=True),
             Output("progress-dashboard-container", "children", allow_duplicate=True),
         ],
-        [
-            Input("left-card-btn", "n_clicks"),
-            Input("right-card-btn", "n_clicks"),
-        ],
+        [Input("left-card-btn", "n_clicks"), Input("right-card-btn", "n_clicks")],
         [
             State("current-pair", "data"),
             State("seen-pairs", "data"),
@@ -79,10 +60,8 @@ def register_callbacks(app):
     def handle_card_click(left_clicks, right_clicks, current_pair, seen_pairs, comp_count, session_id):
         if not ctx.triggered_id:
             raise PreventUpdate
-
         if (left_clicks in [0, None]) and (right_clicks in [0, None]):
             raise PreventUpdate
-
         if current_pair is None:
             raise PreventUpdate
 
@@ -91,94 +70,54 @@ def register_callbacks(app):
         if comp_count is None:
             comp_count = 0
 
-        # Determine winner
-        triggered = ctx.triggered_id
-        if triggered == "left-card-btn":
-            winner_side = "left"
-        elif triggered == "right-card-btn":
-            winner_side = "right"
-        else:
-            raise PreventUpdate
-
-        left_idx = current_pair[0]
-        right_idx = current_pair[1]
-
-        if winner_side == "left":
+        left_idx, right_idx = current_pair[0], current_pair[1]
+        if ctx.triggered_id == "left-card-btn":
             winner_idx, loser_idx = left_idx, right_idx
         else:
             winner_idx, loser_idx = right_idx, left_idx
 
-        # Record comparison
         result = elo.record_comparison(winner_idx, loser_idx)
 
-        # Log to HF
         log_query_event({
             "log_type": "comparison",
             "session_id": session_id,
             "galaxy_left": left_idx,
             "galaxy_right": right_idx,
             "winner": winner_idx,
-            "round": result["round"],
-            "round_advanced": result["round_advanced"],
-            "elo_left_before": result["winner_elo_before"] if winner_side == "left" else result["loser_elo_before"],
-            "elo_right_before": result["loser_elo_before"] if winner_side == "left" else result["winner_elo_before"],
-            "elo_left_after": result["winner_elo_after"] if winner_side == "left" else result["loser_elo_after"],
-            "elo_right_after": result["loser_elo_after"] if winner_side == "left" else result["winner_elo_after"],
+            "elo_left_before": result["winner_elo_before"] if winner_idx == left_idx else result["loser_elo_before"],
+            "elo_right_before": result["loser_elo_before"] if winner_idx == left_idx else result["winner_elo_before"],
+            "elo_left_after": result["winner_elo_after"] if winner_idx == left_idx else result["loser_elo_after"],
+            "elo_right_after": result["loser_elo_after"] if winner_idx == left_idx else result["winner_elo_after"],
         })
 
-        # Update seen pairs and count
         seen_pairs.append([left_idx, right_idx])
         comp_count += 1
 
-        # Select next pair
-        seen_set = set()
-        for p in seen_pairs:
-            seen_set.add((p[0], p[1]))
-            seen_set.add((p[1], p[0]))
-
+        seen_set = {(p[0], p[1]) for p in seen_pairs} | {(p[1], p[0]) for p in seen_pairs}
         pair = elo.select_pair(seen_set)
+        arena = create_arena(pair[0], pair[1]) if pair else create_arena(None, None)
+        current_pair_data = list(pair) if pair else None
 
-        if pair is None:
-            arena = create_arena(None, None)
-            current_pair_data = None
-        else:
-            arena = create_arena(pair[0], pair[1])
-            current_pair_data = list(pair)
-
-        info = elo.get_tournament_info()
+        info = elo.get_info()
         leaderboard = create_leaderboard_rows(elo.get_leaderboard())
         dashboard = create_progress_dashboard(info)
 
-        return (
-            arena,
-            current_pair_data,
-            seen_pairs,
-            comp_count,
-            leaderboard,
-            info,
-            dashboard,
-        )
+        return arena, current_pair_data, seen_pairs, comp_count, leaderboard, info, dashboard
 
-    # Progress dashboard update (interval-driven)
     @app.callback(
         [
-            Output("tournament-info", "data", allow_duplicate=True),
+            Output("elo-info", "data", allow_duplicate=True),
             Output("progress-dashboard-container", "children", allow_duplicate=True),
         ],
         Input("progress-interval", "n_intervals"),
         prevent_initial_call=True,
     )
     def update_progress(n_intervals):
-        info = elo.get_tournament_info()
-        dashboard = create_progress_dashboard(info)
-        return info, dashboard
+        info = elo.get_info()
+        return info, create_progress_dashboard(info)
 
-    # Leaderboard toggle
     @app.callback(
-        [
-            Output("leaderboard-body", "style"),
-            Output("leaderboard-arrow", "style"),
-        ],
+        [Output("leaderboard-body", "style"), Output("leaderboard-arrow", "style")],
         Input("leaderboard-toggle", "n_clicks"),
         State("leaderboard-body", "style"),
         prevent_initial_call=True,
@@ -194,7 +133,6 @@ def register_callbacks(app):
             {"transition": "transform 0.3s", "fontSize": "0.65rem", "transform": "rotate(0deg)"},
         )
 
-    # Reset session (client-side only — does NOT restart tournament)
     @app.callback(
         [
             Output("arena-container", "children", allow_duplicate=True),
@@ -209,23 +147,8 @@ def register_callbacks(app):
     def reset_session(n_clicks):
         if not n_clicks:
             raise PreventUpdate
-
         pair = elo.select_pair(set())
-        if pair is None:
-            arena = create_arena(None, None)
-            current_pair_data = None
-        else:
-            arena = create_arena(pair[0], pair[1])
-            current_pair_data = list(pair)
-
+        arena = create_arena(pair[0], pair[1]) if pair else create_arena(None, None)
+        current_pair_data = list(pair) if pair else None
         leaderboard = create_leaderboard_rows(elo.get_leaderboard())
-
-        return (
-            arena,
-            current_pair_data,
-            [],
-            0,
-            leaderboard,
-        )
-
-
+        return arena, current_pair_data, [], 0, leaderboard

src/components.py

@@ -340,7 +340,7 @@ def create_arena(left_idx=None, right_idx=None):
         return html.Div(
             [
                 html.Div(
-                    "Tournament Complete!",
+                    "You've seen every pair!",
                     style={
                         "fontFamily": "'Playfair Display', serif",
                         "fontSize": "1.8rem",
@@ -350,8 +350,7 @@ def create_arena(left_idx=None, right_idx=None):
                     },
                 ),
                 html.P(
-                    "The top galaxies have been identified. "
-                    "Check the leaderboard below for final rankings!",
+                    "Reset your session to keep voting and refine the rankings.",
                     style={"color": "rgba(255,255,255,0.5)", "maxWidth": "400px", "margin": "0 auto 24px"},
                 ),
                 dbc.Button(
@@ -393,40 +392,25 @@ def create_arena(left_idx=None, right_idx=None):
 
 
 def create_progress_dashboard(info: dict):
-    """Build the tournament progress dashboard."""
-    current_round = info.get("current_round", 0)
+    """Build the ELO ranking progress dashboard."""
     pool_size = info.get("pool_size", 0)
     total_comps = info.get("total_comparisons", 0)
-    eliminated_count = info.get("eliminated_count", 0)
-    est_remaining = info.get("est_remaining_this_round", 0)
     elo_values = info.get("elo_values", [])
-    tournament_complete = info.get("tournament_complete", False)
 
-    # Stats row
-    status_text = "COMPLETE" if tournament_complete else f"ROUND {current_round}"
     stats_row = dbc.Row(
         [
-            dbc.Col(html.Div([
-                html.Div(status_text, className="progress-stat-value"),
-                html.Div("STATUS", className="progress-stat-label"),
-            ], className="progress-stat"), width=3),
             dbc.Col(html.Div([
                 html.Div(str(pool_size), className="progress-stat-value"),
-                html.Div("ACTIVE", className="progress-stat-label"),
-            ], className="progress-stat"), width=3),
+                html.Div("GALAXIES", className="progress-stat-label"),
+            ], className="progress-stat"), width=6),
             dbc.Col(html.Div([
                 html.Div(str(total_comps), className="progress-stat-value"),
                 html.Div("COMPARISONS", className="progress-stat-label"),
-            ], className="progress-stat"), width=3),
-            dbc.Col(html.Div([
-                html.Div(str(eliminated_count), className="progress-stat-value"),
-                html.Div("ELIMINATED", className="progress-stat-label"),
-            ], className="progress-stat"), width=3),
+            ], className="progress-stat"), width=6),
         ],
         className="mb-3",
     )
 
-    # ELO distribution histogram
     if elo_values:
         fig = go.Figure(data=[go.Histogram(
             x=elo_values,
@@ -443,47 +427,14 @@ def create_progress_dashboard(info: dict):
             font_size=10,
             margin=dict(l=30, r=10, t=10, b=30),
             height=120,
-            xaxis=dict(
-                gridcolor="rgba(255,255,255,0.05)",
-                title_text="ELO Rating",
-                title_font_size=9,
-            ),
-            yaxis=dict(
-                gridcolor="rgba(255,255,255,0.05)",
-                title_text="Count",
-                title_font_size=9,
-            ),
-        )
-        histogram = dcc.Graph(
-            figure=fig,
-            config={"displayModeBar": False},
-            style={"height": "120px"},
+            xaxis=dict(gridcolor="rgba(255,255,255,0.05)", title_text="ELO Rating", title_font_size=9),
+            yaxis=dict(gridcolor="rgba(255,255,255,0.05)", title_text="Count", title_font_size=9),
         )
+        histogram = dcc.Graph(figure=fig, config={"displayModeBar": False}, style={"height": "120px"})
     else:
         histogram = html.Div()
 
-    # Remaining estimate
-    remaining_text = (
-        "Tournament complete!" if tournament_complete
-        else f"~{est_remaining} comparisons remaining this round"
-    )
-
-    return html.Div(
-        [
-            stats_row,
-            histogram,
-            html.Div(
-                remaining_text,
-                style={
-                    "textAlign": "center",
-                    "fontSize": "0.7rem",
-                    "color": "rgba(255,255,255,0.3)",
-                    "marginTop": "8px",
-                },
-            ),
-        ],
-        className="progress-dashboard",
-    )
+    return html.Div([stats_row, histogram], className="progress-dashboard")
 
 
 def create_leaderboard_rows(leaderboard_data):
@@ -571,7 +522,7 @@ def create_layout():
             dcc.Store(id="seen-pairs", data=[]),
             dcc.Store(id="current-pair", data=None),
             dcc.Store(id="comparison-count", data=0),
-            dcc.Store(id="tournament-info", data={}),
+            dcc.Store(id="elo-info", data={}),
             dcc.Store(id="session-id", data=""),
 
             # Interval for progress updates

src/config.py

@@ -1,4 +1,4 @@
-"""g-Harmony configuration."""
+"""Perihelion configuration."""
 
 import os
 from pathlib import Path
@@ -8,7 +8,7 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-# HuggingFace logging (secrets stay as env vars)
+# HuggingFace (secrets stay as env vars)
 HF_TOKEN = os.getenv("HF_TOKEN", "")
 HF_LOG_REPO_ID = os.getenv("HF_LOG_REPO_ID", "")
 HF_LOG_EVERY_MINUTES = int(os.getenv("HF_LOG_EVERY_MINUTES", "10"))
@@ -28,10 +28,6 @@ DATASET_SPLIT = _dataset_config.get("split", "train")
 IMAGE_COLUMN = _dataset_config.get("image_column", "image")
 ID_COLUMN = _dataset_config.get("id_column", "id_str")
 POOL_SIZE = _dataset_config.get("pool_size", 300)
-MIN_COMPS_PER_ROUND = _dataset_config.get("min_comparisons_per_round", 3)
-MAX_COMPS_PER_ROUND = _dataset_config.get("max_comparisons_per_round", 5)
-ELIMINATION_FRACTION = _dataset_config.get("elimination_fraction", 0.5)
-FINAL_POOL_SIZE = _dataset_config.get("final_pool_size", 100)
+POOL_SEED = _dataset_config.get("pool_seed", 42)
 IMAGE_CACHE_DIR = _dataset_config.get("image_cache_dir", "cache/images")
 IMAGE_CACHE_MAX_BYTES = _dataset_config.get("image_cache_max_bytes", 524288000)
-CACHE_PREFETCH_COUNT = _dataset_config.get("cache_prefetch_count", 20)

src/elo.py

@@ -1,9 +1,8 @@
-"""ELO rating system with successive-halving tournament engine."""
+"""ELO rating system for a persistent galaxy ranking."""
 
 from __future__ import annotations
 
 import json
-import math
 import random
 import threading
 import logging
@@ -12,14 +11,12 @@ from pathlib import Path
 from huggingface_hub import CommitScheduler, hf_hub_download
 
 from src.config import (
+    DATASET_ID,
     DEFAULT_ELO,
     ELO_K_FACTOR,
-    ELIMINATION_FRACTION,
-    FINAL_POOL_SIZE,
     HF_LOG_EVERY_MINUTES,
     HF_LOG_REPO_ID,
     HF_TOKEN,
-    MIN_COMPS_PER_ROUND,
 )
 
 logger = logging.getLogger(__name__)
@@ -28,61 +25,44 @@ STATE_DIR = Path("state")
 STATE_FILE = STATE_DIR / "elo_state.json"
 
 _lock = threading.Lock()
-_state: TournamentState | None = None
+_state: EloState | None = None
 _state_scheduler = None
 
 
-class TournamentState:
-    """Full tournament state for successive-halving rounds."""
+class EloState:
+    """ELO ratings for a fixed pool of galaxies."""
 
     def __init__(
         self,
-        active_pool: list[int],
+        pool: list[int],
         elo_ratings: dict[int, float] | None = None,
-        round_comparisons: dict[int, int] | None = None,
-        current_round: int = 1,
-        eliminated: list[int] | None = None,
         total_comparisons: int = 0,
-        tournament_complete: bool = False,
-        pool_seed: int | None = None,
+        dataset_id: str = "",
     ):
-        self.active_pool = list(active_pool)
-        self.elo_ratings = elo_ratings or {idx: DEFAULT_ELO for idx in active_pool}
-        self.round_comparisons = round_comparisons or {idx: 0 for idx in active_pool}
-        self.current_round = current_round
-        self.eliminated = eliminated or []
+        self.pool = list(pool)
+        self.elo_ratings = elo_ratings or {idx: DEFAULT_ELO for idx in pool}
         self.total_comparisons = total_comparisons
-        self.tournament_complete = tournament_complete
-        self.pool_seed = pool_seed
+        self.dataset_id = dataset_id
 
     def to_dict(self) -> dict:
         return {
-            "active_pool": self.active_pool,
+            "pool": self.pool,
             "elo_ratings": {str(k): v for k, v in self.elo_ratings.items()},
-            "round_comparisons": {str(k): v for k, v in self.round_comparisons.items()},
-            "current_round": self.current_round,
-            "eliminated": self.eliminated,
             "total_comparisons": self.total_comparisons,
-            "tournament_complete": self.tournament_complete,
-            "pool_seed": self.pool_seed,
+            "dataset_id": self.dataset_id,
         }
 
     @classmethod
-    def from_dict(cls, d: dict) -> TournamentState:
+    def from_dict(cls, d: dict) -> EloState:
         return cls(
-            active_pool=d["active_pool"],
+            pool=d["pool"],
             elo_ratings={int(k): v for k, v in d["elo_ratings"].items()},
-            round_comparisons={int(k): v for k, v in d["round_comparisons"].items()},
-            current_round=d["current_round"],
-            eliminated=d.get("eliminated", []),
             total_comparisons=d.get("total_comparisons", 0),
-            tournament_complete=d.get("tournament_complete", False),
-            pool_seed=d.get("pool_seed"),
+            dataset_id=d.get("dataset_id", ""),
         )
 
 
 def _init_scheduler():
-    """Initialize the CommitScheduler for state persistence."""
     global _state_scheduler
     if not HF_LOG_REPO_ID:
         return
@@ -98,24 +78,26 @@ def _init_scheduler():
     logger.info("ELO state scheduler initialized (repo=%s)", HF_LOG_REPO_ID)
 
 
-def initialize_tournament(pool_indices: list[int], pool_seed: int | None = None):
-    """Create a fresh tournament with the given pool."""
+def initialize_elo(pool_indices: list[int]):
+    """Create fresh ELO state for the given pool."""
     global _state
     with _lock:
-        _state = TournamentState(active_pool=pool_indices, pool_seed=pool_seed)
+        _state = EloState(pool=pool_indices, dataset_id=DATASET_ID)
     _save_state()
     _init_scheduler()
-    logger.info("Tournament initialized with %d galaxies", len(pool_indices))
+    logger.info("ELO state initialized with %d galaxies", len(pool_indices))
 
 
-def load_tournament_state() -> bool:
-    """Try to restore tournament state from HF or local file.
+def load_elo_state() -> bool:
+    """Try to restore ELO state from HF Hub or local file.
 
+    Discards saved state if it belongs to a different dataset.
     Returns True if state was loaded, False if starting fresh.
     """
     global _state
 
-    # Try HF first
+    raw = None
+
     if HF_LOG_REPO_ID:
         try:
             local_path = hf_hub_download(
@@ -126,46 +108,46 @@ def load_tournament_state() -> bool:
             )
             with open(local_path) as f:
                 raw = json.load(f)
-            # Check if it's the new tournament format
-            if "active_pool" in raw:
-                with _lock:
-                    _state = TournamentState.from_dict(raw)
-                _init_scheduler()
-                _save_state()
-                logger.info(
-                    "Loaded tournament state from HF: round %d, %d active galaxies",
-                    _state.current_round,
-                    len(_state.active_pool),
-                )
-                return True
-            else:
-                logger.info("Old-format state found on HF, ignoring")
+            logger.info("Loaded state from HF Hub")
         except Exception as e:
             logger.warning("Could not load state from HF: %s", e)
 
-    # Try local file
-    if STATE_FILE.exists():
+    if raw is None and STATE_FILE.exists():
         try:
             with open(STATE_FILE) as f:
                 raw = json.load(f)
-            if "active_pool" in raw:
-                with _lock:
-                    _state = TournamentState.from_dict(raw)
-                _init_scheduler()
-                logger.info(
-                    "Loaded tournament state from local file: round %d, %d active",
-                    _state.current_round,
-                    len(_state.active_pool),
-                )
-                return True
+            logger.info("Loaded state from local file")
         except Exception as e:
             logger.warning("Could not load local state: %s", e)
 
-    return False
+    if raw is None:
+        return False
+
+    # Validate dataset match
+    saved_dataset = raw.get("dataset_id", "")
+    if saved_dataset and saved_dataset != DATASET_ID:
+        logger.info(
+            "Saved state is for dataset '%s', current is '%s' — starting fresh",
+            saved_dataset,
+            DATASET_ID,
+        )
+        return False
+
+    # Must have 'pool' key (new format); ignore old tournament-format files
+    if "pool" not in raw:
+        logger.info("Saved state is old format — starting fresh")
+        return False
+
+    with _lock:
+        _state = EloState.from_dict(raw)
+    _init_scheduler()
+    _save_state()
+    logger.info("Restored ELO state: %d galaxies, %d comparisons",
+                len(_state.pool), _state.total_comparisons)
+    return True
 
 
 def _save_state():
-    """Write current tournament state to local JSON file."""
     STATE_DIR.mkdir(parents=True, exist_ok=True)
     with _lock:
         if _state is None:
@@ -180,13 +162,10 @@ def _expected_score(rating_a: float, rating_b: float) -> float:
 
 
 def record_comparison(winner_idx: int, loser_idx: int) -> dict:
-    """Record a comparison, update ELO, check round completion.
-
-    Returns dict with before/after ratings and round info.
-    """
+    """Record a comparison and update ELO ratings."""
     with _lock:
         if _state is None:
-            raise RuntimeError("Tournament not initialized")
+            raise RuntimeError("ELO state not initialized")
 
         elo_w_before = _state.elo_ratings.get(winner_idx, DEFAULT_ELO)
         elo_l_before = _state.elo_ratings.get(loser_idx, DEFAULT_ELO)
@@ -199,14 +178,8 @@ def record_comparison(winner_idx: int, loser_idx: int) -> dict:
 
         _state.elo_ratings[winner_idx] = elo_w_after
         _state.elo_ratings[loser_idx] = elo_l_after
-
-        _state.round_comparisons[winner_idx] = _state.round_comparisons.get(winner_idx, 0) + 1
-        _state.round_comparisons[loser_idx] = _state.round_comparisons.get(loser_idx, 0) + 1
         _state.total_comparisons += 1
 
-        round_before = _state.current_round
-        advanced = _check_and_advance_round()
-
     _save_state()
 
     return {
@@ -214,204 +187,68 @@ def record_comparison(winner_idx: int, loser_idx: int) -> dict:
         "winner_elo_after": elo_w_after,
         "loser_elo_before": elo_l_before,
         "loser_elo_after": elo_l_after,
-        "round": round_before,
-        "round_advanced": advanced,
     }
 
 
-def _check_and_advance_round() -> bool:
-    """Check if all active galaxies have enough comparisons; if so, advance.
-
-    Caller must hold _lock.
-    Returns True if a round was advanced.
-    """
-    if _state is None or _state.tournament_complete:
-        return False
-
-    for idx in _state.active_pool:
-        if _state.round_comparisons.get(idx, 0) < MIN_COMPS_PER_ROUND:
-            return False
-
-    # All galaxies have enough comparisons — advance round
-    _advance_round()
-    return True
-
-
-def _advance_round():
-    """Eliminate bottom fraction, advance to next round. Caller holds _lock."""
-    if _state is None:
-        return
-
-    # Sort active pool by ELO descending
-    sorted_pool = sorted(
-        _state.active_pool,
-        key=lambda idx: _state.elo_ratings.get(idx, DEFAULT_ELO),
-        reverse=True,
-    )
-
-    keep_count = max(
-        FINAL_POOL_SIZE,
-        int(math.ceil(len(sorted_pool) * (1 - ELIMINATION_FRACTION))),
-    )
-
-    survivors = sorted_pool[:keep_count]
-    eliminated = sorted_pool[keep_count:]
-
-    _state.eliminated.extend(eliminated)
-    _state.active_pool = survivors
-    _state.round_comparisons = {idx: 0 for idx in survivors}
-    _state.current_round += 1
-
-    if len(survivors) <= FINAL_POOL_SIZE:
-        _state.tournament_complete = True
-        logger.info("Tournament complete! %d galaxies in final pool.", len(survivors))
-    else:
-        logger.info(
-            "Round %d: %d -> %d galaxies (eliminated %d)",
-            _state.current_round - 1,
-            len(sorted_pool),
-            len(survivors),
-            len(eliminated),
-        )
-
-
 def select_pair(seen_pairs: set[tuple[int, int]]) -> tuple[int, int] | None:
-    """Swiss-style pair selection within the active pool.
+    """Select a pair to compare.
 
-    Prioritizes galaxies that need more comparisons in the current round.
-    Returns None if tournament is complete or no pairs available.
+    70% close-ELO matchup, 30% random. Returns None if no unseen pair available.
     """
     with _lock:
-        if _state is None or _state.tournament_complete:
+        if _state is None:
             return None
-
-        pool = list(_state.active_pool)
+        pool = list(_state.pool)
         if len(pool) < 2:
             return None
 
-        # Prioritize galaxies needing more comparisons
-        needs_more = [
-            idx for idx in pool
-            if _state.round_comparisons.get(idx, 0) < MIN_COMPS_PER_ROUND
-        ]
-
-        if not needs_more:
-            # All have enough — round should advance soon, but pick a pair anyway
-            needs_more = pool
-
-        # Swiss-style: pair galaxies with similar ELO
         if random.random() < 0.3:
-            # Pure random for exploration
-            if len(needs_more) >= 2:
-                pair = random.sample(needs_more, 2)
-            else:
-                pair = random.sample(pool, 2)
+            pair = random.sample(pool, 2)
         else:
-            # Sort by ELO and pair adjacent
-            candidates = needs_more if len(needs_more) >= 2 else pool
-            rated = sorted(
-                candidates,
-                key=lambda idx: _state.elo_ratings.get(idx, DEFAULT_ELO),
-            )
-            # Pick a random starting point, then take adjacent pair
-            if len(rated) >= 2:
-                start = random.randint(0, len(rated) - 2)
-                pair = [rated[start], rated[start + 1]]
-            else:
-                pair = random.sample(pool, 2)
-
-        # Check if already seen this session
-        if (pair[0], pair[1]) in seen_pairs or (pair[1], pair[0]) in seen_pairs:
-            # Try a few more random attempts
-            for _ in range(50):
-                pair = random.sample(pool, 2)
-                if (pair[0], pair[1]) not in seen_pairs and (pair[1], pair[0]) not in seen_pairs:
-                    break
-            else:
-                # All pairs exhausted for this session
-                return None
-
-    # Randomize left/right
+            rated = sorted(pool, key=lambda idx: _state.elo_ratings.get(idx, DEFAULT_ELO))
+            start = random.randint(0, len(rated) - 2)
+            pair = [rated[start], rated[start + 1]]
+
+    if (pair[0], pair[1]) in seen_pairs or (pair[1], pair[0]) in seen_pairs:
+        with _lock:
+            pool = list(_state.pool)
+        for _ in range(50):
+            pair = random.sample(pool, 2)
+            if (pair[0], pair[1]) not in seen_pairs and (pair[1], pair[0]) not in seen_pairs:
+                break
+        else:
+            return None
+
     if random.random() < 0.5:
         return (pair[1], pair[0])
     return (pair[0], pair[1])
 
 
-def get_pool_seed() -> int | None:
-    """Return the shuffle seed used when the current pool was sampled."""
-    with _lock:
-        return _state.pool_seed if _state else None
-
-
-def set_pool_seed(seed: int):
-    """Store the pool seed into the current tournament state and save."""
-    with _lock:
-        if _state is not None:
-            _state.pool_seed = seed
-    _save_state()
-
-
-def get_tournament_info() -> dict:
-    """Return a snapshot of tournament state for the progress dashboard."""
+def get_info() -> dict:
+    """Return a snapshot of ELO state for the progress dashboard."""
     with _lock:
         if _state is None:
-            return {
-                "current_round": 0,
-                "pool_size": 0,
-                "total_comparisons": 0,
-                "tournament_complete": False,
-                "elo_values": [],
-                "top_indices": [],
-                "eliminated_count": 0,
-            }
-
-        elo_values = [_state.elo_ratings.get(idx, DEFAULT_ELO) for idx in _state.active_pool]
-
-        # Top 100 by ELO
-        sorted_pool = sorted(
-            _state.active_pool,
-            key=lambda idx: _state.elo_ratings.get(idx, DEFAULT_ELO),
-            reverse=True,
-        )
-        top_indices = sorted_pool[:100]
-
-        # Estimate remaining comparisons
-        comps_needed_this_round = sum(
-            max(0, MIN_COMPS_PER_ROUND - _state.round_comparisons.get(idx, 0))
-            for idx in _state.active_pool
-        )
-        # Each comparison covers 2 galaxies
-        est_remaining_this_round = max(0, comps_needed_this_round // 2)
-
+            return {"pool_size": 0, "total_comparisons": 0, "elo_values": []}
         return {
-            "current_round": _state.current_round,
-            "pool_size": len(_state.active_pool),
+            "pool_size": len(_state.pool),
             "total_comparisons": _state.total_comparisons,
-            "tournament_complete": _state.tournament_complete,
-            "elo_values": elo_values,
-            "top_indices": top_indices,
-            "eliminated_count": len(_state.eliminated),
-            "est_remaining_this_round": est_remaining_this_round,
+            "elo_values": [_state.elo_ratings.get(idx, DEFAULT_ELO) for idx in _state.pool],
         }
 
 
 def get_leaderboard() -> list[dict]:
-    """Get active pool sorted by ELO descending."""
+    """Return top 20 galaxies by ELO descending."""
     with _lock:
         if _state is None:
             return []
         return sorted(
-            [
-                {"id": idx, "elo": _state.elo_ratings.get(idx, DEFAULT_ELO)}
-                for idx in _state.active_pool
-            ],
+            [{"id": idx, "elo": _state.elo_ratings.get(idx, DEFAULT_ELO)} for idx in _state.pool],
             key=lambda x: x["elo"],
             reverse=True,
         )[:20]
 
 
 def get_rating(galaxy_idx: int) -> float:
-    """Get current ELO rating for a galaxy."""
     with _lock:
         if _state is None:
             return DEFAULT_ELO