init nba-evo-s21 (darwinian_weights) — S20/S21/S22 SOTA genotype

Dockerfile.browser

@@ -0,0 +1,64 @@
+# Dockerfile.browser -- Browser-enabled HF Space image for web scraping
+# ======================================================================
+#
+# NOT ACTIVE YET -- this is a template for when we need browser-based
+# scraping on HF Spaces (e.g., scraping odds pages with JS rendering).
+#
+# Current HF Spaces use the default Python runtime without browser deps.
+# To activate: rename to Dockerfile and push to the target Space.
+#
+# Requirements:
+#   - HF Space must be configured as "Docker" SDK (not Gradio SDK)
+#   - The Space will be larger (~2GB) due to Chromium
+#   - CPU-only is fine for scraping (no GPU needed)
+#
+# Size estimate: ~2.5GB image (Playwright + Chromium + Python deps)
+
+FROM python:3.11-slim-bookworm
+
+# Install system deps for Playwright/Chromium
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    wget \
+    ca-certificates \
+    fonts-liberation \
+    libasound2 \
+    libatk-bridge2.0-0 \
+    libatk1.0-0 \
+    libcups2 \
+    libdbus-1-3 \
+    libdrm2 \
+    libgbm1 \
+    libgtk-3-0 \
+    libnspr4 \
+    libnss3 \
+    libx11-xcb1 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxrandr2 \
+    xdg-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user (HF Spaces requirement)
+RUN useradd -m -u 1000 user
+WORKDIR /home/user/app
+
+# Install Python deps
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Playwright and Chromium browser
+RUN pip install --no-cache-dir crawl4ai>=0.4 playwright
+RUN playwright install chromium
+RUN playwright install-deps chromium
+
+# Copy application code
+COPY . .
+
+# Fix permissions
+RUN chown -R user:user /home/user/app
+
+USER user
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,28 @@
 ---
-title: Nba Evo S21
-emoji: 🐢
-colorFrom: yellow
-colorTo: indigo
+title: NBA Evo S21 — Darwinian Weights
+emoji: 🧬
+colorFrom: green
+colorTo: purple
 sdk: gradio
-sdk_version: 6.12.0
+sdk_version: 5.12.0
 app_file: app.py
-pinned: false
+pinned: true
+short_description: "S21 — Darwinian PnL-weighted ensemble (atlas-gic)"
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# NBA Evo S21 — Darwinian Weights (atlas-gic inspired)
+
+Ensemble weights for base models are driven by rolling 30-day PnL rather
+than validation log-loss. Weights are recomputed every 10 generations with
+exponential decay alpha=0.9. Inspiration: atlas-gic (research_cycle7_sota_gap.md).
+
+# NOMOS NBA Quant AI — Continuous Training
+
+Always-running agentic loop for NBA quantitative prediction models.
+
+- **5 tree-based models** evolved via NSGA-II genetic algorithm (CPU-optimized)
+- **8 seasons** of NBA data (9,551+ games, 2018-2026)
+- **Up to 200 features** (island-specific: 55-80) from v3.0-37cat engine with MOVDA
+- **Walk-forward backtesting** with Kelly criterion sizing
+- **Feature engine**: v3.0 + Cat36 EWMA + Cat37 MOVDA (deployed 2026-03-25)
+- **MAX_FEATURES=200** hard cap, mutation capped at 0.15, xgboost_brier fixed

data/calibration-map.json

@@ -0,0 +1,45 @@
+{
+  "_meta": {
+    "version": "2.0",
+    "created": "2026-04-10",
+    "generated_at": "2026-04-10T19:35:17.183416+00:00",
+    "source": "scripts/calibration_fit.py (Pool Adjacent Violators + empirical blend)",
+    "model_version": "ensemble v1 / real_predictions_loader",
+    "notes": "Rebuilt from real matched predictions (prospective, no look-ahead). Previous 31-game hand-tuned map over-corrected bin 6 0.65->0.35. This fit uses 70% PAV curve + 30% empirical bin rate to borrow strength from neighbouring bins in low-count regions.",
+    "n_games_used": 104,
+    "date_range": "2026-03-16 to 2026-04-05",
+    "brier_before": 0.24246,
+    "brier_after": 0.23057,
+    "ece_before": 0.123,
+    "ece_after": 0.06217
+  },
+  "bin_edges": [
+    0.0,
+    0.2,
+    0.4,
+    0.6,
+    0.8,
+    1.0
+  ],
+  "bin_counts": [
+    4,
+    20,
+    26,
+    44,
+    10
+  ],
+  "raw_centers": [
+    0.1,
+    0.3,
+    0.5,
+    0.7,
+    0.9
+  ],
+  "calibrated_centers": [
+    0.075,
+    0.4417,
+    0.5365,
+    0.5556,
+    0.97
+  ]
+}

evolution/genetic_loop_v3.py

@@ -0,0 +1,2002 @@
+#!/usr/bin/env python3
+"""
+NBA Quant AI — REAL Genetic Evolution Loop v4
+================================================
+RUNS 24/7 on HF Space or Google Colab.
+
+This is NOT a fake LLM wrapper. This is REAL ML:
+  - Population of 500 individuals across 5 islands (100 per island)
+  - 13 model types: tree-based + neural nets (LSTM, Transformer, TabNet, etc.)
+  - NSGA-II Pareto front ranking (multi-objective: Brier, ROI, Sharpe, Calibration)
+  - Island migration every 10 generations for diversity
+  - Adaptive mutation: 0.15 -> 0.05 decay + stagnation boost
+  - Memory management: GC between evaluations for 16GB RAM
+  - Continuous cycles — saves after each generation
+  - Callbacks to VM after each cycle
+  - Population persistence (survives restarts)
+
+Usage:
+  # On HF Space (24/7):
+  python evolution/genetic_loop_v3.py --continuous
+
+  # On Google Colab (manual):
+  !python genetic_loop_v3.py --generations 50
+
+  # Quick test:
+  python evolution/genetic_loop_v3.py --generations 5 --pop-size 50
+"""
+
+import os, sys, json, time, random, math, warnings, traceback, gc
+import numpy as np
+from pathlib import Path
+from datetime import datetime, timezone, timedelta
+from collections import defaultdict
+from typing import Dict, List, Tuple, Optional
+
+warnings.filterwarnings("ignore")
+
+# All model types the GA can evolve
+CPU_MODEL_TYPES = [
+    "xgboost", "xgboost_brier", "lightgbm", "catboost", "random_forest", "extra_trees",
+]
+GPU_MODEL_TYPES = CPU_MODEL_TYPES + ["tabicl", "tabpfn"]
+ALL_MODEL_TYPES = GPU_MODEL_TYPES + [
+    "stacking", "mlp", "lstm", "transformer", "tabnet",
+    "ft_transformer", "deep_ensemble", "autogluon",
+]
+NEURAL_NET_TYPES = {"lstm", "transformer", "tabnet", "ft_transformer", "deep_ensemble", "mlp", "autogluon"}
+ICL_MODEL_TYPES = {"tabicl", "tabpfn"}  # In-context learning models (GPU, no hyperparams to tune)
+
+# ── Run Logger (best-effort) ──
+try:
+    from evolution.run_logger import RunLogger
+    _HAS_LOGGER = True
+except ImportError:
+    try:
+        from run_logger import RunLogger
+        _HAS_LOGGER = True
+    except ImportError:
+        _HAS_LOGGER = False
+
+# ─── Auto-load .env.local ───
+_env_file = Path(__file__).resolve().parent.parent / ".env.local"
+if not _env_file.exists():
+    _env_file = Path("/app/.env.local")
+if _env_file.exists():
+    for _line in _env_file.read_text().splitlines():
+        _line = _line.strip()
+        if _line and not _line.startswith("#") and "=" in _line:
+            _line = _line.replace("export ", "")
+            _k, _, _v = _line.partition("=")
+            os.environ.setdefault(_k.strip(), _v.strip("'\""))
+
+# ─── Paths ───
+BASE_DIR = Path(__file__).resolve().parent.parent
+DATA_DIR = BASE_DIR / "data"
+HIST_DIR = DATA_DIR / "historical"
+RESULTS_DIR = DATA_DIR / "results"
+STATE_DIR = DATA_DIR / "evolution-state"
+for d in [DATA_DIR, HIST_DIR, RESULTS_DIR, STATE_DIR]:
+    d.mkdir(parents=True, exist_ok=True)
+
+VM_CALLBACK_URL = os.environ.get("VM_CALLBACK_URL", "http://34.136.180.66:8080")
+ODDS_API_KEY = os.environ.get("ODDS_API_KEY", "")
+
+
+# ═══════════════════════════════════════════════════════════
+# SECTION 1: DATA LOADING
+# ═══════════════════════════════════════════════════════════
+
+TEAM_MAP = {
+    "Atlanta Hawks": "ATL", "Boston Celtics": "BOS", "Brooklyn Nets": "BKN",
+    "Charlotte Hornets": "CHA", "Chicago Bulls": "CHI", "Cleveland Cavaliers": "CLE",
+    "Dallas Mavericks": "DAL", "Denver Nuggets": "DEN", "Detroit Pistons": "DET",
+    "Golden State Warriors": "GSW", "Houston Rockets": "HOU", "Indiana Pacers": "IND",
+    "Los Angeles Clippers": "LAC", "Los Angeles Lakers": "LAL", "Memphis Grizzlies": "MEM",
+    "Miami Heat": "MIA", "Milwaukee Bucks": "MIL", "Minnesota Timberwolves": "MIN",
+    "New Orleans Pelicans": "NOP", "New York Knicks": "NYK", "Oklahoma City Thunder": "OKC",
+    "Orlando Magic": "ORL", "Philadelphia 76ers": "PHI", "Phoenix Suns": "PHX",
+    "Portland Trail Blazers": "POR", "Sacramento Kings": "SAC", "San Antonio Spurs": "SAS",
+    "Toronto Raptors": "TOR", "Utah Jazz": "UTA", "Washington Wizards": "WAS",
+}
+
+ARENA_COORDS = {
+    "ATL": (33.757, -84.396), "BOS": (42.366, -71.062), "BKN": (40.683, -73.976),
+    "CHA": (35.225, -80.839), "CHI": (41.881, -87.674), "CLE": (41.496, -81.688),
+    "DAL": (32.790, -96.810), "DEN": (39.749, -105.008), "DET": (42.341, -83.055),
+    "GSW": (37.768, -122.388), "HOU": (29.751, -95.362), "IND": (39.764, -86.156),
+    "LAC": (34.043, -118.267), "LAL": (34.043, -118.267), "MEM": (35.138, -90.051),
+    "MIA": (25.781, -80.187), "MIL": (43.045, -87.917), "MIN": (44.980, -93.276),
+    "NOP": (29.949, -90.082), "NYK": (40.751, -73.994), "OKC": (35.463, -97.515),
+    "ORL": (28.539, -81.384), "PHI": (39.901, -75.172), "PHX": (33.446, -112.071),
+    "POR": (45.532, -122.667), "SAC": (38.580, -121.500), "SAS": (29.427, -98.438),
+    "TOR": (43.643, -79.379), "UTA": (40.768, -111.901), "WAS": (38.898, -77.021),
+}
+
+ARENA_ALTITUDE = {
+    "DEN": 5280, "UTA": 4226, "PHX": 1086, "OKC": 1201, "SAS": 650,
+    "DAL": 430, "HOU": 43, "MEM": 337, "ATL": 1050, "CHA": 751,
+    "IND": 715, "CHI": 594, "MIL": 617, "MIN": 830, "DET": 600,
+    "CLE": 653, "BOS": 141, "NYK": 33, "BKN": 33, "PHI": 39,
+    "WAS": 25, "MIA": 6, "ORL": 82, "NOP": 7, "TOR": 250,
+    "POR": 50, "SAC": 30, "GSW": 12, "LAL": 305, "LAC": 305,
+}
+
+TIMEZONE_ET = {
+    "ATL": 0, "BOS": 0, "BKN": 0, "CHA": 0, "CHI": -1, "CLE": 0,
+    "DAL": -1, "DEN": -2, "DET": 0, "GSW": -3, "HOU": -1, "IND": 0,
+    "LAC": -3, "LAL": -3, "MEM": -1, "MIA": 0, "MIL": -1, "MIN": -1,
+    "NOP": -1, "NYK": 0, "OKC": -1, "ORL": 0, "PHI": 0, "PHX": -2,
+    "POR": -3, "SAC": -3, "SAS": -1, "TOR": 0, "UTA": -2, "WAS": 0,
+}
+
+WINDOWS = [3, 5, 7, 10, 15, 20]
+
+
+def resolve(name):
+    if name in TEAM_MAP: return TEAM_MAP[name]
+    if len(name) == 3 and name.isupper(): return name
+    for full, abbr in TEAM_MAP.items():
+        if name in full: return abbr
+    return name[:3].upper() if name else None
+
+
+def haversine(lat1, lon1, lat2, lon2):
+    R = 3959
+    dlat, dlon = math.radians(lat2 - lat1), math.radians(lon2 - lon1)
+    a = math.sin(dlat/2)**2 + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(dlon/2)**2
+    return R * 2 * math.asin(math.sqrt(a))
+
+
+def pull_seasons():
+    """Pull NBA game data from nba_api, cache locally."""
+    try:
+        from nba_api.stats.endpoints import leaguegamefinder
+    except ImportError:
+        print("[DATA] nba_api not installed, using cached data only")
+        return
+
+    existing = {f.stem.replace("games-", "") for f in HIST_DIR.glob("games-*.json")}
+    targets = ["2018-19", "2019-20", "2020-21", "2021-22", "2022-23", "2023-24", "2024-25", "2025-26"]
+    missing = [s for s in targets if s not in existing]
+    if not missing:
+        print(f"[DATA] All {len(targets)} seasons cached")
+        return
+
+    for season in missing:
+        print(f"[DATA] Pulling {season}...")
+        try:
+            time.sleep(3)
+            finder = leaguegamefinder.LeagueGameFinder(
+                season_nullable=season, league_id_nullable="00",
+                season_type_nullable="Regular Season", timeout=60
+            )
+            df = finder.get_data_frames()[0]
+            if df.empty:
+                continue
+            pairs = {}
+            for _, row in df.iterrows():
+                gid = row["GAME_ID"]
+                if gid not in pairs:
+                    pairs[gid] = []
+                pairs[gid].append({
+                    "team_name": row.get("TEAM_NAME", ""),
+                    "matchup": row.get("MATCHUP", ""),
+                    "pts": int(row["PTS"]) if row.get("PTS") is not None else None,
+                    "game_date": row.get("GAME_DATE", ""),
+                })
+            games = []
+            for gid, teams in pairs.items():
+                if len(teams) != 2:
+                    continue
+                home = next((t for t in teams if " vs. " in str(t.get("matchup", ""))), None)
+                away = next((t for t in teams if " @ " in str(t.get("matchup", ""))), None)
+                if not home or not away or home["pts"] is None:
+                    continue
+                games.append({
+                    "game_date": home["game_date"],
+                    "home_team": home["team_name"], "away_team": away["team_name"],
+                    "home": {"team_name": home["team_name"], "pts": home["pts"]},
+                    "away": {"team_name": away["team_name"], "pts": away["pts"]},
+                })
+            if games:
+                (HIST_DIR / f"games-{season}.json").write_text(json.dumps(games))
+                print(f"  {len(games)} games saved")
+        except Exception as e:
+            print(f"  Error pulling {season}: {e}")
+
+
+def load_all_games():
+    """Load all cached game data."""
+    games = []
+    for f in sorted(HIST_DIR.glob("games-*.json")):
+        data = json.loads(f.read_text())
+        items = data if isinstance(data, list) else data.get("games", [])
+        games.extend(items)
+    games.sort(key=lambda g: g.get("game_date", g.get("date", "")))
+    return games
+
+
+# ═══════════════════════════════════════════════════════════
+# SECTION 2: FEATURE ENGINE
+# ═══════════════════════════════════════════════════════════
+
+FEATURE_ENGINE_VERSION = "genetic-loop-v3"
+
+def build_features(games):
+    """Build features from raw game data. Tries real NBAFeatureEngine first, falls back to inline."""
+    try:
+        from features.engine import NBAFeatureEngine
+        engine = NBAFeatureEngine(skip_placeholder=True)
+        X, y, feature_names = engine.build(games)
+        X = np.nan_to_num(np.array(X, dtype=np.float64), nan=0.0, posinf=1e6, neginf=-1e6)
+        y = np.array(y, dtype=np.int32)
+        print(f"[ENGINE] Real NBAFeatureEngine: {X.shape[1]} features, {len(y)} games")
+        return X, y, feature_names
+    except Exception as e:
+        print(f"[ENGINE] NBAFeatureEngine import failed ({e}), using inline fallback")
+        return _build_features_inline(games)
+
+
+def _build_features_inline(games):
+    """Fallback: Build 250+ inline features from raw game data. Returns X, y, feature_names."""
+    team_results = defaultdict(list)
+    team_last = {}
+    team_elo = defaultdict(lambda: 1500.0)
+    X, y = [], []
+    feature_names = []
+    first = True
+
+    for game in games:
+        hr, ar = game.get("home_team", ""), game.get("away_team", "")
+        if "home" in game and isinstance(game["home"], dict):
+            h, a = game["home"], game.get("away", {})
+            hs, as_ = h.get("pts"), a.get("pts")
+            if not hr: hr = h.get("team_name", "")
+            if not ar: ar = a.get("team_name", "")
+        else:
+            hs, as_ = game.get("home_score"), game.get("away_score")
+        if hs is None or as_ is None:
+            continue
+        hs, as_ = int(hs), int(as_)
+        home, away = resolve(hr), resolve(ar)
+        if not home or not away:
+            continue
+        gd = game.get("game_date", game.get("date", ""))[:10]
+        hr_ = team_results[home]
+        ar_ = team_results[away]
+
+        if len(hr_) < 5 or len(ar_) < 5:
+            team_results[home].append((gd, hs > as_, hs - as_, away, hs, as_))
+            team_results[away].append((gd, as_ > hs, as_ - hs, home, as_, hs))
+            team_last[home] = gd
+            team_last[away] = gd
+            K = 20
+            exp_h = 1 / (1 + 10 ** ((team_elo[away] - team_elo[home] - 50) / 400))
+            team_elo[home] += K * ((1 if hs > as_ else 0) - exp_h)
+            team_elo[away] += K * ((0 if hs > as_ else 1) - (1 - exp_h))
+            continue
+
+        def wp(r, n):
+            s = r[-n:]
+            return sum(1 for x in s if x[1]) / len(s) if s else 0.5
+
+        def pd(r, n):
+            s = r[-n:]
+            return sum(x[2] for x in s) / len(s) if s else 0.0
+
+        def ppg(r, n):
+            s = r[-n:]
+            return sum(x[4] for x in s) / len(s) if s else 100.0
+
+        def papg(r, n):
+            s = r[-n:]
+            return sum(x[5] for x in s) / len(s) if s else 100.0
+
+        def strk(r):
+            if not r: return 0
+            s, l = 0, r[-1][1]
+            for x in reversed(r):
+                if x[1] == l:
+                    s += 1
+                else:
+                    break
+            return s if l else -s
+
+        def close_pct(r, n):
+            s = r[-n:]
+            return sum(1 for x in s if abs(x[2]) <= 5) / len(s) if s else 0.5
+
+        def blowout_pct(r, n):
+            s = r[-n:]
+            return sum(1 for x in s if abs(x[2]) >= 15) / len(s) if s else 0.0
+
+        def consistency(r, n):
+            s = r[-n:]
+            if len(s) < 3: return 0.0
+            m = [x[2] for x in s]
+            avg = sum(m) / len(m)
+            return (sum((v - avg) ** 2 for v in m) / len(m)) ** 0.5
+
+        def rest(t):
+            last = team_last.get(t)
+            if not last or not gd: return 3
+            try:
+                return max(0, (datetime.strptime(gd[:10], "%Y-%m-%d") - datetime.strptime(last[:10], "%Y-%m-%d")).days)
+            except Exception:
+                return 3
+
+        def sos(r, n=10):
+            rec = r[-n:]
+            if not rec: return 0.5
+            ops = [wp(team_results[x[3]], 82) for x in rec if team_results[x[3]]]
+            return sum(ops) / len(ops) if ops else 0.5
+
+        def travel_dist(r, team):
+            if not r: return 0
+            last_opp = r[-1][3]
+            if last_opp in ARENA_COORDS and team in ARENA_COORDS:
+                return haversine(*ARENA_COORDS[last_opp], *ARENA_COORDS[team])
+            return 0
+
+        h_rest, a_rest = rest(home), rest(away)
+        try:
+            dt = datetime.strptime(gd, "%Y-%m-%d")
+            month, dow = dt.month, dt.weekday()
+        except Exception:
+            month, dow = 1, 2
+
+        sp = max(0, min(1, (month - 10) / 7)) if month >= 10 else max(0, min(1, (month + 2) / 7))
+
+        row = []
+        names = []
+
+        # 1. ROLLING PERFORMANCE (96 features)
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for w in WINDOWS:
+                row.extend([wp(tr, w), pd(tr, w), ppg(tr, w), papg(tr, w),
+                            ppg(tr, w) - papg(tr, w), close_pct(tr, w), blowout_pct(tr, w),
+                            ppg(tr, w) + papg(tr, w)])
+                if first:
+                    names.extend([f"{prefix}_wp{w}", f"{prefix}_pd{w}", f"{prefix}_ppg{w}",
+                                  f"{prefix}_papg{w}", f"{prefix}_margin{w}", f"{prefix}_close{w}",
+                                  f"{prefix}_blowout{w}", f"{prefix}_ou{w}"])
+
+        # 2. MOMENTUM (16 features)
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            row.extend([strk(tr), abs(strk(tr)),
+                        wp(tr, 5) - wp(tr, 82), wp(tr, 3) - wp(tr, 10),
+                        ppg(tr, 5) - ppg(tr, 20), papg(tr, 5) - papg(tr, 20),
+                        consistency(tr, 10), consistency(tr, 5)])
+            if first:
+                names.extend([f"{prefix}_streak", f"{prefix}_streak_abs",
+                              f"{prefix}_form5v82", f"{prefix}_form3v10",
+                              f"{prefix}_scoring_trend", f"{prefix}_defense_trend",
+                              f"{prefix}_consistency10", f"{prefix}_consistency5"])
+
+        # 3. REST & SCHEDULE (16 features)
+        h_travel = travel_dist(hr_, home)
+        a_travel = travel_dist(ar_, away)
+        row.extend([
+            min(h_rest, 7), min(a_rest, 7), h_rest - a_rest,
+            1.0 if h_rest <= 1 else 0.0, 1.0 if a_rest <= 1 else 0.0,
+            h_travel / 1000, a_travel / 1000, (h_travel - a_travel) / 1000,
+            ARENA_ALTITUDE.get(home, 500) / 5280, ARENA_ALTITUDE.get(away, 500) / 5280,
+            (ARENA_ALTITUDE.get(home, 500) - ARENA_ALTITUDE.get(away, 500)) / 5280,
+            abs(TIMEZONE_ET.get(home, 0) - TIMEZONE_ET.get(away, 0)),
+            0, 0, 0, 0,
+        ])
+        if first:
+            names.extend(["h_rest", "a_rest", "rest_adv", "h_b2b", "a_b2b",
+                          "h_travel", "a_travel", "travel_adv",
+                          "h_altitude", "a_altitude", "altitude_delta",
+                          "tz_shift", "h_games_7d", "a_games_7d", "sched_density", "pad1"])
+
+        # 4. OPPONENT-ADJUSTED (12 features)
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            s5 = sos(tr, 5)
+            s10 = sos(tr, 10)
+            ss = sos(tr, 82)
+            wp_above = sum(1 for r in tr if wp(team_results[r[3]], 82) > 0.5 and r[1]) / max(
+                sum(1 for r in tr if wp(team_results[r[3]], 82) > 0.5), 1)
+            wp_below = sum(1 for r in tr if wp(team_results[r[3]], 82) <= 0.5 and r[1]) / max(
+                sum(1 for r in tr if wp(team_results[r[3]], 82) <= 0.5), 1)
+            row.extend([s5, s10, ss, wp_above, wp_below, 0])
+            if first:
+                names.extend([f"{prefix}_sos5", f"{prefix}_sos10", f"{prefix}_sos_season",
+                              f"{prefix}_wp_above500", f"{prefix}_wp_below500", f"{prefix}_margin_quality"])
+
+        # 5. MATCHUP & ELO (12 features)
+        row.extend([
+            wp(hr_, 10) - wp(ar_, 10), pd(hr_, 10) - pd(ar_, 10),
+            ppg(hr_, 10) - papg(ar_, 10), ppg(ar_, 10) - papg(hr_, 10),
+            abs(ppg(hr_, 10) + papg(hr_, 10) - ppg(ar_, 10) - papg(ar_, 10)),
+            consistency(hr_, 10) - consistency(ar_, 10),
+            team_elo[home], team_elo[away], team_elo[home] - team_elo[away] + 50,
+            (team_elo[home] - 1500) / 100, (team_elo[away] - 1500) / 100,
+            (team_elo[home] - team_elo[away]) / 100,
+        ])
+        if first:
+            names.extend(["rel_strength", "rel_pd", "off_matchup", "def_matchup",
+                          "tempo_diff", "consistency_edge",
+                          "elo_home", "elo_away", "elo_diff",
+                          "elo_home_norm", "elo_away_norm", "elo_diff_norm"])
+
+        # 6. CONTEXT (12 features)
+        row.extend([
+            1.0, sp, math.sin(2 * math.pi * month / 12), math.cos(2 * math.pi * month / 12),
+            dow / 6.0, 1.0 if dow >= 5 else 0.0,
+            min(len(hr_), 82) / 82.0, min(len(ar_), 82) / 82.0,
+            wp(hr_, 82) + wp(ar_, 82), wp(hr_, 82) - wp(ar_, 82),
+            1.0 if wp(hr_, 82) > 0.5 and wp(ar_, 82) > 0.5 else 0.0,
+            ppg(hr_, 10) + ppg(ar_, 10),
+        ])
+        if first:
+            names.extend(["home_court", "season_phase", "month_sin", "month_cos",
+                          "day_of_week", "is_weekend", "h_games_pct", "a_games_pct",
+                          "combined_wp", "wp_diff", "playoff_race", "expected_total"])
+
+        # 7. CROSS-WINDOW MOMENTUM (20 features) — trend acceleration
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            # Short vs long momentum (5 vs 20)
+            wp_accel = wp(tr, 3) - 2 * wp(tr, 10) + wp(tr, 20) if len(tr) >= 20 else 0.0
+            pd_accel = pd(tr, 3) - 2 * pd(tr, 10) + pd(tr, 20) if len(tr) >= 20 else 0.0
+            # Pythagorean expected win rate (Bill James)
+            pts_for = sum(x[4] for x in tr[-20:]) if len(tr) >= 5 else 100
+            pts_against = sum(x[5] for x in tr[-20:]) if len(tr) >= 5 else 100
+            pyth_exp = pts_for ** 13.91 / max(1, pts_for ** 13.91 + pts_against ** 13.91) if pts_for > 0 else 0.5
+            # Scoring volatility
+            pts_list = [x[4] for x in tr[-10:]] if len(tr) >= 5 else [100]
+            pts_vol = (sum((p - sum(pts_list)/len(pts_list))**2 for p in pts_list) / len(pts_list)) ** 0.5 if len(pts_list) > 1 else 0
+            # Home/away specific win rates
+            home_games = [x for x in tr if x[3] != home] if prefix == "h" else [x for x in tr if x[3] != away]
+            ha_wp = sum(1 for x in home_games[-20:] if x[1]) / max(len(home_games[-20:]), 1)
+            # Opponent quality of recent wins
+            recent_wins = [x for x in tr[-10:] if x[1]]
+            win_quality = sum(wp(team_results[x[3]], 82) for x in recent_wins) / max(len(recent_wins), 1) if recent_wins else 0.5
+            # Margin trend (linear slope over last 10 games)
+            margins_10 = [x[2] for x in tr[-10:]] if len(tr) >= 5 else [0]
+            if len(margins_10) >= 3:
+                x_vals = list(range(len(margins_10)))
+                x_mean = sum(x_vals) / len(x_vals)
+                y_mean = sum(margins_10) / len(margins_10)
+                num = sum((x - x_mean) * (y - y_mean) for x, y in zip(x_vals, margins_10))
+                den = sum((x - x_mean) ** 2 for x in x_vals)
+                margin_slope = num / den if den > 0 else 0.0
+            else:
+                margin_slope = 0.0
+            row.extend([
+                wp(tr, 5) - wp(tr, 20) if len(tr) >= 20 else 0.0,
+                wp_accel, pd_accel, pyth_exp,
+                pts_vol / 10.0,  # normalized
+                ha_wp, win_quality,
+                margin_slope,
+                ppg(tr, 3) / max(ppg(tr, 20), 1),  # recent scoring ratio
+                papg(tr, 3) / max(papg(tr, 20), 1),  # recent defense ratio
+            ])
+            if first:
+                names.extend([f"{prefix}_wp5v20", f"{prefix}_wp_accel", f"{prefix}_pd_accel",
+                              f"{prefix}_pyth_exp", f"{prefix}_pts_vol",
+                              f"{prefix}_location_wp", f"{prefix}_win_quality",
+                              f"{prefix}_margin_slope", f"{prefix}_off_ratio", f"{prefix}_def_ratio"])
+
+        # 8. INTERACTION FEATURES (12 features) — key cross-terms
+        elo_d = team_elo[home] - team_elo[away] + 50
+        rest_adv = h_rest - a_rest
+        wp_d = wp(hr_, 10) - wp(ar_, 10)
+        row.extend([
+            elo_d * rest_adv / 10.0,          # elo × rest interaction
+            wp_d * rest_adv / 3.0,             # form × rest interaction
+            elo_d * (1 if h_rest <= 1 else 0), # elo × b2b penalty
+            wp_d ** 2,                          # squared wp diff (nonlinearity)
+            elo_d ** 2 / 10000.0,               # squared elo diff
+            (ppg(hr_, 10) - papg(ar_, 10)) * (ppg(ar_, 10) - papg(hr_, 10)),  # off×def interaction
+            consistency(hr_, 10) * consistency(ar_, 10) / 100.0,  # consistency product
+            wp(hr_, 82) * wp(ar_, 82),          # season quality product
+            (wp(hr_, 5) - wp(hr_, 20)) * (wp(ar_, 5) - wp(ar_, 20)),  # momentum alignment
+            abs(ppg(hr_, 10) + papg(hr_, 10) - ppg(ar_, 10) - papg(ar_, 10)) * elo_d / 1000.0,  # tempo×elo
+            (1.0 if wp(hr_, 82) > 0.6 else 0.0) * (1.0 if wp(ar_, 82) < 0.4 else 0.0),  # mismatch flag
+            float(h_rest >= 3 and a_rest <= 1),  # rest mismatch flag
+        ])
+        if first:
+            names.extend(["elo_rest_interact", "form_rest_interact", "elo_b2b_penalty",
+                          "wp_diff_sq", "elo_diff_sq", "off_def_interact",
+                          "consistency_product", "quality_product", "momentum_align",
+                          "tempo_elo_interact", "mismatch_flag", "rest_mismatch_flag"])
+
+        # 9. NEW HIGH-IMPACT FEATURES (50 features, windows [5, 10])
+        NEW_WINDOWS = [5, 10]
+
+        # Helper: home/away split win% (home team plays at home, away team plays away)
+        def home_split_wp(r, n, is_home_team):
+            """Win% for home-only or away-only games over last n."""
+            if is_home_team:
+                # home team's results when they were the home team (opponent is different city)
+                loc_games = [x for x in r if x[3] != home][-n:]
+            else:
+                loc_games = [x for x in r if x[3] != away][-n:]
+            if not loc_games:
+                return wp(r, n)  # fallback to overall
+            return sum(1 for x in loc_games if x[1]) / len(loc_games)
+
+        def away_split_wp(r, n, is_home_team):
+            """Win% for away-only games over last n."""
+            if is_home_team:
+                loc_games = [x for x in r if x[3] == home][-n:]
+            else:
+                loc_games = [x for x in r if x[3] == away][-n:]
+            if not loc_games:
+                return wp(r, n)
+            return sum(1 for x in loc_games if x[1]) / len(loc_games)
+
+        def net_rating(r, n):
+            """Net points per game over window (proxy for net rating)."""
+            s = r[-n:]
+            if not s:
+                return 0.0
+            return sum(x[4] - x[5] for x in s) / len(s)
+
+        def pace_proxy(r, n):
+            """Approximate pace as total points per game (proxy when possession data absent)."""
+            s = r[-n:]
+            if not s:
+                return 200.0
+            return sum(x[4] + x[5] for x in s) / len(s)
+
+        def h2h_wp(hr, ar, n):
+            """Head-to-head win% for home team vs this specific away team over last n meetings."""
+            meetings = [x for x in hr if x[3] == away][-n:]
+            if not meetings:
+                return 0.5
+            return sum(1 for x in meetings if x[1]) / len(meetings)
+
+        def sos_window(r, n):
+            """Average opponent win% over last n games (Strength of Schedule)."""
+            rec = r[-n:]
+            if not rec:
+                return 0.5
+            ops = [wp(team_results[x[3]], 82) for x in rec if team_results[x[3]]]
+            return sum(ops) / len(ops) if ops else 0.5
+
+        # 9a. Net Rating (windows 5, 10) — 4 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for w in NEW_WINDOWS:
+                row.append(net_rating(tr, w))
+                if first:
+                    names.append(f"{prefix}_net_rating{w}")
+
+        # 9b. Pace proxy (windows 5, 10) — 4 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for w in NEW_WINDOWS:
+                row.append(pace_proxy(tr, w))
+                if first:
+                    names.append(f"{prefix}_pace{w}")
+
+        # 9c. Rest days (already exists as h_rest/a_rest, add explicit named vars for clarity)
+        # These are already in section 3 above; skip to avoid duplication.
+
+        # 9d. Home/Away Win% Split (windows 5, 10) — 4 features each side = 8 features
+        for w in NEW_WINDOWS:
+            row.append(home_split_wp(hr_, w, is_home_team=True))   # h home-venue wp
+            row.append(away_split_wp(ar_, w, is_home_team=False))  # a away-venue wp
+            if first:
+                names.append(f"h_home_wp{w}")
+                names.append(f"a_away_wp{w}")
+
+        # 9e. Matchup H2H record (windows 5, 10) — 2 features
+        for w in NEW_WINDOWS:
+            row.append(h2h_wp(hr_, ar_, w))
+            if first:
+                names.append(f"h_h2h_wp{w}")
+
+        # 9f. Strength of Schedule windows 5, 10 (distinct from existing sos5/sos10 in sec 4)
+        # sec 4 already has h_sos5, h_sos10 — skip to avoid duplication.
+
+        # 9g. Streak type: signed streak (positive=wins, negative=losses) — 2 features
+        # (strk() already included in section 2 as h_streak/a_streak; skip duplicate.)
+
+        # 9h. Pace × Net Rating interaction — 4 features (home + away, windows 5 and 10)
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for w in NEW_WINDOWS:
+                p = pace_proxy(tr, w)
+                n_r = net_rating(tr, w)
+                row.append((p * n_r) / 1000.0)  # scaled
+                if first:
+                    names.append(f"{prefix}_pace_net_interact{w}")
+
+        # 9i. Pythagorean-adjusted net rating (per-100-possessions approximation) — 4 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for w in NEW_WINDOWS:
+                s = tr[-w:]
+                if s:
+                    total_pts_for = sum(x[4] for x in s)
+                    total_pts_ag = sum(x[5] for x in s)
+                    n_games = len(s)
+                    avg_pace = (total_pts_for + total_pts_ag) / max(n_games, 1)
+                    # net per 100 possessions approximation
+                    net_per100 = ((total_pts_for - total_pts_ag) / max(n_games, 1)) / max(avg_pace / 100.0, 1.0)
+                else:
+                    net_per100 = 0.0
+                row.append(net_per100)
+                if first:
+                    names.append(f"{prefix}_net_per100_{w}")
+
+        # 9j. Recent opponent quality (win% of opponents faced) — 4 features (windows 5, 10)
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for w in NEW_WINDOWS:
+                row.append(sos_window(tr, w))
+                if first:
+                    names.append(f"{prefix}_opp_quality{w}")
+
+        # ── SECTION 10: EXPONENTIALLY-WEIGHTED MOMENTUM FEATURES (~28 features) ──
+        # EWM uses manual exponential decay (no pandas needed) for each team's history.
+        # Halflife h means the weight of a game h games ago is 0.5x the weight of the current.
+        # alpha = 1 - exp(-ln(2) / halflife)  =>  older games decay exponentially.
+
+        def ewm_win(r, halflife):
+            """EWM of wins (0/1) with given halflife in games."""
+            s = [x[1] for x in r]
+            if not s:
+                return 0.5
+            alpha = 1.0 - math.exp(-math.log(2) / max(halflife, 0.5))
+            val, w_sum = 0.0, 0.0
+            for i, v in enumerate(s):
+                w = (1 - alpha) ** (len(s) - 1 - i)
+                val += w * float(v)
+                w_sum += w
+            return val / w_sum if w_sum > 0 else 0.5
+
+        def ewm_pd(r, halflife):
+            """EWM of point differentials with given halflife."""
+            s = [x[2] for x in r]
+            if not s:
+                return 0.0
+            alpha = 1.0 - math.exp(-math.log(2) / max(halflife, 0.5))
+            val, w_sum = 0.0, 0.0
+            for i, v in enumerate(s):
+                w = (1 - alpha) ** (len(s) - 1 - i)
+                val += w * v
+                w_sum += w
+            return val / w_sum if w_sum > 0 else 0.0
+
+        def ewm_ppg(r, halflife):
+            """EWM of points scored per game."""
+            s = [x[4] for x in r]
+            if not s:
+                return 100.0
+            alpha = 1.0 - math.exp(-math.log(2) / max(halflife, 0.5))
+            val, w_sum = 0.0, 0.0
+            for i, v in enumerate(s):
+                w = (1 - alpha) ** (len(s) - 1 - i)
+                val += w * v
+                w_sum += w
+            return val / w_sum if w_sum > 0 else 100.0
+
+        def ewm_papg(r, halflife):
+            """EWM of opponent points per game (defensive rating proxy)."""
+            s = [x[5] for x in r]
+            if not s:
+                return 100.0
+            alpha = 1.0 - math.exp(-math.log(2) / max(halflife, 0.5))
+            val, w_sum = 0.0, 0.0
+            for i, v in enumerate(s):
+                w = (1 - alpha) ** (len(s) - 1 - i)
+                val += w * v
+                w_sum += w
+            return val / w_sum if w_sum > 0 else 100.0
+
+        def streak_decay_score(r):
+            """current_streak x (1 / (1 + games_since_last_loss)).
+            Captures both streak length and recency of last loss."""
+            if not r:
+                return 0.0
+            cur_streak = 0
+            last_result = r[-1][1]
+            for x in reversed(r):
+                if x[1] == last_result:
+                    cur_streak += 1
+                else:
+                    break
+            if not last_result:
+                return -float(cur_streak)  # losing streak: negative
+            # Count consecutive games back since last loss (= win streak length)
+            games_since_loss = 0
+            for x in reversed(r):
+                if not x[1]:
+                    break
+                games_since_loss += 1
+            return cur_streak * (1.0 / (1 + games_since_loss))
+
+        def fatigue_index(r, n=5):
+            """Sum of (1/rest_days) for last n inter-game gaps — high = compressed schedule."""
+            recent = r[-n:]
+            if len(recent) < 2:
+                return 0.0
+            total = 0.0
+            for i in range(1, len(recent)):
+                try:
+                    d1 = datetime.strptime(recent[i - 1][0][:10], "%Y-%m-%d")
+                    d2 = datetime.strptime(recent[i][0][:10], "%Y-%m-%d")
+                    gap = max(1, abs((d2 - d1).days))
+                    total += 1.0 / gap
+                except Exception:
+                    total += 0.5  # fallback: assume 2-day gap
+            return total
+
+        def b2b_delta(r, metric_idx=2):
+            """B2B performance delta: avg metric in B2B games minus avg in normal-rest games.
+            B2B = previous game was <= 1 day ago."""
+            b2b_vals, normal_vals = [], []
+            for i in range(1, len(r)):
+                try:
+                    d1 = datetime.strptime(r[i - 1][0][:10], "%Y-%m-%d")
+                    d2 = datetime.strptime(r[i][0][:10], "%Y-%m-%d")
+                    gap = abs((d2 - d1).days)
+                except Exception:
+                    gap = 2
+                val = r[i][metric_idx]
+                if gap <= 1:
+                    b2b_vals.append(val)
+                else:
+                    normal_vals.append(val)
+            b2b_avg = sum(b2b_vals) / len(b2b_vals) if b2b_vals else 0.0
+            normal_avg = sum(normal_vals) / len(normal_vals) if normal_vals else 0.0
+            return b2b_avg - normal_avg
+
+        def travel_burden(r, n=7):
+            """Count unique opponents (proxy for unique cities visited) in last n games.
+            More unique opponents correlates with more travel across the schedule."""
+            recent = r[-n:]
+            if not recent:
+                return 0
+            return len({x[3] for x in recent})
+
+        # 10a. EWM Win Probability — halflives [3, 5, 10] x 2 teams = 6 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for hl in [3, 5, 10]:
+                row.append(ewm_win(tr, hl))
+                if first:
+                    names.append(f"{prefix}_ewm_win_hl{hl}")
+
+        # 10b. EWM Point Differential — halflives [3, 5, 10] x 2 teams = 6 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            for hl in [3, 5, 10]:
+                row.append(ewm_pd(tr, hl) / 10.0)  # normalize: typical margins ~0–20 pts
+                if first:
+                    names.append(f"{prefix}_ewm_pd_hl{hl}")
+
+        # 10c. EWM Offensive Rating (halflife=5) — 2 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            row.append(ewm_ppg(tr, 5) / 100.0)  # normalize to ~1.0 range
+            if first:
+                names.append(f"{prefix}_ewm_off_hl5")
+
+        # 10d. EWM Defensive Rating (halflife=5) — 2 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            row.append(ewm_papg(tr, 5) / 100.0)
+            if first:
+                names.append(f"{prefix}_ewm_def_hl5")
+
+        # 10e. Streak Decay Score — 2 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            row.append(streak_decay_score(tr))
+            if first:
+                names.append(f"{prefix}_streak_decay")
+
+        # 10f. Fatigue Index (last 5 games) — 2 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            row.append(fatigue_index(tr, n=5))
+            if first:
+                names.append(f"{prefix}_fatigue_idx")
+
+        # 10g. B2B Performance Delta (point margin) — 2 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            row.append(b2b_delta(tr, metric_idx=2) / 10.0)  # normalized margin delta
+            if first:
+                names.append(f"{prefix}_b2b_margin_delta")
+
+        # 10h. Travel Burden (unique cities proxy over last 7 games) — 2 features
+        for prefix, tr in [("h", hr_), ("a", ar_)]:
+            row.append(float(travel_burden(tr, n=7)) / 7.0)  # normalize to [0, 1]
+            if first:
+                names.append(f"{prefix}_travel_burden7")
+
+        # 10i. Cross-team EWM interaction features — 4 features
+        row.append(ewm_win(hr_, 3) - ewm_win(ar_, 3))         # home vs away momentum (hl=3)
+        row.append(ewm_win(hr_, 5) - ewm_win(ar_, 5))         # home vs away momentum (hl=5)
+        row.append((ewm_pd(hr_, 5) - ewm_pd(ar_, 5)) / 10.0)  # relative margin quality (hl=5)
+        row.append((ewm_ppg(hr_, 5) - ewm_papg(ar_, 5)) / 100.0)  # home offense vs away defense
+        if first:
+            names.extend(["ewm_win_diff_hl3", "ewm_win_diff_hl5",
+                          "ewm_pd_diff_hl5", "ewm_off_vs_def_hl5"])
+
+        X.append(row)
+        y.append(1 if hs > as_ else 0)
+        if first:
+            feature_names = names
+            first = False
+
+        team_results[home].append((gd, hs > as_, hs - as_, away, hs, as_))
+        team_results[away].append((gd, as_ > hs, as_ - hs, home, as_, hs))
+        team_last[home] = gd
+        team_last[away] = gd
+        K = 20
+        exp_h = 1 / (1 + 10 ** ((team_elo[away] - team_elo[home] - 50) / 400))
+        team_elo[home] += K * ((1 if hs > as_ else 0) - exp_h)
+        team_elo[away] += K * ((0 if hs > as_ else 1) - (1 - exp_h))
+
+    X = np.nan_to_num(np.array(X, dtype=np.float64))
+    y = np.array(y, dtype=np.int32)
+    return X, y, feature_names
+
+
+# ═══════════════════════════════════════════════════════════
+# SECTION 3: INDIVIDUAL (feature mask + hyperparameters)
+# ═══════════════════════════════════════════════════════════
+
+class Individual:
+    """One model configuration: feature selection mask + hyperparameters."""
+
+    def __init__(self, n_features, target=100, model_type=None):
+        prob = target / max(n_features, 1)
+        self.features = [1 if random.random() < prob else 0 for _ in range(n_features)]
+        self.hyperparams = {
+            "n_estimators": random.randint(100, 600),
+            "max_depth": random.randint(3, 10),
+            "learning_rate": 10 ** random.uniform(-2.5, -0.5),
+            "subsample": random.uniform(0.5, 1.0),
+            "colsample_bytree": random.uniform(0.3, 1.0),
+            "min_child_weight": random.randint(1, 15),
+            "reg_alpha": 10 ** random.uniform(-6, 1),
+            "reg_lambda": 10 ** random.uniform(-6, 1),
+            "model_type": model_type or random.choice(GPU_MODEL_TYPES),
+            # venn_abers added (brain cycle 82, 2026-04-09): HF island best (pareto 0.21773) uses
+            # venn_abers; GPU Kaggle loop was missing this option entirely.
+            "calibration": random.choices(
+                ["none", "sigmoid", "venn_abers", "beta", "isotonic", "isotonic_temporal"],
+                weights=[15, 12, 25, 20, 15, 13], k=1)[0],
+            # Neural net hyperparams
+            "nn_hidden_dims": random.choice([64, 128, 256]),
+            "nn_n_layers": random.randint(2, 4),
+            "nn_dropout": random.uniform(0.1, 0.5),
+            "nn_epochs": random.randint(20, 100),
+            "nn_batch_size": random.choice([32, 64, 128]),
+        }
+        self.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "calibration_error": 1.0, "composite": 0.0}
+        self.pareto_rank = 999
+        self.crowding_dist = 0.0
+        self.island_id = -1
+        self.generation = 0
+        self.birth_generation = 0
+        self._enforce_feature_cap()
+
+    def selected_indices(self):
+        return [i for i, b in enumerate(self.features) if b]
+
+    def to_dict(self):
+        return {
+            "n_features": self.n_features,
+            "hyperparams": {k: v for k, v in self.hyperparams.items()},
+            "fitness": dict(self.fitness),
+            "generation": self.generation,
+        }
+
+    @staticmethod
+    def _hamming_distance(f1, f2):
+        """Normalized Hamming distance between two binary feature masks (0.0 – 1.0)."""
+        n = len(f1)
+        if n == 0:
+            return 0.0
+        return sum(a != b for a, b in zip(f1, f2)) / n
+
+    @staticmethod
+    def crossover(p1, p2):
+        """Crossover on features + blend hyperparams.
+
+        Crossover type is selected based on parent similarity:
+          - Parents very similar (Hamming < 0.1): uniform crossover.
+            Picks each bit independently, generating more variation between
+            nearly-identical individuals.
+          - Otherwise: classic two-point crossover.
+        """
+        child = Individual.__new__(Individual)
+        n = len(p1.features)
+        parent_hamming = Individual._hamming_distance(p1.features, p2.features)
+        if parent_hamming < 0.1:
+            # Uniform crossover: each position drawn independently
+            child.features = [
+                p1.features[i] if random.random() < 0.5 else p2.features[i]
+                for i in range(n)
+            ]
+        else:
+            pt1 = random.randint(0, n - 1)
+            pt2 = random.randint(pt1, n - 1)
+            child.features = p1.features[:pt1] + p2.features[pt1:pt2] + p1.features[pt2:]
+
+        child.hyperparams = {}
+        for key in p1.hyperparams:
+            if isinstance(p1.hyperparams[key], (int, float)):
+                w = random.random()
+                val = w * p1.hyperparams[key] + (1 - w) * p2.hyperparams[key]
+                if isinstance(p1.hyperparams[key], int):
+                    val = int(round(val))
+                child.hyperparams[key] = val
+            else:
+                child.hyperparams[key] = random.choice([p1.hyperparams[key], p2.hyperparams[key]])
+
+        child.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "calibration_error": 1.0, "composite": 0.0}
+        child.generation = max(p1.generation, p2.generation) + 1
+        child.birth_generation = child.generation
+        child.pareto_rank = 999
+        child.crowding_dist = 0.0
+        child.island_id = -1
+        child._enforce_feature_cap()
+        return child
+
+    MAX_FEATURES = 200  # Hard cap — individuals above this waste compute
+
+    def _enforce_feature_cap(self):
+        """If feature count exceeds MAX_FEATURES, randomly drop excess features."""
+        selected = [i for i, b in enumerate(self.features) if b]
+        if len(selected) > self.MAX_FEATURES:
+            to_drop = random.sample(selected, len(selected) - self.MAX_FEATURES)
+            for idx in to_drop:
+                self.features[idx] = 0
+        self.n_features = sum(self.features)
+
+    def mutate(self, rate=0.03):
+        """Mutate features and hyperparameters."""
+        for i in range(len(self.features)):
+            if random.random() < rate:
+                self.features[i] = 1 - self.features[i]
+        self._enforce_feature_cap()
+        if random.random() < 0.15:
+            self.hyperparams["n_estimators"] = max(50, self.hyperparams["n_estimators"] + random.randint(-100, 100))
+        if random.random() < 0.15:
+            self.hyperparams["max_depth"] = max(2, min(12, self.hyperparams["max_depth"] + random.randint(-2, 2)))
+        if random.random() < 0.15:
+            self.hyperparams["learning_rate"] *= 10 ** random.uniform(-0.3, 0.3)
+            self.hyperparams["learning_rate"] = max(0.001, min(0.5, self.hyperparams["learning_rate"]))
+        if random.random() < 0.08:
+            self.hyperparams["model_type"] = random.choice(GPU_MODEL_TYPES)
+        if random.random() < 0.05:
+            # Aligned with HF island weights; venn_abers dominant (brain cycle 82).
+            self.hyperparams["calibration"] = random.choices(
+                ["none", "sigmoid", "venn_abers", "beta", "isotonic", "isotonic_temporal"],
+                weights=[16, 12, 25, 20, 14, 13], k=1)[0]
+        # Neural net hyperparams
+        if random.random() < 0.10:
+            self.hyperparams["nn_hidden_dims"] = random.choice([64, 128, 256, 512])
+        if random.random() < 0.10:
+            self.hyperparams["nn_n_layers"] = max(1, min(6, self.hyperparams.get("nn_n_layers", 2) + random.randint(-1, 1)))
+        if random.random() < 0.10:
+            self.hyperparams["nn_dropout"] = max(0.0, min(0.7, self.hyperparams.get("nn_dropout", 0.3) + random.uniform(-0.1, 0.1)))
+
+
+# ═══════════════════════════════════════════════════════════
+# SECTION 4: FITNESS EVALUATION (multi-objective)
+# ═══════════════════════════════════════════════════════════
+
+def evaluate_individual(ind, X, y, n_splits=5, use_gpu=False, _eval_counter=[0]):
+    """
+    Evaluate one individual via walk-forward backtest.
+    Multi-objective: Brier + ROI + Sharpe + Calibration.
+    Includes memory management for 16GB RAM with 500 individuals.
+
+    Post-hoc Platt Scaling (added 2026-03-21):
+      Each train fold is split 80/20 into train_proper + calibration_set.
+      A LogisticRegression is fitted on (raw_probs_cal, y_cal) and used to
+      transform test probabilities → calibrated probabilities before computing
+      all downstream metrics (Brier, ROI, ECE).  This removes systematic
+      over/under-confidence from tree-based models without touching cv=3 inner
+      calibration, giving an expected Brier improvement of -0.008 to -0.015.
+    """
+    _eval_counter[0] += 1
+    if _eval_counter[0] % 10 == 0:
+        gc.collect()
+    from sklearn.model_selection import TimeSeriesSplit
+    from sklearn.metrics import brier_score_loss
+    from sklearn.calibration import CalibratedClassifierCV
+    from sklearn.linear_model import LogisticRegression
+
+    selected = ind.selected_indices()
+    if len(selected) < 15 or len(selected) > Individual.MAX_FEATURES:
+        ind.fitness = {"brier": 0.30, "roi": -0.10, "sharpe": -1.0, "calibration": 0.15, "calibration_error": 0.15, "composite": -1.0}
+        return
+
+    X_sub = X[:, selected]
+    X_sub = np.nan_to_num(X_sub, nan=0.0, posinf=1e6, neginf=-1e6)
+    tscv = TimeSeriesSplit(n_splits=n_splits)
+    hp = ind.hyperparams
+
+    model = _build_model(hp, use_gpu)
+    if model is None:
+        ind.fitness["composite"] = -1.0
+        return
+
+    is_icl = hp["model_type"] in ICL_MODEL_TYPES
+    briers, rois, all_probs, all_y = [], [], [], []
+
+    for ti, vi in tscv.split(X_sub):
+        try:
+            # ── ICL models (TabICLv2, TabPFN): no clone via get_params, no calibration wrapper ──
+            if is_icl:
+                m = _build_model(hp, use_gpu)
+                m.fit(X_sub[ti], y[ti])
+                probs = m.predict_proba(X_sub[vi])[:, 1]
+            else:
+                # ── Platt Scaling: split train fold 80/20 → proper + calibration ──
+                cal_split = max(1, int(len(ti) * 0.20))
+                ti_proper = ti[:-cal_split]
+                ti_cal    = ti[-cal_split:]
+
+                m = type(model)(**model.get_params())
+                if hp["calibration"] != "none":
+                    m = CalibratedClassifierCV(m, method=hp["calibration"], cv=3)
+
+                m.fit(X_sub[ti_proper], y[ti_proper])
+
+                raw_cal = m.predict_proba(X_sub[ti_cal])[:, 1].reshape(-1, 1)
+                y_cal   = y[ti_cal]
+
+                platt = LogisticRegression(C=1.0, solver="lbfgs", max_iter=200, random_state=42)
+                platt.fit(raw_cal, y_cal)
+
+                raw_test = m.predict_proba(X_sub[vi])[:, 1].reshape(-1, 1)
+                probs = platt.predict_proba(raw_test)[:, 1]
+
+            briers.append(brier_score_loss(y[vi], probs))
+            rois.append(_simulate_betting(probs, y[vi]))
+            all_probs.extend(probs)
+            all_y.extend(y[vi])
+        except Exception:
+            briers.append(0.28)
+            rois.append(-0.05)
+
+    avg_brier = np.mean(briers)
+    avg_roi = np.mean(rois)
+    sharpe = np.mean(rois) / max(np.std(rois), 0.01) if len(rois) > 1 else 0.0
+    cal_err = _calibration_error(np.array(all_probs), np.array(all_y)) if all_probs else 0.15
+
+    # Multi-objective composite fitness (higher = better)
+    # Feature penalty: penalize bloated individuals (n_features > 80)
+    n_feat = ind.n_features
+    feat_penalty = max(0, (n_feat - 80) / 200) * 0.05  # up to -0.03 for 200 features
+
+    composite = (
+        0.40 * (1 - avg_brier) +      # Brier: lower is better
+        0.25 * max(0, avg_roi) +        # ROI: higher is better
+        0.20 * max(0, sharpe / 3) +     # Sharpe: higher is better
+        0.15 * (1 - cal_err)            # Calibration: lower is better
+        - feat_penalty                  # Parsimony pressure for n_features > 80
+    )
+
+    ind.fitness = {
+        "brier": round(avg_brier, 5),
+        "roi": round(avg_roi, 4),
+        "sharpe": round(sharpe, 4),
+        "calibration": round(cal_err, 4),
+        "calibration_error": round(cal_err, 4),   # ECE with 10 bins, on calibrated probs
+        "composite": round(composite, 5),
+    }
+
+
+def _build_model(hp, use_gpu=False):
+    """Build ML model from hyperparameters."""
+    mt = hp["model_type"]
+    try:
+        if mt == "xgboost":
+            import xgboost as xgb
+            params = {
+                "n_estimators": hp["n_estimators"],
+                "max_depth": hp["max_depth"],
+                "learning_rate": hp["learning_rate"],
+                "subsample": hp["subsample"],
+                "colsample_bytree": hp["colsample_bytree"],
+                "min_child_weight": hp["min_child_weight"],
+                "reg_alpha": hp["reg_alpha"],
+                "reg_lambda": hp["reg_lambda"],
+                "eval_metric": "logloss",
+                "random_state": 42,
+                "n_jobs": -1,
+                "tree_method": "hist",
+            }
+            if use_gpu:
+                params["device"] = "cuda"
+            return xgb.XGBClassifier(**params)
+        elif mt == "lightgbm":
+            import lightgbm as lgbm
+            return lgbm.LGBMClassifier(
+                n_estimators=hp["n_estimators"],
+                max_depth=hp["max_depth"],
+                learning_rate=hp["learning_rate"],
+                subsample=hp["subsample"],
+                num_leaves=min(2 ** hp["max_depth"] - 1, 127),
+                reg_alpha=hp["reg_alpha"],
+                reg_lambda=hp["reg_lambda"],
+                # DART P012: dropout trees — better probability calibration, reduces reliability error
+                boosting_type="dart", drop_rate=0.1, skip_drop=0.5, uniform_drop=True,
+                verbose=-1, random_state=42, n_jobs=-1,
+            )
+        elif mt == "catboost":
+            from catboost import CatBoostClassifier
+            # CPU speed fix: cap iterations to 60 on CPU (catboost is 3-5x slower than lightgbm)
+            _cat_iters = hp["n_estimators"]
+            if not use_gpu:
+                _cat_iters = min(_cat_iters, 60)
+            _cat_params = dict(
+                iterations=_cat_iters,
+                depth=min(hp["max_depth"], 10),
+                learning_rate=hp["learning_rate"],
+                l2_leaf_reg=hp["reg_lambda"],
+                verbose=0, random_state=42,
+            )
+            if not use_gpu:
+                _cat_params["early_stopping_rounds"] = 15
+            return CatBoostClassifier(**_cat_params)
+        elif mt == "random_forest":
+            from sklearn.ensemble import RandomForestClassifier
+            return RandomForestClassifier(
+                n_estimators=hp["n_estimators"],
+                max_depth=hp["max_depth"],
+                min_samples_leaf=max(1, hp["min_child_weight"]),
+                random_state=42, n_jobs=-1,
+            )
+        elif mt == "extra_trees":
+            from sklearn.ensemble import ExtraTreesClassifier
+            return ExtraTreesClassifier(
+                n_estimators=hp["n_estimators"],
+                max_depth=hp["max_depth"],
+                min_samples_leaf=max(1, hp["min_child_weight"]),
+                random_state=42, n_jobs=-1,
+            )
+        elif mt == "xgboost_brier":
+            import xgboost as xgb
+            def _brier_objective(y_true, y_pred):
+                grad = 2.0 * (y_pred - y_true)
+                hess = np.full_like(grad, 2.0)
+                return grad, hess
+            params = {
+                "n_estimators": hp["n_estimators"],
+                "max_depth": hp["max_depth"],
+                "learning_rate": hp["learning_rate"],
+                "subsample": hp["subsample"],
+                "colsample_bytree": hp["colsample_bytree"],
+                "min_child_weight": hp["min_child_weight"],
+                "reg_alpha": hp["reg_alpha"],
+                "reg_lambda": hp["reg_lambda"],
+                "objective": _brier_objective,
+                "random_state": 42,
+                "n_jobs": -1,
+                "tree_method": "hist",
+            }
+            if use_gpu:
+                params["device"] = "cuda"
+            return xgb.XGBClassifier(**params)
+        elif mt == "tabicl":
+            from tabicl import TabICLClassifier
+            return TabICLClassifier()
+        elif mt == "tabpfn":
+            from tabpfn import TabPFNClassifier
+            return TabPFNClassifier(device="cuda" if use_gpu else "cpu")
+        elif mt == "stacking":
+            from sklearn.ensemble import StackingClassifier, RandomForestClassifier, GradientBoostingClassifier
+            from sklearn.linear_model import LogisticRegression
+            estimators = [
+                ("rf", RandomForestClassifier(n_estimators=100, max_depth=hp["max_depth"], random_state=42, n_jobs=-1)),
+                ("gb", GradientBoostingClassifier(n_estimators=100, max_depth=min(hp["max_depth"], 6), learning_rate=hp["learning_rate"], random_state=42)),
+            ]
+            try:
+                import xgboost as xgb
+                estimators.append(("xgb", xgb.XGBClassifier(n_estimators=100, max_depth=hp["max_depth"], learning_rate=hp["learning_rate"], eval_metric="logloss", random_state=42, n_jobs=-1)))
+            except ImportError:
+                pass
+            return StackingClassifier(estimators=estimators, final_estimator=LogisticRegression(max_iter=500), cv=3, n_jobs=-1)
+        elif mt == "mlp":
+            from sklearn.neural_network import MLPClassifier
+            hidden = tuple([hp.get("nn_hidden_dims", 128)] * hp.get("nn_n_layers", 2))
+            return MLPClassifier(
+                hidden_layer_sizes=hidden,
+                learning_rate_init=hp["learning_rate"],
+                max_iter=hp.get("nn_epochs", 50),
+                alpha=hp["reg_alpha"],
+                random_state=42,
+            )
+        else:
+            # Fallback for unknown types (lstm, transformer, tabnet, etc.) — use GBM
+            from sklearn.ensemble import GradientBoostingClassifier
+            return GradientBoostingClassifier(
+                n_estimators=min(hp["n_estimators"], 200),
+                max_depth=hp["max_depth"],
+                learning_rate=hp["learning_rate"],
+                random_state=42,
+            )
+    except ImportError:
+        from sklearn.ensemble import GradientBoostingClassifier
+        return GradientBoostingClassifier(
+            n_estimators=min(hp["n_estimators"], 200),
+            max_depth=hp["max_depth"],
+            learning_rate=hp["learning_rate"],
+            random_state=42,
+        )
+    return None
+
+
+def _simulate_betting(probs, actuals, edge=0.05, vig=0.045):
+    """Simulate flat betting with realistic market odds (including vig).
+
+    Market line estimated as midpoint between our model and 50/50 (conservative).
+    Payout at market decimal odds with vig baked in.
+    This gives a realistic ROI vs the old fair-value (1/prob) approach.
+    """
+    stake = 10
+    profit = 0
+    n_bets = 0
+    for prob, actual in zip(probs, actuals):
+        # Market prob ~ halfway between our model and 50/50
+        market_prob = 0.5 + (prob - 0.5) * 0.5
+        if prob > 0.5 + edge:
+            # Bet home: market pays at their (less favorable) odds with vig
+            market_decimal = 1.0 / (market_prob * (1 + vig / 2))
+            n_bets += 1
+            if actual == 1:
+                profit += stake * (market_decimal - 1)
+            else:
+                profit -= stake
+        elif prob < 0.5 - edge:
+            # Bet away
+            away_market = 1.0 - market_prob
+            market_decimal = 1.0 / (away_market * (1 + vig / 2))
+            n_bets += 1
+            if actual == 0:
+                profit += stake * (market_decimal - 1)
+            else:
+                profit -= stake
+    return profit / (n_bets * stake) if n_bets > 0 else 0.0
+
+
+def _calibration_error(probs, actuals, n_bins=10):
+    """Expected Calibration Error (ECE)."""
+    if len(probs) == 0:
+        return 1.0
+    bins = np.linspace(0, 1, n_bins + 1)
+    ece = 0
+    for i in range(n_bins):
+        mask = (probs >= bins[i]) & (probs < bins[i + 1])
+        if mask.sum() == 0:
+            continue
+        ece += mask.sum() / len(probs) * abs(probs[mask].mean() - actuals[mask].mean())
+    return ece
+
+
+# ═══════════════════════════════════════════════════════════
+# SECTION 5: GENETIC EVOLUTION ENGINE
+# ═══════════════════════════════════════════════════════════
+
+class GeneticEvolutionEngine:
+    """
+    REAL genetic evolution engine.
+    Runs continuously, evolving a population of model configs.
+    """
+
+    def __init__(self, pop_size=500, elite_size=25, mutation_rate=0.15,
+                 crossover_rate=0.85, target_features=100, n_splits=3,
+                 n_islands=5, migration_interval=10, migrants_per_island=5):
+        self.pop_size = pop_size
+        self.elite_size = elite_size
+        self.base_mutation_rate = mutation_rate
+        self.mutation_rate = mutation_rate
+        self.mut_floor = 0.05
+        self.mut_decay = 0.995
+        self.crossover_rate = crossover_rate
+        self.target_features = target_features
+        self.n_splits = n_splits
+        self.n_islands = n_islands
+        self.island_size = pop_size // n_islands
+        self.migration_interval = migration_interval
+        self.migrants_per_island = migrants_per_island
+
+        self.population = []
+        self.generation = 0
+        self.best_ever = None
+        self.history = []
+        self.stagnation_counter = 0
+        self.use_gpu = False
+        # Hamming diversity tracking
+        self._pop_centroid = None        # float list — mean feature mask over population
+        self._hamming_diversity = 1.0   # normalized average pairwise Hamming distance
+        self._no_improve_counter = 0    # gens without best-ever composite improvement
+
+        # Detect GPU
+        try:
+            import xgboost as xgb
+            _test = xgb.XGBClassifier(n_estimators=5, max_depth=3, tree_method="hist", device="cuda")
+            _test.fit(np.random.randn(50, 5), np.random.randint(0, 2, 50))
+            self.use_gpu = True
+            print("[GPU] XGBoost CUDA: ENABLED")
+        except Exception:
+            print("[GPU] XGBoost CUDA: disabled, using CPU")
+
+    def initialize(self, n_features):
+        """Create initial random population."""
+        self.n_features = n_features
+        self.population = [Individual(n_features, self.target_features) for _ in range(self.pop_size)]
+        print(f"[INIT] Population: {self.pop_size} individuals, {n_features} feature candidates, "
+              f"~{self.target_features} target features")
+
+    def restore_state(self):
+        """Restore population from saved state (survive restarts)."""
+        state_file = STATE_DIR / "population.json"
+        if not state_file.exists():
+            return False
+        try:
+            state = json.loads(state_file.read_text())
+            self.generation = state["generation"]
+            self.n_features = state["n_features"]
+            self.history = state.get("history", [])
+            self.stagnation_counter = state.get("stagnation_counter", 0)
+            self.mutation_rate = state.get("mutation_rate", self.base_mutation_rate)
+
+            self.population = []
+            for ind_data in state["population"]:
+                ind = Individual.__new__(Individual)
+                ind.features = ind_data["features"]
+                ind.hyperparams = ind_data["hyperparams"]
+                ind.fitness = ind_data["fitness"]
+                ind.generation = ind_data.get("generation", 0)
+                ind.birth_generation = ind_data.get("birth_generation", ind.generation)
+                ind.n_features = sum(ind.features)
+                self.population.append(ind)
+
+            if state.get("best_ever"):
+                be = state["best_ever"]
+                self.best_ever = Individual.__new__(Individual)
+                self.best_ever.features = be["features"]
+                self.best_ever.hyperparams = be["hyperparams"]
+                self.best_ever.fitness = be["fitness"]
+                self.best_ever.generation = be.get("generation", 0)
+                self.best_ever.n_features = sum(self.best_ever.features)
+
+            print(f"[RESTORE] Generation {self.generation}, {len(self.population)} individuals, "
+                  f"best Brier={self.best_ever.fitness['brier']:.4f}" if self.best_ever else "")
+            return True
+        except Exception as e:
+            print(f"[RESTORE] Failed: {e}")
+            return False
+
+    def resize_population_features(self, new_n_features):
+        """Resize feature masks if feature count changed (e.g., new features added)."""
+        old_n = self.n_features
+        if old_n == new_n_features:
+            return
+        delta = new_n_features - old_n
+        print(f"[RESIZE] Feature count changed: {old_n} -> {new_n_features} (delta={delta})")
+        self.n_features = new_n_features
+        for ind in self.population:
+            if len(ind.features) < new_n_features:
+                # Extend with random activation for new features (50% chance each)
+                ind.features.extend([1 if random.random() < 0.3 else 0 for _ in range(new_n_features - len(ind.features))])
+            elif len(ind.features) > new_n_features:
+                ind.features = ind.features[:new_n_features]
+            ind.n_features = sum(ind.features)
+        if self.best_ever:
+            if len(self.best_ever.features) < new_n_features:
+                self.best_ever.features.extend([0] * (new_n_features - len(self.best_ever.features)))
+            elif len(self.best_ever.features) > new_n_features:
+                self.best_ever.features = self.best_ever.features[:new_n_features]
+            self.best_ever.n_features = sum(self.best_ever.features)
+        print(f"[RESIZE] All {len(self.population)} individuals resized")
+
+    def save_state(self):
+        """Save population state to survive restarts."""
+        state = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "generation": self.generation,
+            "n_features": self.n_features,
+            "stagnation_counter": self.stagnation_counter,
+            "mutation_rate": self.mutation_rate,
+            "population": [
+                {
+                    "features": ind.features,
+                    "hyperparams": {k: (float(v) if isinstance(v, (np.floating,)) else v)
+                                    for k, v in ind.hyperparams.items()},
+                    "fitness": ind.fitness,
+                    "generation": ind.generation,
+                    "birth_generation": getattr(ind, 'birth_generation', ind.generation),
+                }
+                for ind in self.population
+            ],
+            "best_ever": {
+                "features": self.best_ever.features,
+                "hyperparams": {k: (float(v) if isinstance(v, (np.floating,)) else v)
+                                for k, v in self.best_ever.hyperparams.items()},
+                "fitness": self.best_ever.fitness,
+                "generation": self.best_ever.generation,
+            } if self.best_ever else None,
+            "history": self.history[-200:],
+        }
+        (STATE_DIR / "population.json").write_text(json.dumps(state, default=str))
+
+    # ── Hamming Diversity Utilities ──────────────────────────────────────────
+
+    def _update_pop_centroid(self):
+        """Compute and cache the population centroid (mean feature mask).
+
+        The centroid[i] is the fraction of individuals that have feature i active.
+        Used by _tournament_select for crowding distance.
+        """
+        if not self.population:
+            return
+        n = len(self.population[0].features)
+        centroid = [0.0] * n
+        for ind in self.population:
+            for i, v in enumerate(ind.features):
+                centroid[i] += v
+        pop_len = len(self.population)
+        self._pop_centroid = [c / pop_len for c in centroid]
+
+    def _compute_hamming_diversity(self, sample_size=50):
+        """Compute the normalized average pairwise Hamming distance of the population.
+
+        Exact O(N²) computation is expensive for pop_size=500, so we use a
+        random sample of up to `sample_size` pairs for efficiency.
+
+        Returns a float in [0, 1].  A value of 0 means all feature masks are
+        identical; a value of 1 means every bit differs between every pair.
+        """
+        pop = self.population
+        if len(pop) < 2:
+            return 1.0
+        n_feat = len(pop[0].features)
+        if n_feat == 0:
+            return 0.0
+
+        # Random sampling: up to sample_size² / 2 pairs
+        indices = list(range(len(pop)))
+        random.shuffle(indices)
+        sample = indices[:sample_size]
+
+        total_dist = 0.0
+        n_pairs = 0
+        for i in range(len(sample)):
+            for j in range(i + 1, len(sample)):
+                f1 = pop[sample[i]].features
+                f2 = pop[sample[j]].features
+                total_dist += sum(a != b for a, b in zip(f1, f2)) / n_feat
+                n_pairs += 1
+
+        return total_dist / n_pairs if n_pairs > 0 else 1.0
+
+    def evolve_one_generation(self, X, y):
+        """Run one generation of evolution. Returns best individual."""
+        self.generation += 1
+        gen_start = time.time()
+
+        # 1. Evaluate all individuals
+        for i, ind in enumerate(self.population):
+            evaluate_individual(ind, X, y, self.n_splits, self.use_gpu)
+            if (i + 1) % 10 == 0:
+                print(f"  Evaluated {i+1}/{len(self.population)}...", end="\r")
+
+        # 2. Sort by composite fitness (higher = better)
+        self.population.sort(key=lambda x: x.fitness["composite"], reverse=True)
+        best = self.population[0]
+
+        # 3. Track best ever
+        prev_best_brier = self.best_ever.fitness["brier"] if self.best_ever else 1.0
+        if self.best_ever is None or best.fitness["composite"] > self.best_ever.fitness["composite"]:
+            self.best_ever = Individual.__new__(Individual)
+            self.best_ever.features = best.features[:]
+            self.best_ever.hyperparams = dict(best.hyperparams)
+            self.best_ever.fitness = dict(best.fitness)
+            self.best_ever.n_features = best.n_features
+            self.best_ever.generation = self.generation
+
+        # 4. Stagnation detection — track BOTH Brier and composite
+        prev_best_composite = self.best_ever.fitness["composite"] if self.best_ever and hasattr(self.best_ever, 'fitness') else 0.0
+        brier_stagnant = abs(best.fitness["brier"] - prev_best_brier) < 0.0005
+        composite_stagnant = abs(best.fitness["composite"] - prev_best_composite) < 0.001
+        if brier_stagnant and composite_stagnant:
+            self.stagnation_counter += 1
+            self._no_improve_counter += 1
+        elif not brier_stagnant:
+            self.stagnation_counter = max(0, self.stagnation_counter - 2)  # Partial reset
+            self._no_improve_counter = 0
+        else:
+            self.stagnation_counter = max(0, self.stagnation_counter - 1)
+            self._no_improve_counter = 0
+
+        # 4b. Hamming Diversity Monitor
+        # Compute normalized average pairwise Hamming distance; also refresh centroid
+        # (used by crowding-aware tournament selection below).
+        self._hamming_diversity = self._compute_hamming_diversity(sample_size=50)
+        self._update_pop_centroid()
+        if self._hamming_diversity < 0.15:
+            print(f"  [DIVERSITY-LOW] Hamming diversity={self._hamming_diversity:.3f} < 0.15 threshold")
+
+        # 4c. Adaptive Mutation Rate — diversity-driven formula
+        # Base = 0.03; rises smoothly toward 0.10 as diversity falls below 0.25.
+        # Formula: mutation_rate = 0.03 + 0.07 * max(0, 1 - diversity / 0.25)
+        diversity_mutation = 0.03 + 0.07 * max(0.0, 1.0 - self._hamming_diversity / 0.25)
+        # Stagnation boosts applied on top (capped at 0.25)
+        if self.stagnation_counter >= 10:
+            self.mutation_rate = min(0.15, diversity_mutation * 1.8)
+            print(f"  [STAGNATION-CRITICAL] {self.stagnation_counter} gens — "
+                  f"mutation rate -> {self.mutation_rate:.3f} (diversity={self._hamming_diversity:.3f})")
+        elif self.stagnation_counter >= 7:
+            self.mutation_rate = min(0.15, diversity_mutation * 1.5)
+            print(f"  [STAGNATION] {self.stagnation_counter} gens — "
+                  f"mutation rate -> {self.mutation_rate:.3f} (diversity={self._hamming_diversity:.3f})")
+        elif self.stagnation_counter >= 3:
+            self.mutation_rate = min(0.12, diversity_mutation * 1.2)
+        else:
+            # Normal regime: formula drives the rate directly
+            self.mutation_rate = diversity_mutation
+
+        # 5. Record history
+        self.history.append({
+            "gen": self.generation,
+            "best_brier": best.fitness["brier"],
+            "best_roi": best.fitness["roi"],
+            "best_sharpe": best.fitness["sharpe"],
+            "best_composite": best.fitness["composite"],
+            "best_calibration_error": best.fitness.get("calibration_error", best.fitness.get("calibration", 1.0)),
+            "n_features": best.n_features,
+            "model_type": best.hyperparams["model_type"],
+            "mutation_rate": round(self.mutation_rate, 4),
+            "avg_composite": round(np.mean([ind.fitness["composite"] for ind in self.population]), 5),
+            "pop_diversity": round(np.std([ind.n_features for ind in self.population]), 1),
+            "hamming_diversity": round(self._hamming_diversity, 4),
+        })
+
+        elapsed = time.time() - gen_start
+        ece_val = best.fitness.get("calibration_error", best.fitness.get("calibration", 1.0))
+        print(f"  Gen {self.generation}: Brier={best.fitness['brier']:.4f} "
+              f"ROI={best.fitness['roi']:.1%} Sharpe={best.fitness['sharpe']:.2f} "
+              f"ECE={ece_val:.4f} Features={best.n_features} Model={best.hyperparams['model_type']} "
+              f"Composite={best.fitness['composite']:.4f} "
+              f"Diversity={self._hamming_diversity:.3f} MutRate={self.mutation_rate:.3f} ({elapsed:.0f}s)")
+
+        # 6. Create next generation
+        new_pop = []
+
+        # Elitism — protect top by composite AND top by raw Brier (prevents fossil loss)
+        def _clone_individual(src):
+            clone = Individual.__new__(Individual)
+            clone.features = src.features[:]
+            clone.hyperparams = dict(src.hyperparams)
+            clone.fitness = dict(src.fitness)
+            clone.n_features = src.n_features
+            clone.generation = src.generation
+            clone.birth_generation = getattr(src, 'birth_generation', src.generation)
+            return clone
+
+        # Top elite_size by composite (already sorted)
+        elite_ids = set()
+        for i in range(min(self.elite_size, len(self.population))):
+            new_pop.append(_clone_individual(self.population[i]))
+            elite_ids.add(id(self.population[i]))
+
+        # Also protect top-2 by raw Brier score (lower = better) if not already elite
+        brier_sorted = sorted(self.population, key=lambda x: x.fitness["brier"])
+        for ind in brier_sorted[:2]:
+            if id(ind) not in elite_ids:
+                new_pop.append(_clone_individual(ind))
+                elite_ids.add(id(ind))
+
+        # Aging: remove individuals that have survived > 15 generations without improvement
+        MAX_AGE = 15
+        aged_out = 0
+        for i in range(len(new_pop) - 1, self.elite_size - 1, -1):
+            if i < len(new_pop):
+                age = self.generation - getattr(new_pop[i], 'birth_generation', 0)
+                if age > MAX_AGE and new_pop[i].fitness["composite"] < new_pop[0].fitness["composite"] * 0.95:
+                    new_pop.pop(i)
+                    aged_out += 1
+        if aged_out > 0:
+            print(f"  [AGING] {aged_out} stale individuals removed")
+
+        # Injection: smarter — at stagnation >= 7 inject targeted mutants of best, not just random
+        n_inject = 0
+        if self.stagnation_counter >= 7:
+            n_inject = self.pop_size // 4
+            # Half random, half targeted mutations of best individual
+            n_random = n_inject // 2
+            n_mutant = n_inject - n_random
+            for _ in range(n_random):
+                new_pop.append(Individual(self.n_features, self.target_features))
+            # Targeted mutants: take best, apply heavy mutation
+            for _ in range(n_mutant):
+                mutant = Individual.__new__(Individual)
+                mutant.features = self.population[0].features[:]
+                mutant.hyperparams = dict(self.population[0].hyperparams)
+                mutant.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "calibration_error": 1.0, "composite": 0.0}
+                mutant.birth_generation = self.generation
+                mutant.n_features = self.population[0].n_features
+                mutant.generation = self.generation
+                mutant.mutate(0.25)  # Heavy mutation
+                new_pop.append(mutant)
+            print(f"  [INJECTION] {n_random} random + {n_mutant} targeted mutants (stagnation={self.stagnation_counter})")
+        elif self.stagnation_counter >= 3:
+            # Mild injection: 10% fresh individuals
+            n_inject = self.pop_size // 10
+            for _ in range(n_inject):
+                new_pop.append(Individual(self.n_features, self.target_features))
+            print(f"  [INJECTION-MILD] {n_inject} fresh individuals (stagnation={self.stagnation_counter})")
+
+        # Diversity Injection: triggered independently when diversity is critically low
+        # (diversity < 0.15) OR when there has been no fitness improvement for 5
+        # consecutive generations — whichever happens first.  Elites are always kept.
+        diversity_trigger = (self._hamming_diversity < 0.15) or (self._no_improve_counter >= 5)
+        if diversity_trigger and n_inject == 0:
+            # Inject 20% of population as freshly randomized individuals (elites already in new_pop)
+            n_diversity_inject = max(1, self.pop_size // 5)
+            # Cap to avoid going way over pop_size before the fill loop
+            slots_remaining = max(0, self.pop_size - len(new_pop) - n_diversity_inject)
+            for _ in range(n_diversity_inject):
+                new_pop.append(Individual(self.n_features, self.target_features))
+            trigger_reason = (
+                f"diversity={self._hamming_diversity:.3f}<0.15"
+                if self._hamming_diversity < 0.15
+                else f"no_improve={self._no_improve_counter}>=5"
+            )
+            print(f"  [DIVERSITY-INJECT] {n_diversity_inject} fresh individuals injected "
+                  f"({trigger_reason}), elites preserved")
+
+        # Fill with crossover + mutation
+        while len(new_pop) < self.pop_size:
+            # Diversity-aware tournament: 80% fitness-based, 20% diversity-based
+            if random.random() < 0.2:
+                p1 = self._diversity_select(7)
+                p2 = self._tournament_select(7)
+            else:
+                p1 = self._tournament_select(7)
+                p2 = self._tournament_select(7)
+            if random.random() < self.crossover_rate:
+                child = Individual.crossover(p1, p2)
+            else:
+                child = Individual.__new__(Individual)
+                child.features = p1.features[:]
+                child.hyperparams = dict(p1.hyperparams)
+                child.fitness = dict(p1.fitness)
+                child.n_features = p1.n_features
+                child.generation = self.generation
+                child.birth_generation = self.generation
+            child.mutate(self.mutation_rate)
+            new_pop.append(child)
+
+        self.population = new_pop[:self.pop_size]
+        return best
+
+    def _tournament_select(self, k=7):
+        """Tournament selection with crowding.
+
+        Standard tournament selection, but when two candidates have similar
+        composite fitness (within 5%), prefer the one that is more unique —
+        measured by Hamming distance from the population centroid.  This
+        implements a lightweight niching pressure that rewards exploration
+        without discarding high-quality individuals.
+        """
+        contestants = random.sample(self.population, min(k, len(self.population)))
+        best = max(contestants, key=lambda x: x.fitness["composite"])
+        best_fit = best.fitness["composite"]
+
+        # Among contestants within 5% of the best, prefer the most unique one
+        similar = [c for c in contestants if best_fit > 0 and
+                   abs(c.fitness["composite"] - best_fit) / max(abs(best_fit), 1e-9) < 0.05]
+        if len(similar) > 1 and hasattr(self, '_pop_centroid') and self._pop_centroid is not None:
+            centroid = self._pop_centroid
+            def _dist_from_centroid(ind):
+                f = ind.features
+                n = len(f)
+                if n == 0 or len(centroid) != n:
+                    return 0.0
+                return sum(abs(f[i] - centroid[i]) for i in range(n)) / n
+            best = max(similar, key=_dist_from_centroid)
+
+        return best
+
+    def _diversity_select(self, k=7):
+        """Diversity-preserving selection: pick the most unique individual from k random."""
+        contestants = random.sample(self.population, min(k, len(self.population)))
+        if not self.population:
+            return contestants[0]
+        # Measure uniqueness: how different is this individual's feature set from the elite?
+        elite_features = set()
+        for i, ind in enumerate(self.population[:self.elite_size]):
+            elite_features.update(ind.selected_indices())
+        best_diversity = -1
+        best_ind = contestants[0]
+        for c in contestants:
+            c_features = set(c.selected_indices())
+            if not c_features:
+                continue
+            overlap = len(c_features & elite_features) / max(len(c_features), 1)
+            diversity = 1.0 - overlap
+            # Weight by fitness to avoid picking terrible individuals
+            score = diversity * 0.6 + max(0, c.fitness["composite"]) * 0.4
+            if score > best_diversity:
+                best_diversity = score
+                best_ind = c
+        return best_ind
+
+    def save_cycle_results(self, feature_names):
+        """Save results after a cycle of generations."""
+        if not self.best_ever:
+            return
+
+        selected_names = [feature_names[i] for i in self.best_ever.selected_indices()
+                          if i < len(feature_names)]
+
+        results = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "generation": self.generation,
+            "population_size": self.pop_size,
+            "feature_candidates": self.n_features,
+            "mutation_rate": round(self.mutation_rate, 4),
+            "stagnation_counter": self.stagnation_counter,
+            "gpu": self.use_gpu,
+            "best": {
+                "brier": self.best_ever.fitness["brier"],
+                "roi": self.best_ever.fitness["roi"],
+                "sharpe": self.best_ever.fitness["sharpe"],
+                "calibration": self.best_ever.fitness["calibration"],
+                "calibration_error": self.best_ever.fitness.get("calibration_error", self.best_ever.fitness["calibration"]),
+                "composite": self.best_ever.fitness["composite"],
+                "n_features": self.best_ever.n_features,
+                "model_type": self.best_ever.hyperparams["model_type"],
+                "hyperparams": {k: (float(v) if isinstance(v, (np.floating, np.integer)) else v)
+                                for k, v in self.best_ever.hyperparams.items()},
+                "selected_features": selected_names[:50],
+            },
+            "top5": [ind.to_dict() for ind in sorted(
+                self.population, key=lambda x: x.fitness["composite"], reverse=True
+            )[:5]],
+            "history_last20": self.history[-20:],
+        }
+
+        # Save timestamped + latest
+        ts = datetime.now().strftime("%Y%m%d-%H%M")
+        (RESULTS_DIR / f"evolution-{ts}.json").write_text(json.dumps(results, indent=2, default=str))
+        (RESULTS_DIR / "evolution-latest.json").write_text(json.dumps(results, indent=2, default=str))
+        return results
+
+
+# ═══════════════════════════════════════════════════════════
+# SECTION 6: VM CALLBACK
+# ═══════════════════════════════════════════════════════════
+
+def callback_to_vm(results):
+    """POST results to VM data server (best-effort)."""
+    import urllib.request
+    try:
+        url = f"{VM_CALLBACK_URL}/callback/evolution"
+        body = json.dumps(results, default=str).encode()
+        req = urllib.request.Request(url, data=body, headers={"Content-Type": "application/json"})
+        resp = urllib.request.urlopen(req, timeout=10)
+        print(f"  [CALLBACK] VM notified: {resp.status}")
+    except Exception as e:
+        # Best-effort, don't block on failure
+        print(f"  [CALLBACK] VM unreachable: {e}")
+
+    # Also try to write to shared mon-ipad data if accessible
+    try:
+        shared = Path("/home/termius/mon-ipad/data/nba-agent/evolution-latest.json")
+        if shared.parent.exists():
+            shared.write_text(json.dumps(results, indent=2, default=str))
+            print(f"  [CALLBACK] Wrote to mon-ipad")
+    except Exception:
+        pass
+
+
+# ═══════════════════════════════════════════════════════════
+# SECTION 7: MAIN LOOP (continuous 24/7)
+# ═══════════════════════════════════════════════════════════
+
+def run_continuous(generations_per_cycle=10, total_cycles=None, pop_size=500,
+                   target_features=100, n_splits=5, cool_down=30):
+    """
+    Main entry point — runs genetic evolution CONTINUOUSLY.
+
+    Args:
+        generations_per_cycle: Generations per cycle before saving/callback
+        total_cycles: None = infinite (24/7 mode)
+        pop_size: Population size
+        target_features: Target number of features per individual
+        n_splits: Walk-forward backtest splits
+        cool_down: Seconds between cycles
+    """
+    print("=" * 70)
+    print("  NBA QUANT AI — REAL GENETIC EVOLUTION LOOP v3")
+    print(f"  Started: {datetime.now(timezone.utc).isoformat()}")
+    print(f"  Pop: {pop_size} | Target features: {target_features}")
+    print(f"  Gens/cycle: {generations_per_cycle} | Cycles: {'INFINITE' if total_cycles is None else total_cycles}")
+    print("=" * 70)
+
+    # 1. Pull data
+    print("\n[PHASE 1] Loading data...")
+    pull_seasons()
+    games = load_all_games()
+    print(f"  {len(games)} games loaded")
+    if len(games) < 500:
+        print("  ERROR: Not enough games!")
+        return
+
+    # 2. Build features
+    print("\n[PHASE 2] Building features...")
+    X, y, feature_names = build_features(games)
+    print(f"  Feature matrix: {X.shape} ({len(feature_names)} features)")
+
+    # 3. Initialize engine
+    print("\n[PHASE 3] Initializing engine...")
+    engine = GeneticEvolutionEngine(
+        pop_size=pop_size, elite_size=max(5, pop_size // 20), mutation_rate=0.15,
+        crossover_rate=0.85, target_features=target_features, n_splits=n_splits,
+        n_islands=5, migration_interval=10, migrants_per_island=5,
+    )
+
+    # Try to restore previous state
+    if not engine.restore_state():
+        engine.initialize(X.shape[1])
+    else:
+        # Resize population if feature count changed (new features added)
+        engine.resize_population_features(X.shape[1])
+
+    # ── Supabase Run Logger + Auto-Cut ──
+    run_logger = None
+    if _HAS_LOGGER:
+        try:
+            run_logger = RunLogger(local_dir=str(RESULTS_DIR / "run-logs"))
+            print("[RUN-LOGGER] Supabase logging + auto-cut ACTIVE")
+        except Exception as e:
+            print(f"[RUN-LOGGER] Init failed: {e}")
+
+    # 4. CONTINUOUS EVOLUTION LOOP
+    cycle = 0
+    while True:
+        cycle += 1
+        if total_cycles is not None and cycle > total_cycles:
+            break
+
+        cycle_start = time.time()
+        print(f"\n{'='*60}")
+        print(f"  CYCLE {cycle} — Starting {generations_per_cycle} generations")
+        print(f"  Time: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}")
+        print(f"{'='*60}")
+
+        for gen in range(generations_per_cycle):
+            try:
+                gen_start = time.time()
+                best = engine.evolve_one_generation(X, y)
+
+                # ── Log generation + auto-cut ──
+                if run_logger and best:
+                    try:
+                        pop_div = float(np.std([ind.n_features for ind in engine.population]))
+                        avg_comp = float(np.mean([ind.fitness["composite"] for ind in engine.population]))
+                        run_logger.log_generation(
+                            cycle=cycle, generation=engine.generation,
+                            best={"brier": best.fitness["brier"], "roi": best.fitness["roi"],
+                                  "sharpe": best.fitness["sharpe"], "composite": best.fitness["composite"],
+                                  "n_features": best.n_features, "model_type": best.hyperparams["model_type"]},
+                            mutation_rate=engine.mutation_rate, avg_composite=avg_comp,
+                            pop_diversity=pop_div, duration_s=time.time() - gen_start)
+
+                        # Auto-cut check
+                        cut_actions = run_logger.check_auto_cut(best.fitness, {
+                            "mutation_rate": engine.mutation_rate,
+                            "stagnation": engine.stagnation_counter,
+                            "pop_size": engine.pop_size,
+                            "pop_diversity": pop_div,
+                        })
+                        for action in cut_actions:
+                            atype = action["type"]
+                            params = action.get("params", {})
+                            if atype == "config" and "mutation_rate" in params:
+                                engine.mutation_rate = params["mutation_rate"]
+                            elif atype == "emergency_diversify":
+                                n_new = engine.pop_size // 3
+                                engine.population = sorted(engine.population, key=lambda x: x.fitness["composite"], reverse=True)[:engine.pop_size - n_new]
+                                for _ in range(n_new):
+                                    engine.population.append(Individual(engine.n_features, engine.target_features))
+                                print(f"  [AUTO-CUT] Diversified: {n_new} fresh individuals")
+                            elif atype == "full_reset":
+                                engine.population = sorted(engine.population, key=lambda x: x.fitness["composite"], reverse=True)[:engine.elite_size]
+                                while len(engine.population) < engine.pop_size:
+                                    engine.population.append(Individual(engine.n_features, engine.target_features))
+                                engine.stagnation_counter = 0
+                                print(f"  [AUTO-CUT] FULL RESET executed")
+                    except Exception as e:
+                        print(f"  [RUN-LOGGER] Error: {e}")
+            except Exception as e:
+                print(f"  [ERROR] Generation failed: {e}")
+                traceback.print_exc()
+                continue
+
+        # Save state (survives restarts)
+        engine.save_state()
+
+        # Save results
+        results = engine.save_cycle_results(feature_names)
+
+        cycle_elapsed = time.time() - cycle_start
+        print(f"\n  Cycle {cycle} complete in {cycle_elapsed:.0f}s")
+
+        if engine.best_ever:
+            print(f"  BEST EVER: Brier={engine.best_ever.fitness['brier']:.4f} "
+                  f"ROI={engine.best_ever.fitness['roi']:.1%} "
+                  f"Features={engine.best_ever.n_features}")
+
+        # ── Log cycle to Supabase ──
+        if run_logger and results and engine.best_ever:
+            try:
+                pop_div = float(np.std([ind.n_features for ind in engine.population]))
+                avg_comp = float(np.mean([ind.fitness["composite"] for ind in engine.population]))
+                run_logger.log_cycle(
+                    cycle=cycle, generation=engine.generation,
+                    best=engine.best_ever.fitness | {"n_features": engine.best_ever.n_features,
+                                                      "model_type": engine.best_ever.hyperparams["model_type"]},
+                    pop_size=engine.pop_size, mutation_rate=engine.mutation_rate,
+                    crossover_rate=engine.crossover_rate, stagnation=engine.stagnation_counter,
+                    games=len(games), feature_candidates=X.shape[1],
+                    cycle_duration_s=cycle_elapsed, avg_composite=avg_comp, pop_diversity=pop_div,
+                    top5=results.get("top5"), selected_features=results.get("best", {}).get("selected_features"))
+                print(f"  [RUN-LOGGER] Cycle {cycle} logged to Supabase")
+            except Exception as e:
+                print(f"  [RUN-LOGGER] Cycle log error: {e}")
+
+        # Callback to VM
+        if results:
+            callback_to_vm(results)
+
+        # Refresh data periodically (every 10 cycles)
+        if cycle % 10 == 0:
+            print("\n  [REFRESH] Pulling latest game data...")
+            try:
+                pull_seasons()
+                new_games = load_all_games()
+                if len(new_games) > len(games):
+                    games = new_games
+                    X, y, feature_names = build_features(games)
+                    print(f"  [REFRESH] Updated: {X.shape}")
+            except Exception as e:
+                print(f"  [REFRESH] Failed: {e}")
+
+        if total_cycles is None:
+            print(f"\n  Cooling down {cool_down}s before next cycle...")
+            time.sleep(cool_down)
+
+    print("\n" + "=" * 70)
+    print("  EVOLUTION COMPLETE")
+    if engine.best_ever:
+        print(f"  Final best: Brier={engine.best_ever.fitness['brier']:.4f} "
+              f"ROI={engine.best_ever.fitness['roi']:.1%}")
+    print("=" * 70)
+
+
+# ═══════════════════════════════════════════════════════════
+# CLI ENTRY POINT
+# ═══════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="NBA Quant Genetic Evolution Loop v3")
+    parser.add_argument("--continuous", action="store_true", help="Run 24/7 (no cycle limit)")
+    parser.add_argument("--generations", type=int, default=10, help="Generations per cycle (default: 10)")
+    parser.add_argument("--cycles", type=int, default=None, help="Number of cycles (default: infinite)")
+    parser.add_argument("--pop-size", type=int, default=500, help="Population size (default: 500)")
+    parser.add_argument("--target-features", type=int, default=100, help="Target features (default: 100)")
+    parser.add_argument("--splits", type=int, default=5, help="Walk-forward splits (default: 5)")
+    parser.add_argument("--cooldown", type=int, default=30, help="Seconds between cycles (default: 30)")
+    args = parser.parse_args()
+
+    cycles = None if args.continuous else (args.cycles or 1)
+
+    run_continuous(
+        generations_per_cycle=args.generations,
+        total_cycles=cycles,
+        pop_size=args.pop_size,
+        target_features=args.target_features,
+        n_splits=args.splits,
+        cool_down=args.cooldown,
+    )

evolution/run_logger.py

@@ -0,0 +1,425 @@
+#!/usr/bin/env python3
+"""
+Run Logger & Auto-Cut — Hedge Fund Grade Evolution Monitoring
+================================================================
+Logs EVERY generation, cycle, and eval to Supabase.
+Auto-cuts evolution when regression detected or stagnation exceeds threshold.
+
+Tables (auto-created):
+  - nba_evolution_runs    : one row per cycle (summary)
+  - nba_evolution_gens    : one row per generation (detailed)
+  - nba_evolution_evals   : one row per individual evaluation
+  - nba_evolution_cuts    : log of auto-cut events
+
+Auto-Cut Rules:
+  1. REGRESSION CUT: If best Brier increases by > 0.005 for 3 consecutive gens → rollback
+  2. STAGNATION CUT: If no improvement for 20 gens → emergency diversify + log
+  3. ROI CUT: If ROI drops below -15% → pause betting, continue evolving
+  4. DIVERSITY CUT: If population diversity < 0.05 → inject fresh individuals
+  5. FEATURE CUT: If selected features < 40 → expand target_features
+
+Designed for real-time monitoring via Supabase dashboard or Telegram.
+"""
+
+import os
+import json
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+# ── Supabase connection ──
+_SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
+_DATABASE_URL = os.environ.get("DATABASE_URL", "")
+_SUPABASE_KEY = os.environ.get("SUPABASE_API_KEY", os.environ.get("SUPABASE_ANON_KEY", ""))
+
+_pg_pool = None
+
+def _get_pg():
+    """Lazy PostgreSQL connection pool (Supabase = PostgreSQL)."""
+    global _pg_pool
+    if _pg_pool is not None:
+        return _pg_pool
+    # Read at call time, not import time (HF Spaces set env late)
+    db_url = os.environ.get("DATABASE_URL", "") or _DATABASE_URL
+    if not db_url:
+        print(f"[RUN-LOGGER] DATABASE_URL not set — Supabase logging disabled")
+        return None
+    try:
+        import psycopg2
+        from psycopg2 import pool as pg_pool
+        _pg_pool = pg_pool.SimpleConnectionPool(1, 3, db_url, options="-c search_path=public")
+        # Test the connection
+        conn = _pg_pool.getconn()
+        with conn.cursor() as cur:
+            cur.execute("SELECT 1")
+        _pg_pool.putconn(conn)
+        print(f"[RUN-LOGGER] PostgreSQL connected to Supabase OK")
+        return _pg_pool
+    except Exception as e:
+        print(f"[RUN-LOGGER] PostgreSQL connection failed: {e}")
+        _pg_pool = None
+        return None
+
+
+def _exec_sql(sql, params=None):
+    """Execute SQL on Supabase PostgreSQL. Best-effort, never crashes."""
+    pool = _get_pg()
+    if not pool:
+        return None
+    conn = None
+    try:
+        conn = pool.getconn()
+        with conn.cursor() as cur:
+            cur.execute(sql, params)
+            conn.commit()
+            try:
+                return cur.fetchall()
+            except Exception:
+                return True  # INSERT/UPDATE succeeded but no rows to fetch
+    except Exception as e:
+        if conn:
+            try:
+                conn.rollback()
+            except Exception:
+                pass
+        print(f"[RUN-LOGGER] SQL error: {e}", flush=True)
+        return None
+    finally:
+        if conn and pool:
+            try:
+                pool.putconn(conn)
+            except Exception:
+                pass
+
+
+def _ensure_tables():
+    """Create logging tables if they don't exist."""
+    sqls = [
+        """CREATE TABLE IF NOT EXISTS public.nba_evolution_runs (
+            id SERIAL PRIMARY KEY,
+            ts TIMESTAMPTZ DEFAULT NOW(),
+            cycle INT,
+            generation INT,
+            best_brier FLOAT,
+            best_roi FLOAT,
+            best_sharpe FLOAT,
+            best_calibration FLOAT,
+            best_composite FLOAT,
+            best_features INT,
+            best_model_type TEXT,
+            pop_size INT,
+            mutation_rate FLOAT,
+            crossover_rate FLOAT,
+            stagnation INT,
+            games INT,
+            feature_candidates INT,
+            cycle_duration_s FLOAT,
+            avg_composite FLOAT,
+            pop_diversity FLOAT,
+            top5 JSONB,
+            selected_features JSONB
+        )""",
+        """CREATE TABLE IF NOT EXISTS public.nba_evolution_gens (
+            id SERIAL PRIMARY KEY,
+            ts TIMESTAMPTZ DEFAULT NOW(),
+            cycle INT,
+            generation INT,
+            best_brier FLOAT,
+            best_roi FLOAT,
+            best_sharpe FLOAT,
+            best_composite FLOAT,
+            n_features INT,
+            model_type TEXT,
+            mutation_rate FLOAT,
+            avg_composite FLOAT,
+            pop_diversity FLOAT,
+            gen_duration_s FLOAT,
+            improved BOOLEAN DEFAULT FALSE
+        )""",
+        """CREATE TABLE IF NOT EXISTS public.nba_evolution_cuts (
+            id SERIAL PRIMARY KEY,
+            ts TIMESTAMPTZ DEFAULT NOW(),
+            cut_type TEXT,
+            reason TEXT,
+            brier_before FLOAT,
+            brier_after FLOAT,
+            action_taken TEXT,
+            params_applied JSONB
+        )""",
+        """CREATE TABLE IF NOT EXISTS public.nba_evolution_evals (
+            id SERIAL PRIMARY KEY,
+            ts TIMESTAMPTZ DEFAULT NOW(),
+            generation INT,
+            individual_rank INT,
+            brier FLOAT,
+            roi FLOAT,
+            sharpe FLOAT,
+            composite FLOAT,
+            n_features INT,
+            model_type TEXT
+        )""",
+    ]
+    for sql in sqls:
+        _exec_sql(sql)
+
+
+# ── Auto-initialize tables on import ──
+_tables_ready = False
+
+
+class RunLogger:
+    """Logs evolution runs to Supabase + local files. Never crashes the main loop."""
+
+    def __init__(self, local_dir=None):
+        global _tables_ready
+        self.local_dir = Path(local_dir or "/data/run-logs")
+        self.local_dir.mkdir(parents=True, exist_ok=True)
+
+        # Auto-cut state
+        self.brier_history = []      # last N best Brier values
+        self.regression_count = 0    # consecutive regressions
+        self.stagnation_count = 0
+        self.last_best_brier = 1.0
+        self.last_best_composite = 0.0
+        self.cuts_applied = 0
+
+        # Ensure Supabase tables exist
+        if not _tables_ready:
+            _ensure_tables()
+            _tables_ready = True
+            print("[RUN-LOGGER] Supabase tables ready")
+
+    # ══════════════════════════════════════════
+    #  LOG — Record events
+    # ══════════════════════════════════════════
+
+    def log_generation(self, cycle, generation, best, mutation_rate, avg_composite, pop_diversity, duration_s):
+        """Log one generation result."""
+        improved = best["brier"] < self.last_best_brier - 0.0001
+
+        # Supabase
+        _exec_sql("""INSERT INTO public.nba_evolution_gens
+            (cycle, generation, best_brier, best_roi, best_sharpe, best_composite,
+             n_features, model_type, mutation_rate, avg_composite, pop_diversity,
+             gen_duration_s, improved)
+            VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)""",
+            (cycle, generation, best["brier"], best["roi"], best["sharpe"],
+             best["composite"], best.get("n_features", 0), best.get("model_type", "?"),
+             mutation_rate, avg_composite, pop_diversity, duration_s, improved))
+
+        # Track for auto-cut
+        self.brier_history.append(best["brier"])
+        if len(self.brier_history) > 50:
+            self.brier_history = self.brier_history[-50:]
+
+        return improved
+
+    def log_cycle(self, cycle, generation, best, pop_size, mutation_rate, crossover_rate,
+                  stagnation, games, feature_candidates, cycle_duration_s,
+                  avg_composite, pop_diversity, top5=None, selected_features=None):
+        """Log one full cycle (multiple generations) result."""
+        _exec_sql("""INSERT INTO public.nba_evolution_runs
+            (cycle, generation, best_brier, best_roi, best_sharpe, best_calibration,
+             best_composite, best_features, best_model_type, pop_size, mutation_rate,
+             crossover_rate, stagnation, games, feature_candidates, cycle_duration_s,
+             avg_composite, pop_diversity, top5, selected_features)
+            VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)""",
+            (cycle, generation, best["brier"], best["roi"], best["sharpe"],
+             best.get("calibration", 0), best["composite"], best.get("n_features", 0),
+             best.get("model_type", "?"), pop_size, mutation_rate, crossover_rate,
+             stagnation, games, feature_candidates, cycle_duration_s,
+             avg_composite, pop_diversity,
+             json.dumps(top5 or [], default=str),
+             json.dumps(selected_features or [], default=str)))
+
+        # Local file backup
+        entry = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "cycle": cycle, "generation": generation,
+            "best": best, "pop_size": pop_size,
+            "mutation_rate": mutation_rate, "stagnation": stagnation,
+        }
+        log_file = self.local_dir / f"cycle-{cycle:04d}.json"
+        log_file.write_text(json.dumps(entry, indent=2, default=str))
+
+    def log_top_evals(self, generation, top_individuals):
+        """Log top 10 individuals for this generation."""
+        for rank, ind in enumerate(top_individuals[:10]):
+            _exec_sql("""INSERT INTO public.nba_evolution_evals
+                (generation, individual_rank, brier, roi, sharpe, composite, n_features, model_type)
+                VALUES (%s,%s,%s,%s,%s,%s,%s,%s)""",
+                (generation, rank + 1,
+                 ind.get("brier", ind.get("fitness", {}).get("brier", 0)),
+                 ind.get("roi", ind.get("fitness", {}).get("roi", 0)),
+                 ind.get("sharpe", ind.get("fitness", {}).get("sharpe", 0)),
+                 ind.get("composite", ind.get("fitness", {}).get("composite", 0)),
+                 ind.get("n_features", 0),
+                 ind.get("model_type", ind.get("hyperparams", {}).get("model_type", "?"))))
+
+    def log_cut(self, cut_type, reason, brier_before, brier_after, action, params=None):
+        """Log an auto-cut event."""
+        _exec_sql("""INSERT INTO public.nba_evolution_cuts
+            (cut_type, reason, brier_before, brier_after, action_taken, params_applied)
+            VALUES (%s,%s,%s,%s,%s,%s)""",
+            (cut_type, reason, brier_before, brier_after, action,
+             json.dumps(params or {}, default=str)))
+        self.cuts_applied += 1
+        print(f"[AUTO-CUT] {cut_type}: {reason} → {action}")
+
+    # ══════════════════════════════════════════
+    #  AUTO-CUT — Automatic regression/stagnation handling
+    # ══════════════════════════════════════════
+
+    def check_auto_cut(self, current_best, engine_state):
+        """
+        Check if an auto-cut should be applied.
+        Returns: list of actions to take, or empty list.
+
+        Actions are dicts: {"type": "...", "params": {...}}
+        The caller (evolution loop) is responsible for executing them.
+        """
+        actions = []
+        brier = current_best.get("brier", 1.0)
+        composite = current_best.get("composite", 0)
+
+        # ── RULE 1: REGRESSION CUT ──
+        # If Brier is getting worse for 3+ consecutive generations
+        if len(self.brier_history) >= 3:
+            last3 = self.brier_history[-3:]
+            if all(last3[i] > last3[i-1] + 0.0003 for i in range(1, len(last3))):
+                self.regression_count += 1
+                if self.regression_count >= 2:
+                    self.log_cut("REGRESSION", f"Brier increasing 3+ gens: {[f'{b:.4f}' for b in last3]}",
+                                 last3[0], last3[-1], "rollback_mutation",
+                                 {"mutation_rate": max(0.03, engine_state.get("mutation_rate", 0.1) * 0.5)})
+                    actions.append({
+                        "type": "config",
+                        "params": {"mutation_rate": max(0.03, engine_state.get("mutation_rate", 0.1) * 0.5)},
+                    })
+                    self.regression_count = 0
+            else:
+                self.regression_count = 0
+
+        # ── RULE 2: STAGNATION CUT ──
+        # At 20+ gens stagnation, diversify moderately (don't destroy good individuals)
+        stagnation = engine_state.get("stagnation", 0)
+        if stagnation >= 20:
+            current_mut = engine_state.get("mutation_rate", 0.04)
+            # Boost mutation by 2x (capped at 0.15) — enough to explore without random noise
+            new_mut = min(0.15, current_mut * 2)
+            self.log_cut("STAGNATION", f"No improvement for {stagnation} gens (mutation {current_mut:.3f} → {new_mut:.3f})",
+                         brier, brier, "moderate_diversify",
+                         {"mutation_rate": new_mut})
+            actions.append({
+                "type": "emergency_diversify",
+                "params": {"mutation_rate": new_mut},
+            })
+
+        # ── RULE 3: ROI CUT ──
+        roi = current_best.get("roi", 0)
+        if roi < -0.15:
+            self.log_cut("ROI_THRESHOLD", f"ROI dropped to {roi:.1%} — betting paused",
+                         brier, brier, "pause_betting")
+            # Don't stop evolution, just flag for betting logic
+            actions.append({"type": "flag", "params": {"pause_betting": True}})
+
+        # ── RULE 4: DIVERSITY CUT ──
+        diversity = engine_state.get("pop_diversity", 0)
+        if diversity < 3.0 and engine_state.get("pop_size", 0) > 20:
+            self.log_cut("DIVERSITY", f"Population diversity {diversity:.1f} too low",
+                         brier, brier, "inject_random",
+                         {"inject_count": max(10, engine_state.get("pop_size", 50) // 4)})
+            actions.append({
+                "type": "inject",
+                "params": {"count": max(10, engine_state.get("pop_size", 50) // 4)},
+            })
+
+        # ── RULE 5: FEATURE CUT ──
+        n_features = current_best.get("n_features", 0)
+        if 0 < n_features < 40:
+            self.log_cut("LOW_FEATURES", f"Only {n_features} features selected",
+                         brier, brier, "expand_target",
+                         {"target_features": 200})
+            actions.append({
+                "type": "config",
+                "params": {"target_features": 200},
+            })
+
+        # ── RULE 6: BRIER FLOOR ──
+        # If Brier is stuck above 0.24 for 50+ gens, try moderate exploration (NOT full reset)
+        # Old rule was destroying progress: mutation 0.25 = random noise, pop 250 > hard cap 80
+        if len(self.brier_history) >= 50:
+            if all(b > 0.24 for b in self.brier_history[-50:]):
+                self.log_cut("BRIER_FLOOR", f"Brier stuck above 0.24 for 50+ gens (best: {min(self.brier_history[-50:]):.4f})",
+                             brier, brier, "moderate_diversify",
+                             {"mutation_rate": 0.12, "target_features": 150})
+                actions.append({
+                    "type": "emergency_diversify",
+                    "params": {"mutation_rate": 0.12, "target_features": 150},
+                })
+                # Clear history so rule doesn't fire every single generation
+                self.brier_history = self.brier_history[-10:]
+
+        # ── RULE 7: LIVE REGRESSION CUT ──
+        # If live Brier (from daily eval) is worse than best checkpoint + 0.01 → rollback
+        live_brier = engine_state.get("live_brier")
+        best_cp_brier = engine_state.get("best_checkpoint_brier")
+        if live_brier is not None and best_cp_brier is not None:
+            if live_brier > best_cp_brier + 0.01:
+                self.log_cut("LIVE_REGRESSION",
+                             f"Live Brier {live_brier:.4f} > checkpoint {best_cp_brier:.4f} + 0.01",
+                             best_cp_brier, live_brier, "rollback_to_checkpoint",
+                             {"target_brier": best_cp_brier})
+                actions.append({
+                    "type": "rollback",
+                    "params": {"reason": "live_regression", "live_brier": live_brier, "checkpoint_brier": best_cp_brier},
+                })
+
+        # Update tracking
+        if brier < self.last_best_brier:
+            self.last_best_brier = brier
+        self.last_best_composite = composite
+
+        return actions
+
+    # ══════════════════════════════════════════
+    #  QUERY — Read logged data
+    # ══════════════════════════════════════════
+
+    def get_recent_runs(self, limit=20):
+        """Get recent cycle logs from Supabase."""
+        rows = _exec_sql(
+            "SELECT * FROM public.nba_evolution_runs ORDER BY ts DESC LIMIT %s", (limit,))
+        return rows or []
+
+    def get_recent_cuts(self, limit=10):
+        rows = _exec_sql(
+            "SELECT * FROM public.nba_evolution_cuts ORDER BY ts DESC LIMIT %s", (limit,))
+        return rows or []
+
+    def get_brier_trend(self, last_n=50):
+        rows = _exec_sql(
+            "SELECT generation, best_brier FROM public.nba_evolution_gens ORDER BY ts DESC LIMIT %s",
+            (last_n,))
+        if rows:
+            return [(r[0], r[1]) for r in reversed(rows)]
+        return self.brier_history[-last_n:]
+
+    def get_stats(self):
+        """Summary stats for dashboard."""
+        total_gens = _exec_sql("SELECT COUNT(*) FROM public.nba_evolution_gens")
+        total_runs = _exec_sql("SELECT COUNT(*) FROM public.nba_evolution_runs")
+        total_cuts = _exec_sql("SELECT COUNT(*) FROM public.nba_evolution_cuts")
+        best_ever = _exec_sql(
+            "SELECT MIN(best_brier) FROM public.nba_evolution_runs")
+
+        return {
+            "total_generations": total_gens[0][0] if total_gens else 0,
+            "total_cycles": total_runs[0][0] if total_runs else 0,
+            "total_cuts": total_cuts[0][0] if total_cuts else 0,
+            "best_brier_ever": best_ever[0][0] if best_ever and best_ever[0][0] else None,
+            "local_cuts_applied": self.cuts_applied,
+            "regression_count": self.regression_count,
+            "brier_history_len": len(self.brier_history),
+        }

evolution/sota_s21.py

@@ -0,0 +1,108 @@
+"""S21 SOTA hooks — Darwinian weights driven by rolling 30-day PnL.
+
+Inspiration: atlas-gic (research_cycle7_sota_gap.md).
+
+Instead of weighting ensemble members by validation log-loss, we track a
+rolling 30-day PnL per base estimator and recompute weights every 10
+generations with exponential decay alpha=0.9.
+
+Usage:
+    tracker = DarwinianWeights(n_models=3, window_days=30, alpha=0.9,
+                               reweight_every=10)
+    tracker.record_pnl(model_idx=0, date="2026-04-15", pnl=12.3)
+    ...
+    if tracker.should_reweight(current_gen):
+        weights = tracker.compute_weights()  # -> np.ndarray shape (n_models,)
+    final_prob = np.dot(weights, [p0, p1, p2])
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Deque, Dict, List
+
+import numpy as np
+
+
+@dataclass
+class DarwinianWeights:
+    n_models: int
+    window_days: int = 30
+    alpha: float = 0.9
+    reweight_every: int = 10
+    _history: Dict[int, Deque] = field(default_factory=dict)
+    _cached_weights: np.ndarray = field(default=None)
+    _last_reweight_gen: int = -1
+
+    def __post_init__(self):
+        self._history = {i: deque() for i in range(self.n_models)}
+        self._cached_weights = np.ones(self.n_models) / self.n_models
+
+    def record_pnl(self, model_idx: int, date: str, pnl: float) -> None:
+        """Record a single-day PnL contribution for a base model."""
+        if model_idx < 0 or model_idx >= self.n_models:
+            return
+        try:
+            d = datetime.fromisoformat(date[:10])
+        except Exception:
+            d = datetime.utcnow()
+        hist = self._history[model_idx]
+        hist.append((d, float(pnl)))
+        # trim to window
+        cutoff = datetime.utcnow().toordinal() - self.window_days
+        while hist and hist[0][0].toordinal() < cutoff:
+            hist.popleft()
+
+    def should_reweight(self, current_gen: int) -> bool:
+        return (current_gen - self._last_reweight_gen) >= self.reweight_every
+
+    def compute_weights(self) -> np.ndarray:
+        """Compute softmax weights across models based on exponentially
+        decayed rolling PnL. Returns a normalized weight vector."""
+        scores = np.zeros(self.n_models)
+        for i in range(self.n_models):
+            hist = list(self._history[i])
+            if not hist:
+                scores[i] = 0.0
+                continue
+            # Sort ascending by date, apply exponential decay from most recent.
+            hist.sort(key=lambda t: t[0])
+            # Walk newest -> oldest with decay
+            weighted = 0.0
+            w = 1.0
+            for d, pnl in reversed(hist):
+                weighted += w * pnl
+                w *= self.alpha
+            scores[i] = weighted
+
+        # Softmax with temperature to keep weights bounded
+        if np.all(scores == 0):
+            w = np.ones(self.n_models) / self.n_models
+        else:
+            temp = max(1e-3, float(np.std(scores)))
+            z = scores / temp
+            z -= z.max()
+            exp_z = np.exp(z)
+            w = exp_z / exp_z.sum()
+        self._cached_weights = w
+        return w
+
+    def get_weights(self, current_gen: int = 0) -> np.ndarray:
+        """Return cached weights; recompute if reweight interval hit."""
+        if self.should_reweight(current_gen):
+            self._last_reweight_gen = current_gen
+            return self.compute_weights()
+        return self._cached_weights
+
+    def snapshot(self) -> dict:
+        return {
+            "n_models": self.n_models,
+            "window_days": self.window_days,
+            "alpha": self.alpha,
+            "reweight_every": self.reweight_every,
+            "last_reweight_gen": self._last_reweight_gen,
+            "weights": self._cached_weights.tolist(),
+            "history_counts": {i: len(self._history[i]) for i in range(self.n_models)},
+        }

experiment_runner.py

@@ -0,0 +1,1073 @@
+#!/usr/bin/env python3
+"""
+S11 Experiment Runner — Isolated Evaluation Server
+=====================================================
+Turns S11 from a clone of S10 into a dedicated experiment server.
+Agents (Eve, CrewAI, etc.) submit experiments to Supabase queue.
+S11 polls the queue, evaluates in isolation (walk-forward backtest),
+and stores results back. S10's population is NEVER touched.
+
+Experiment Types:
+  - feature_test:      Test specific feature mask → evaluate with walk-forward
+  - model_test:        Test specific model_type + hyperparams → evaluate
+  - calibration_test:  Test calibration method on current best features
+  - config_change:     Test GA config by running mini-evolution (5 gens)
+
+Queue: Supabase table `nba_experiments`
+  status: pending → running → completed | failed
+"""
+
+import os
+import sys
+import json
+import time
+import random
+import traceback
+import threading
+import numpy as np
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# ── Import shared functions from app.py (lazy — app.py must be loaded first) ──
+# When this module is imported from app.py's bottom section, app is already
+# fully loaded in sys.modules. Direct `from app import` would re-execute
+# app.py's top-level code (Gradio, data loading) causing a hang.
+# Instead, we grab references AFTER import, in init_from_app().
+
+def _default_log(msg, level="INFO"):
+    print(f"[{level}] {msg}")
+
+Individual = None
+evaluate = None
+_build = None
+_prune_correlated_features = None
+_log_loss_score = None
+_ece = None
+_evaluate_stacking = None
+load_all_games = None
+build_features = None
+pull_seasons = None
+log = _default_log
+live = {}
+FAST_EVAL_GAMES = 7000
+DATA_DIR = Path("/data") if Path("/data").exists() else Path("data")
+HIST_DIR = DATA_DIR / "historical"
+STATE_DIR = DATA_DIR / "evolution-state"
+RESULTS_DIR = DATA_DIR / "results"
+
+def init_from_app():
+    """Grab references from the already-loaded app module. Call once at startup."""
+    import sys as _sys
+    app_mod = _sys.modules.get('app') or _sys.modules.get('__main__')
+    if app_mod is None:
+        raise RuntimeError("app module not loaded")
+
+    global Individual, evaluate, _build, _prune_correlated_features
+    global _log_loss_score, _ece, _evaluate_stacking
+    global load_all_games, build_features, pull_seasons, log, live
+    global FAST_EVAL_GAMES, DATA_DIR, HIST_DIR, STATE_DIR, RESULTS_DIR
+
+    Individual = getattr(app_mod, 'Individual')
+    evaluate = getattr(app_mod, 'evaluate')
+    _build = getattr(app_mod, '_build')
+    _prune_correlated_features = getattr(app_mod, '_prune_correlated_features')
+    _log_loss_score = getattr(app_mod, '_log_loss_score')
+    _ece = getattr(app_mod, '_ece')
+    _evaluate_stacking = getattr(app_mod, '_evaluate_stacking')
+    load_all_games = getattr(app_mod, 'load_all_games')
+    build_features = getattr(app_mod, 'build_features')
+    pull_seasons = getattr(app_mod, 'pull_seasons')
+    log = getattr(app_mod, 'log')
+    live = getattr(app_mod, 'live')
+    FAST_EVAL_GAMES = getattr(app_mod, 'FAST_EVAL_GAMES', 7000)
+    DATA_DIR = getattr(app_mod, 'DATA_DIR', DATA_DIR)
+    HIST_DIR = getattr(app_mod, 'HIST_DIR', HIST_DIR)
+    STATE_DIR = getattr(app_mod, 'STATE_DIR', STATE_DIR)
+    RESULTS_DIR = getattr(app_mod, 'RESULTS_DIR', RESULTS_DIR)
+
+# ── Constants ──
+POLL_INTERVAL = 60          # Poll Supabase every 60 seconds
+MAX_EVAL_GAMES = 7000       # Cap evaluation to prevent OOM (16GB Space)
+MINI_EVO_GENS = 5           # Generations for config_change experiments
+MINI_EVO_POP = 20           # Small population for config_change experiments
+EXPERIMENT_TIMEOUT = 1800   # 30 min max per experiment
+
+# ── Supabase connection (same pattern as run_logger.py) ──
+_pg_pool = None
+
+
+def _get_pg():
+    """Lazy PostgreSQL connection pool for Supabase."""
+    global _pg_pool
+    if _pg_pool is not None:
+        return _pg_pool
+    db_url = os.environ.get("DATABASE_URL", "")
+    if not db_url:
+        log("[EXPERIMENT] DATABASE_URL not set — cannot connect to Supabase", "ERROR")
+        return None
+    try:
+        import psycopg2
+        from psycopg2 import pool as pg_pool
+        _pg_pool = pg_pool.SimpleConnectionPool(1, 3, db_url, options="-c search_path=public")
+        conn = _pg_pool.getconn()
+        with conn.cursor() as cur:
+            cur.execute("SELECT 1")
+        _pg_pool.putconn(conn)
+        log("[EXPERIMENT] PostgreSQL connected to Supabase OK")
+        return _pg_pool
+    except Exception as e:
+        log(f"[EXPERIMENT] PostgreSQL connection failed: {e}", "ERROR")
+        _pg_pool = None
+        return None
+
+
+def _exec_sql(sql, params=None, fetch=True):
+    """Execute SQL on Supabase. Returns rows on SELECT, True on INSERT/UPDATE, None on failure."""
+    pool = _get_pg()
+    if not pool:
+        return None
+    conn = None
+    try:
+        conn = pool.getconn()
+        with conn.cursor() as cur:
+            cur.execute(sql, params)
+            conn.commit()
+            if fetch:
+                try:
+                    return cur.fetchall()
+                except Exception:
+                    return True
+            return True
+    except Exception as e:
+        log(f"[EXPERIMENT] SQL error: {e}", "ERROR")
+        if conn:
+            try:
+                conn.rollback()
+            except Exception:
+                pass
+        return None
+    finally:
+        if conn and pool:
+            try:
+                pool.putconn(conn)
+            except Exception:
+                pass
+
+
+def _reconnect_pg():
+    """Force reconnection on next call (e.g., after connection timeout)."""
+    global _pg_pool
+    if _pg_pool:
+        try:
+            _pg_pool.closeall()
+        except Exception:
+            pass
+    _pg_pool = None
+
+
+# ═══════════════════════════════════════════════════════
+# EXPERIMENT FETCHER
+# ═══════════════════════════════════════════════════════
+
+def fetch_next_experiment() -> Optional[Dict[str, Any]]:
+    """Fetch AND atomically claim the next pending experiment from Supabase.
+
+    Returns dict with all columns, or None if queue empty.
+    Uses CTE with FOR UPDATE SKIP LOCKED to prevent double-pickup.
+    """
+    rows = _exec_sql("""
+        WITH next_exp AS (
+            SELECT id FROM public.nba_experiments
+            WHERE status = 'pending'
+              AND (target_space IS NULL OR target_space = 'S11' OR target_space = 'any')
+            ORDER BY priority DESC, created_at ASC
+            LIMIT 1
+            FOR UPDATE SKIP LOCKED
+        )
+        UPDATE public.nba_experiments e
+        SET status = 'running', started_at = NOW()
+        FROM next_exp
+        WHERE e.id = next_exp.id
+        RETURNING e.id, e.experiment_id, e.agent_name, e.experiment_type,
+                  e.description, e.hypothesis, e.params, e.priority,
+                  e.status, e.target_space, e.baseline_brier, e.created_at
+    """)
+    if not rows or rows is True or len(rows) == 0:
+        return None
+    row = rows[0]
+    return {
+        "id": row[0],
+        "experiment_id": row[1],
+        "agent_name": row[2],
+        "experiment_type": row[3],
+        "description": row[4],
+        "hypothesis": row[5],
+        "params": row[6] if isinstance(row[6], dict) else json.loads(row[6]) if row[6] else {},
+        "priority": row[7],
+        "status": row[8],
+        "target_space": row[9],
+        "baseline_brier": row[10],
+        "created_at": str(row[11]) if row[11] else None,
+    }
+
+
+def claim_experiment(exp_id: int) -> bool:
+    """Legacy claim — now handled atomically in fetch_next_experiment(), kept for compatibility."""
+    return True
+
+
+def _sanitize_for_json(obj):
+    """Convert numpy types to native Python for JSON serialization."""
+    if isinstance(obj, dict):
+        return {k: _sanitize_for_json(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_sanitize_for_json(v) for v in obj]
+    if hasattr(obj, 'item'):  # numpy scalar
+        return obj.item()
+    return obj
+
+
+def complete_experiment(exp_id: int, brier: float, accuracy: float,
+                        log_loss_val: float, details: dict, status: str = "completed"):
+    """Write results back to Supabase."""
+    clean_details = _sanitize_for_json(details)
+    _exec_sql("""
+        UPDATE public.nba_experiments
+        SET status = %s,
+            result_brier = %s,
+            result_accuracy = %s,
+            result_log_loss = %s,
+            result_details = %s,
+            feature_engine_version = %s,
+            completed_at = NOW()
+        WHERE id = %s
+    """, (status, float(brier), float(accuracy), float(log_loss_val),
+          json.dumps(clean_details), "v3.0-35cat-6000feat", int(exp_id)), fetch=False)
+
+
+def fail_experiment(exp_id: int, error_msg: str):
+    """Mark experiment as failed with error details."""
+    details = {"error": error_msg[:2000], "failed_at": datetime.now(timezone.utc).isoformat()}
+    _exec_sql("""
+        UPDATE public.nba_experiments
+        SET status = 'failed',
+            result_details = %s,
+            completed_at = NOW()
+        WHERE id = %s
+    """, (json.dumps(details), exp_id), fetch=False)
+
+
+# ═══════════════════════════════════════════════════════
+# EXPERIMENT EXECUTORS
+# ═══════════════════════════════════════════════════════
+
+def _make_individual(n_features: int, params: dict) -> Individual:
+    """Create an Individual from experiment params.
+
+    params can contain:
+      - features: list of ints (feature mask) or list of feature indices
+      - feature_indices: list of ints (indices to enable)
+      - hyperparams: dict of hyperparams (merged with defaults)
+      - model_type: str (shortcut for hyperparams.model_type)
+      - calibration: str (shortcut for hyperparams.calibration)
+    """
+    ind = Individual(n_features, target=params.get("target_features", 80))
+
+    # Feature mask: explicit list
+    if "features" in params:
+        feat = params["features"]
+        if len(feat) == n_features:
+            ind.features = [int(f) for f in feat]
+        else:
+            # Treat as indices
+            ind.features = [0] * n_features
+            for idx in feat:
+                if 0 <= idx < n_features:
+                    ind.features[idx] = 1
+
+    # Feature indices: explicit list of which features to enable
+    if "feature_indices" in params:
+        ind.features = [0] * n_features
+        for idx in params["feature_indices"]:
+            if 0 <= idx < n_features:
+                ind.features[idx] = 1
+
+    # Hyperparams: merge with defaults
+    if "hyperparams" in params:
+        for k, v in params["hyperparams"].items():
+            if k in ind.hyperparams:
+                ind.hyperparams[k] = v
+
+    # Shortcuts
+    if "model_type" in params:
+        ind.hyperparams["model_type"] = params["model_type"]
+    if "calibration" in params:
+        ind.hyperparams["calibration"] = params["calibration"]
+
+    ind.n_features = sum(ind.features)
+    return ind
+
+
+def run_feature_test(experiment: dict, X: np.ndarray, y: np.ndarray,
+                     feature_names: list) -> dict:
+    """Test specific feature configuration with walk-forward evaluation.
+
+    params should contain:
+      - features or feature_indices: which features to enable
+      - hyperparams (optional): model hyperparams
+      - model_type (optional): which model to use (default: xgboost)
+      - n_splits (optional): number of walk-forward splits (default: 3)
+    """
+    params = experiment["params"]
+    n_features = X.shape[1]
+
+    ind = _make_individual(n_features, params)
+
+    # If no explicit features specified, use current best's feature set if available
+    if "features" not in params and "feature_indices" not in params:
+        # Load best individual from state
+        best = _load_best_individual(n_features)
+        if best:
+            ind.features = list(best.features)
+            ind.n_features = sum(ind.features)
+
+    n_splits = params.get("n_splits", 3)
+    fast = params.get("fast", False)
+
+    log(f"[EXPERIMENT] feature_test: {ind.n_features} features, model={ind.hyperparams['model_type']}, splits={n_splits}")
+
+    # Evaluate with full data (not fast mode by default for experiments)
+    evaluate(ind, X, y, n_splits=n_splits, fast=fast)
+
+    return {
+        "brier": ind.fitness.get("brier", 1.0),
+        "roi": ind.fitness.get("roi", 0.0),
+        "sharpe": ind.fitness.get("sharpe", 0.0),
+        "calibration": ind.fitness.get("calibration", 1.0),
+        "composite": ind.fitness.get("composite", 0.0),
+        "features_pruned": ind.fitness.get("features_pruned", 0),
+        "n_features_selected": ind.n_features,
+        "model_type": ind.hyperparams["model_type"],
+        "hyperparams": ind.hyperparams,
+    }
+
+
+def run_model_test(experiment: dict, X: np.ndarray, y: np.ndarray,
+                   feature_names: list) -> dict:
+    """Test specific model type and hyperparams.
+
+    params should contain:
+      - model_type: str (xgboost, lightgbm, catboost, random_forest, extra_trees, stacking, mlp)
+      - hyperparams (optional): full or partial hyperparams dict
+      - features or feature_indices (optional): use specific features
+    """
+    params = experiment["params"]
+    n_features = X.shape[1]
+
+    # Start from best individual's features (most fair comparison)
+    best = _load_best_individual(n_features)
+    ind = _make_individual(n_features, params)
+
+    if best and "features" not in params and "feature_indices" not in params:
+        ind.features = list(best.features)
+        ind.n_features = sum(ind.features)
+
+    # Must have model_type
+    if "model_type" not in params:
+        raise ValueError("model_test requires 'model_type' in params")
+
+    ind.hyperparams["model_type"] = params["model_type"]
+    n_splits = params.get("n_splits", 3)
+    fast = params.get("fast", False)
+
+    log(f"[EXPERIMENT] model_test: model={ind.hyperparams['model_type']}, "
+        f"{ind.n_features} features, splits={n_splits}")
+
+    evaluate(ind, X, y, n_splits=n_splits, fast=fast)
+
+    return {
+        "brier": ind.fitness.get("brier", 1.0),
+        "roi": ind.fitness.get("roi", 0.0),
+        "sharpe": ind.fitness.get("sharpe", 0.0),
+        "calibration": ind.fitness.get("calibration", 1.0),
+        "composite": ind.fitness.get("composite", 0.0),
+        "features_pruned": ind.fitness.get("features_pruned", 0),
+        "n_features_selected": ind.n_features,
+        "model_type": ind.hyperparams["model_type"],
+        "hyperparams": ind.hyperparams,
+    }
+
+
+def run_calibration_test(experiment: dict, X: np.ndarray, y: np.ndarray,
+                         feature_names: list) -> dict:
+    """Test calibration method on current best features.
+
+    params should contain:
+      - calibration: str (isotonic, sigmoid, none)
+      - model_type (optional): override model type
+    """
+    params = experiment["params"]
+    n_features = X.shape[1]
+
+    best = _load_best_individual(n_features)
+    if not best:
+        raise ValueError("No best individual found — cannot run calibration_test without baseline features")
+
+    # Test each calibration method if "all" requested, otherwise just the one specified
+    calibration = params.get("calibration", "isotonic")
+    methods_to_test = ["isotonic", "sigmoid", "none"] if calibration == "all" else [calibration]
+
+    results = {}
+    best_brier = 1.0
+    best_method = None
+
+    for method in methods_to_test:
+        ind = Individual.__new__(Individual)
+        ind.features = list(best.features)
+        ind.hyperparams = dict(best.hyperparams)
+        ind.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "composite": 0.0}
+        ind.generation = 0
+        ind.n_features = sum(ind.features)
+        ind.hyperparams["calibration"] = method
+
+        if "model_type" in params:
+            ind.hyperparams["model_type"] = params["model_type"]
+
+        n_splits = params.get("n_splits", 3)
+        log(f"[EXPERIMENT] calibration_test: method={method}, model={ind.hyperparams['model_type']}")
+
+        evaluate(ind, X, y, n_splits=n_splits, fast=False)
+
+        results[method] = {
+            "brier": ind.fitness.get("brier", 1.0),
+            "roi": ind.fitness.get("roi", 0.0),
+            "sharpe": ind.fitness.get("sharpe", 0.0),
+            "calibration": ind.fitness.get("calibration", 1.0),
+            "composite": ind.fitness.get("composite", 0.0),
+        }
+
+        if ind.fitness.get("brier", 1.0) < best_brier:
+            best_brier = ind.fitness["brier"]
+            best_method = method
+
+    return {
+        "brier": best_brier,
+        "best_method": best_method,
+        "all_results": results,
+        "n_features_selected": best.n_features,
+        "model_type": best.hyperparams.get("model_type", "unknown"),
+    }
+
+
+def run_config_change(experiment: dict, X: np.ndarray, y: np.ndarray,
+                      feature_names: list) -> dict:
+    """Test GA config change by running a mini-evolution.
+
+    params should contain any of:
+      - pop_size: int (default 20)
+      - mutation_rate: float
+      - crossover_rate: float
+      - tournament_size: int
+      - target_features: int
+      - n_generations: int (default 5)
+      - elite_size: int
+    """
+    params = experiment["params"]
+    n_features = X.shape[1]
+
+    pop_size = min(params.get("pop_size", MINI_EVO_POP), 30)  # Cap at 30
+    n_gens = min(params.get("n_generations", MINI_EVO_GENS), 10)  # Cap at 10
+    mutation_rate = params.get("mutation_rate", 0.04)
+    crossover_rate = params.get("crossover_rate", 0.80)
+    tournament_size = min(params.get("tournament_size", 4), pop_size // 2)
+    target_features = params.get("target_features", 80)
+    elite_size = min(params.get("elite_size", 3), pop_size // 3)
+
+    log(f"[EXPERIMENT] config_change: pop={pop_size}, gens={n_gens}, "
+        f"mut={mutation_rate}, cx={crossover_rate}, target_feat={target_features}")
+
+    # Initialize population
+    population = []
+    model_types = ["xgboost", "lightgbm", "catboost", "random_forest", "extra_trees", "stacking", "mlp"]
+    for i in range(pop_size):
+        ind = Individual(n_features, target=target_features)
+        ind.hyperparams["model_type"] = model_types[i % len(model_types)]
+        population.append(ind)
+
+    # Seed with best individual if available
+    best = _load_best_individual(n_features)
+    if best and len(population) > 0:
+        population[0] = best
+
+    history = []
+    best_ever_brier = 1.0
+    best_ever_composite = 0.0
+
+    for gen in range(n_gens):
+        # Evaluate
+        for ind in population:
+            evaluate(ind, X, y, n_splits=2, fast=True)
+
+        # Sort by composite
+        population.sort(key=lambda x: x.fitness.get("composite", 0), reverse=True)
+        gen_best = population[0]
+
+        gen_brier = gen_best.fitness.get("brier", 1.0)
+        gen_composite = gen_best.fitness.get("composite", 0.0)
+        if gen_brier < best_ever_brier:
+            best_ever_brier = gen_brier
+        if gen_composite > best_ever_composite:
+            best_ever_composite = gen_composite
+
+        history.append({
+            "generation": gen,
+            "best_brier": gen_brier,
+            "best_composite": gen_composite,
+            "avg_brier": round(np.mean([p.fitness.get("brier", 1.0) for p in population]), 5),
+            "avg_composite": round(np.mean([p.fitness.get("composite", 0) for p in population]), 5),
+        })
+
+        log(f"[EXPERIMENT] config_change gen {gen}: best_brier={gen_brier:.4f}, "
+            f"composite={gen_composite:.4f}")
+
+        # Selection + Crossover + Mutation (mini-GA)
+        elites = population[:elite_size]
+        new_pop = list(elites)
+
+        while len(new_pop) < pop_size:
+            # Tournament selection
+            candidates = random.sample(population, min(tournament_size, len(population)))
+            p1 = max(candidates, key=lambda x: x.fitness.get("composite", 0))
+            candidates = random.sample(population, min(tournament_size, len(population)))
+            p2 = max(candidates, key=lambda x: x.fitness.get("composite", 0))
+
+            if random.random() < crossover_rate:
+                child = Individual.crossover(p1, p2)
+            else:
+                child = Individual(n_features, target=target_features)
+
+            child.mutate(rate=mutation_rate)
+            new_pop.append(child)
+
+        population = new_pop[:pop_size]
+
+    # Final evaluation (full, not fast)
+    final_best = max(population, key=lambda x: x.fitness.get("composite", 0))
+    evaluate(final_best, X, y, n_splits=3, fast=False)
+
+    return {
+        "brier": final_best.fitness.get("brier", 1.0),
+        "roi": final_best.fitness.get("roi", 0.0),
+        "sharpe": final_best.fitness.get("sharpe", 0.0),
+        "calibration": final_best.fitness.get("calibration", 1.0),
+        "composite": final_best.fitness.get("composite", 0.0),
+        "best_ever_brier": best_ever_brier,
+        "best_ever_composite": best_ever_composite,
+        "n_generations": n_gens,
+        "pop_size": pop_size,
+        "mutation_rate": mutation_rate,
+        "crossover_rate": crossover_rate,
+        "target_features": target_features,
+        "history": history,
+        "final_model_type": final_best.hyperparams.get("model_type", "unknown"),
+        "final_n_features": final_best.n_features,
+    }
+
+
+# ═══════════════════════════════════════════════════════
+# HELPERS
+# ═══════════════════════════════════════════════════════
+
+def _load_best_individual(n_features: int) -> Optional[Individual]:
+    """Load the best individual from S10's saved state (read-only, never modifies)."""
+    state_file = STATE_DIR / "population.json"
+    if not state_file.exists():
+        return None
+    try:
+        st = json.loads(state_file.read_text())
+        if not st.get("best_ever"):
+            return None
+        be = st["best_ever"]
+        ind = Individual.__new__(Individual)
+        ind.features = be["features"]
+        ind.hyperparams = be["hyperparams"]
+        ind.fitness = be["fitness"]
+        ind.generation = be.get("generation", 0)
+        ind.n_features = sum(ind.features)
+
+        # Resize if feature count changed
+        if len(ind.features) < n_features:
+            ind.features.extend([0] * (n_features - len(ind.features)))
+        elif len(ind.features) > n_features:
+            ind.features = ind.features[:n_features]
+        ind.n_features = sum(ind.features)
+
+        return ind
+    except Exception as e:
+        log(f"[EXPERIMENT] Failed to load best individual: {e}", "WARN")
+        return None
+
+
+def _compute_accuracy(ind: Individual, X: np.ndarray, y: np.ndarray) -> float:
+    """Compute accuracy for an individual (separate from evaluate's fitness)."""
+    try:
+        from sklearn.model_selection import TimeSeriesSplit
+        from sklearn.metrics import accuracy_score
+        from sklearn.base import clone
+        from sklearn.calibration import CalibratedClassifierCV
+
+        selected = ind.selected_indices()
+        if len(selected) < 15:
+            return 0.0
+
+        X_sub = np.nan_to_num(X[:, selected], nan=0.0, posinf=1e6, neginf=-1e6)
+        X_sub, _ = _prune_correlated_features(X_sub, threshold=0.95)
+
+        hp = ind.hyperparams
+        model = _build(hp)
+        if model is None:
+            return 0.0
+
+        tscv = TimeSeriesSplit(n_splits=3)
+        accs = []
+        for ti, vi in tscv.split(X_sub):
+            try:
+                m = clone(model)
+                if hp.get("calibration", "none") != "none":
+                    m = CalibratedClassifierCV(m, method=hp["calibration"], cv=2)
+                m.fit(X_sub[ti], y[ti])
+                preds = m.predict(X_sub[vi])
+                accs.append(accuracy_score(y[vi], preds))
+            except Exception:
+                pass
+        return round(float(np.mean(accs)), 4) if accs else 0.0
+    except Exception:
+        return 0.0
+
+
+# ═══════════════════════════════════════════════════════
+# EXPERIMENT EXECUTION ENGINE
+# ═══════════════════════════════════════════════════════
+
+# Experiment state (for status API)
+_current_experiment = None
+_queue_depth = 0
+_experiments_completed = 0
+_experiments_failed = 0
+_last_result = None
+
+
+EXECUTORS = {
+    "feature_test": run_feature_test,
+    "model_test": run_model_test,
+    "calibration_test": run_calibration_test,
+    "config_change": run_config_change,
+}
+
+
+def run_experiment(experiment: dict, X: np.ndarray, y: np.ndarray,
+                   feature_names: list) -> dict:
+    """Route an experiment to the correct executor and return results."""
+    global _current_experiment, _experiments_completed, _experiments_failed, _last_result
+
+    exp_type = experiment["experiment_type"]
+    exp_id = experiment["id"]
+    _current_experiment = experiment
+
+    log(f"[EXPERIMENT] === Starting: {experiment['experiment_id']} ===")
+    log(f"[EXPERIMENT] Type: {exp_type} | Agent: {experiment['agent_name']} | Priority: {experiment['priority']}")
+    log(f"[EXPERIMENT] Description: {experiment['description'][:200]}")
+
+    executor = EXECUTORS.get(exp_type)
+    if not executor:
+        error_msg = f"Unknown experiment type: {exp_type}. Valid: {list(EXECUTORS.keys())}"
+        fail_experiment(exp_id, error_msg)
+        _experiments_failed += 1
+        _current_experiment = None
+        raise ValueError(error_msg)
+
+    # Claim it
+    if not claim_experiment(exp_id):
+        _current_experiment = None
+        raise RuntimeError(f"Experiment {exp_id} already claimed by another runner")
+
+    start_time = time.time()
+    try:
+        results = executor(experiment, X, y, feature_names)
+        elapsed = time.time() - start_time
+
+        brier = float(results.get("brier", 1.0))
+        accuracy = float(_compute_accuracy(
+            _make_individual(X.shape[1], experiment["params"]), X, y
+        )) if exp_type != "config_change" else float(results.get("accuracy", 0.0))
+
+        # Compute log_loss from brier (approximate — actual log_loss needs probabilities)
+        log_loss_val = float(results.get("log_loss", 0.0))
+
+        results["elapsed_seconds"] = round(elapsed, 1)
+        results["games_evaluated"] = min(X.shape[0], MAX_EVAL_GAMES)
+        results["feature_candidates"] = X.shape[1]
+        results["experiment_id"] = experiment["experiment_id"]
+        results["agent_name"] = experiment["agent_name"]
+
+        # Compare with baseline
+        baseline = experiment.get("baseline_brier")
+        if baseline:
+            results["improvement"] = round(baseline - brier, 5)
+            results["improved"] = brier < baseline
+
+        complete_experiment(exp_id, brier, accuracy, log_loss_val, results)
+        _experiments_completed += 1
+        _last_result = results
+
+        log(f"[EXPERIMENT] === Completed: {experiment['experiment_id']} ===")
+        log(f"[EXPERIMENT] Brier: {brier:.4f} | Elapsed: {elapsed:.1f}s")
+        if baseline:
+            delta = baseline - brier
+            log(f"[EXPERIMENT] vs baseline {baseline:.4f}: {'BETTER' if delta > 0 else 'WORSE'} by {abs(delta):.4f}")
+
+        return results
+
+    except Exception as e:
+        elapsed = time.time() - start_time
+        error_msg = f"{str(e)[:500]}\n{traceback.format_exc()[-1000:]}"
+        fail_experiment(exp_id, error_msg)
+        _experiments_failed += 1
+        log(f"[EXPERIMENT] === FAILED: {experiment['experiment_id']} ({elapsed:.1f}s) ===", "ERROR")
+        log(f"[EXPERIMENT] Error: {str(e)[:300]}", "ERROR")
+        raise
+    finally:
+        _current_experiment = None
+
+
+# ═══════════════════════════════════════════════════════
+# MAIN LOOP (replaces evolution_loop on S11)
+# ═══════════════════════════════════════════════════════
+
+def experiment_loop():
+    """Main experiment polling loop — runs in background thread on S11.
+
+    1. Load game data + build features (same as evolution_loop init)
+    2. Poll Supabase every 60s for pending experiments
+    3. Execute one at a time, write results back
+    4. Never modifies S10's population or state
+    """
+    global _queue_depth
+
+    # Initialize references to app.py functions (must be called after app.py is loaded)
+    init_from_app()
+
+    log("=" * 60)
+    log("S11 EXPERIMENT RUNNER — STARTING")
+    log("=" * 60)
+
+    # ── Phase 1: Load data (same as evolution_loop) ──
+    live["status"] = "EXPERIMENT: LOADING DATA"
+    pull_seasons()
+    games = load_all_games()
+    live["games"] = len(games)
+    log(f"[EXPERIMENT] Games loaded: {len(games)}")
+
+    if len(games) < 500:
+        log("[EXPERIMENT] NOT ENOUGH GAMES — aborting", "ERROR")
+        live["status"] = "EXPERIMENT: ERROR (no data)"
+        return
+
+    # ── Phase 2: Build features ──
+    live["status"] = "EXPERIMENT: BUILDING FEATURES"
+    X, y, feature_names = build_features(games)
+    log(f"[EXPERIMENT] Raw feature matrix: {X.shape}")
+
+    # Remove zero-variance features (same filter as evolution_loop)
+    variances = np.var(X, axis=0)
+    valid_mask = variances > 1e-10
+    n_removed = int((~valid_mask).sum())
+    if n_removed > 0:
+        X = X[:, valid_mask]
+        feature_names = [f for f, v in zip(feature_names, valid_mask) if v]
+        log(f"[EXPERIMENT] Noise filter: removed {n_removed} zero-variance features")
+
+    n_feat = X.shape[1]
+    live["feature_candidates"] = n_feat
+    log(f"[EXPERIMENT] Clean feature matrix: {X.shape} ({n_feat} usable features)")
+
+    # Cap games for OOM protection
+    if X.shape[0] > MAX_EVAL_GAMES:
+        log(f"[EXPERIMENT] Capping to {MAX_EVAL_GAMES} most recent games (OOM protection)")
+        X = X[-MAX_EVAL_GAMES:]
+        y = y[-MAX_EVAL_GAMES:]
+
+    # ── Phase 3: Poll loop ──
+    live["status"] = "EXPERIMENT: READY (polling)"
+    log(f"[EXPERIMENT] Ready — polling every {POLL_INTERVAL}s for experiments")
+    consecutive_errors = 0
+
+    while True:
+        try:
+            experiment = fetch_next_experiment()
+
+            if experiment:
+                _queue_depth = _count_pending()
+                live["status"] = f"EXPERIMENT: RUNNING ({experiment['experiment_type']})"
+                log(f"[EXPERIMENT] Found experiment: {experiment['experiment_id']} "
+                    f"(type={experiment['experiment_type']}, queue={_queue_depth})")
+
+                try:
+                    run_experiment(experiment, X, y, feature_names)
+                except Exception as e:
+                    log(f"[EXPERIMENT] Experiment failed: {e}", "ERROR")
+
+                live["status"] = "EXPERIMENT: READY (polling)"
+                consecutive_errors = 0
+
+                # Refresh data every 10 experiments
+                if (_experiments_completed + _experiments_failed) % 10 == 0:
+                    try:
+                        log("[EXPERIMENT] Refreshing game data...")
+                        new_games = load_all_games()
+                        if len(new_games) > len(games):
+                            games = new_games
+                            X_new, y_new, fn_new = build_features(games)
+                            variances = np.var(X_new, axis=0)
+                            valid_mask = variances > 1e-10
+                            X_new = X_new[:, valid_mask]
+                            fn_new = [f for f, v in zip(fn_new, valid_mask) if v]
+                            if X_new.shape[0] > MAX_EVAL_GAMES:
+                                X_new = X_new[-MAX_EVAL_GAMES:]
+                                y_new = y_new[-MAX_EVAL_GAMES:]
+                            X, y, feature_names = X_new, y_new, fn_new
+                            n_feat = X.shape[1]
+                            log(f"[EXPERIMENT] Data refreshed: {X.shape}")
+                    except Exception as e:
+                        log(f"[EXPERIMENT] Data refresh failed (continuing with old): {e}", "WARN")
+
+            else:
+                # No experiments pending — sleep
+                time.sleep(POLL_INTERVAL)
+
+        except Exception as e:
+            consecutive_errors += 1
+            log(f"[EXPERIMENT] Poll error #{consecutive_errors}: {e}", "ERROR")
+
+            if consecutive_errors >= 5:
+                log("[EXPERIMENT] 5 consecutive errors — reconnecting to Supabase", "WARN")
+                _reconnect_pg()
+                consecutive_errors = 0
+
+            time.sleep(POLL_INTERVAL * 2)  # Back off on errors
+
+
+def _count_pending() -> int:
+    """Count pending experiments in queue."""
+    rows = _exec_sql("""
+        SELECT COUNT(*) FROM public.nba_experiments
+        WHERE status = 'pending'
+          AND (target_space IS NULL OR target_space = 'S11' OR target_space = 'any')
+    """)
+    if rows and rows is not True and len(rows) > 0:
+        return rows[0][0]
+    return 0
+
+
+# ═══════════════════════════════════════════════════════
+# FASTAPI ENDPOINTS (added to control_api)
+# ═══════════════════════════════════════════════════════
+
+def register_experiment_endpoints(api):
+    """Register experiment-related FastAPI endpoints on the control_api."""
+    from fastapi import Request
+    from fastapi.responses import JSONResponse
+
+    @api.get("/api/experiment/status")
+    async def experiment_status():
+        """Current experiment runner status."""
+        return JSONResponse({
+            "mode": "experiment_runner",
+            "status": live.get("status", "unknown"),
+            "current_experiment": {
+                "experiment_id": _current_experiment["experiment_id"],
+                "type": _current_experiment["experiment_type"],
+                "agent": _current_experiment["agent_name"],
+                "description": _current_experiment["description"][:200],
+            } if _current_experiment else None,
+            "queue_depth": _queue_depth,
+            "experiments_completed": _experiments_completed,
+            "experiments_failed": _experiments_failed,
+            "last_result": {
+                "experiment_id": _last_result.get("experiment_id"),
+                "brier": _last_result.get("brier"),
+                "improvement": _last_result.get("improvement"),
+                "elapsed_seconds": _last_result.get("elapsed_seconds"),
+            } if _last_result else None,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        })
+
+    @api.post("/api/experiment/run")
+    async def experiment_run_direct(request: Request):
+        """Submit and immediately run an experiment (bypasses queue).
+
+        Body: {
+            "experiment_type": "feature_test|model_test|calibration_test|config_change",
+            "description": "...",
+            "params": { ... },
+            "agent_name": "direct_api"
+        }
+        """
+        try:
+            body = await request.json()
+
+            exp_type = body.get("experiment_type")
+            if exp_type not in EXECUTORS:
+                return JSONResponse(
+                    {"error": f"Invalid experiment_type. Valid: {list(EXECUTORS.keys())}"},
+                    status_code=400
+                )
+
+            # Write to Supabase first (for tracking), then execute
+            exp_id_str = f"direct-{int(time.time())}"
+            _exec_sql("""
+                INSERT INTO public.nba_experiments
+                (experiment_id, agent_name, experiment_type, description, hypothesis,
+                 params, priority, status, target_space, feature_engine_version)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, 'pending', 'S11', %s)
+                RETURNING id
+            """, (
+                exp_id_str,
+                body.get("agent_name", "direct_api"),
+                exp_type,
+                body.get("description", "Direct API submission"),
+                body.get("hypothesis", ""),
+                json.dumps(body.get("params", {})),
+                body.get("priority", 10),
+                "v3.0-35cat-6000feat",
+            ))
+
+            # Fetch the just-inserted experiment
+            rows = _exec_sql("""
+                SELECT id, experiment_id, agent_name, experiment_type, description,
+                       hypothesis, params, priority, status, target_space,
+                       baseline_brier, created_at
+                FROM public.nba_experiments
+                WHERE experiment_id = %s
+                ORDER BY id DESC LIMIT 1
+            """, (exp_id_str,))
+
+            if not rows or rows is True:
+                return JSONResponse({"error": "Failed to insert experiment"}, status_code=500)
+
+            row = rows[0]
+            experiment = {
+                "id": row[0], "experiment_id": row[1], "agent_name": row[2],
+                "experiment_type": row[3], "description": row[4], "hypothesis": row[5],
+                "params": row[6] if isinstance(row[6], dict) else json.loads(row[6]) if row[6] else {},
+                "priority": row[7], "status": row[8], "target_space": row[9],
+                "baseline_brier": row[10], "created_at": str(row[11]) if row[11] else None,
+            }
+
+            # Note: This blocks the request until evaluation completes (can be long).
+            # For non-blocking, use /api/experiment/submit instead.
+            return JSONResponse({
+                "status": "queued_for_poll",
+                "experiment_id": exp_id_str,
+                "message": "Experiment inserted into queue. S11 will pick it up on next poll cycle.",
+            })
+
+        except Exception as e:
+            return JSONResponse({"error": str(e)[:500]}, status_code=500)
+
+    @api.post("/api/experiment/submit")
+    async def experiment_submit(request: Request):
+        """Submit an experiment to the Supabase queue (non-blocking).
+
+        Body: {
+            "experiment_id": "optional-custom-id",
+            "agent_name": "eve|crew-research|crew-feature|manual",
+            "experiment_type": "feature_test|model_test|calibration_test|config_change",
+            "description": "What this experiment tests",
+            "hypothesis": "Expected outcome",
+            "params": { ... },
+            "priority": 5,
+            "baseline_brier": 0.2205
+        }
+        """
+        try:
+            body = await request.json()
+
+            exp_type = body.get("experiment_type")
+            if exp_type not in EXECUTORS:
+                return JSONResponse(
+                    {"error": f"Invalid experiment_type. Valid: {list(EXECUTORS.keys())}"},
+                    status_code=400
+                )
+
+            if not body.get("description"):
+                return JSONResponse({"error": "description is required"}, status_code=400)
+
+            exp_id_str = body.get("experiment_id", f"submit-{int(time.time())}")
+
+            result = _exec_sql("""
+                INSERT INTO public.nba_experiments
+                (experiment_id, agent_name, experiment_type, description, hypothesis,
+                 params, priority, status, target_space, baseline_brier, feature_engine_version)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, 'pending', %s, %s, %s)
+                RETURNING id
+            """, (
+                exp_id_str,
+                body.get("agent_name", "unknown"),
+                exp_type,
+                body["description"],
+                body.get("hypothesis", ""),
+                json.dumps(body.get("params", {})),
+                body.get("priority", 5),
+                body.get("target_space", "S11"),
+                body.get("baseline_brier"),
+                body.get("feature_engine_version", "v3.0-35cat-6000feat"),
+            ))
+
+            if result is None:
+                return JSONResponse({"error": "Failed to insert — Supabase error"}, status_code=500)
+
+            db_id = result[0][0] if result and result is not True else None
+
+            return JSONResponse({
+                "status": "queued",
+                "id": db_id,
+                "experiment_id": exp_id_str,
+                "message": f"Experiment queued. S11 polls every {POLL_INTERVAL}s.",
+            })
+
+        except Exception as e:
+            return JSONResponse({"error": str(e)[:500]}, status_code=500)
+
+    @api.get("/api/experiment/results")
+    async def experiment_results():
+        """Fetch recent experiment results from Supabase."""
+        rows = _exec_sql("""
+            SELECT experiment_id, agent_name, experiment_type, status,
+                   result_brier, result_accuracy, result_details,
+                   created_at, completed_at
+            FROM public.nba_experiments
+            ORDER BY id DESC
+            LIMIT 20
+        """)
+        if not rows or rows is True:
+            return JSONResponse({"experiments": [], "count": 0})
+
+        experiments = []
+        for row in rows:
+            experiments.append({
+                "experiment_id": row[0],
+                "agent_name": row[1],
+                "experiment_type": row[2],
+                "status": row[3],
+                "result_brier": row[4],
+                "result_accuracy": row[5],
+                "result_details": row[6],
+                "created_at": str(row[7]) if row[7] else None,
+                "completed_at": str(row[8]) if row[8] else None,
+            })
+
+        return JSONResponse({"experiments": experiments, "count": len(experiments)})
+
+    log("[EXPERIMENT] FastAPI endpoints registered: /api/experiment/{status,run,submit,results}")

models/__init__.py

@@ -0,0 +1,35 @@
+"""
+NBA Quant AI — Neural Network Models
+=====================================
+SOTA 2025-2026 neural architectures for NBA game prediction.
+
+All models conform to the same interface:
+  - fit(X_train, y_train, X_val, y_val)
+  - predict_proba(X)
+  - get_params()
+  - save(path) / load(path)
+
+Runs on HF Spaces (16 GB RAM, CPU-only PyTorch).
+"""
+
+from .neural_models import (
+    LSTMSequenceModel,
+    TransformerAttentionModel,
+    TabNetModel,
+    FTTransformerModel,
+    DeepEnsemble,
+    ConformalPredictionWrapper,
+    AutoGluonEnsemble,
+    NEURAL_MODEL_REGISTRY,
+)
+
+__all__ = [
+    "LSTMSequenceModel",
+    "TransformerAttentionModel",
+    "TabNetModel",
+    "FTTransformerModel",
+    "DeepEnsemble",
+    "ConformalPredictionWrapper",
+    "AutoGluonEnsemble",
+    "NEURAL_MODEL_REGISTRY",
+]

models/neural_models.py

@@ -0,0 +1,1598 @@
+#!/usr/bin/env python3
+"""
+NBA Quant AI — Neural Network Models (2025-2026 SOTA)
+======================================================
+Real, production-grade neural architectures for NBA game prediction.
+
+Models implemented:
+  1. LSTMSequenceModel      — Bidirectional LSTM over last N games
+  2. TransformerAttentionModel — Self-attention over game history
+  3. TabNetModel             — Attention-based tabular learning (Arik & Pfister 2021)
+  4. FTTransformerModel      — Feature Tokenizer + Transformer (Gorishniy et al. 2021)
+  5. DeepEnsemble            — N independent nets, averaged predictions
+  6. ConformalPredictionWrapper — Calibrated prediction intervals (any base model)
+  7. AutoGluonEnsemble       — Auto-stacking over hundreds of configs
+
+All models:
+  - Handle NaN gracefully (median imputation)
+  - Work with 6000+ features
+  - Use early stopping
+  - CPU-only PyTorch (no CUDA needed)
+  - Fit in 16 GB RAM (HF Spaces free tier)
+
+THIS RUNS ON HF SPACES ONLY — NOT ON VM.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import math
+import os
+import pickle
+import warnings
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+warnings.filterwarnings("ignore", category=UserWarning)
+
+# ---------------------------------------------------------------------------
+# Lazy imports — heavy libraries loaded only when a model is instantiated
+# ---------------------------------------------------------------------------
+
+def _import_torch():
+    """Import torch lazily to avoid startup cost."""
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from torch.utils.data import DataLoader, TensorDataset
+    return torch, nn, optim, DataLoader, TensorDataset
+
+
+# ---------------------------------------------------------------------------
+# Base class — common interface for all models
+# ---------------------------------------------------------------------------
+
+class BaseNBAModel(ABC):
+    """Abstract base for all NBA prediction models."""
+
+    def __init__(self, **params):
+        self.params = params
+        self._scaler: Optional[StandardScaler] = None
+        self._feature_medians: Optional[np.ndarray] = None
+        self._is_fitted = False
+
+    # --- public interface ---------------------------------------------------
+
+    @abstractmethod
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "BaseNBAModel":
+        """Train the model. Returns self."""
+        ...
+
+    @abstractmethod
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Return P(home_win) for each row — shape (n,)."""
+        ...
+
+    def get_params(self) -> Dict[str, Any]:
+        """Return hyperparameter dict (JSON-serialisable)."""
+        return {k: v for k, v in self.params.items() if _is_jsonable(v)}
+
+    def save(self, path: Union[str, Path]) -> None:
+        """Persist to disk."""
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "wb") as f:
+            pickle.dump(self, f, protocol=pickle.HIGHEST_PROTOCOL)
+
+    @classmethod
+    def load(cls, path: Union[str, Path]) -> "BaseNBAModel":
+        """Load from disk."""
+        with open(path, "rb") as f:
+            obj = pickle.load(f)
+        return obj
+
+    # --- NaN handling & scaling --------------------------------------------
+
+    def _impute(self, X: np.ndarray, fit: bool = False) -> np.ndarray:
+        """Replace NaN/Inf with column medians. If *fit*, compute medians first."""
+        X = np.array(X, dtype=np.float32)
+        X = np.where(np.isfinite(X), X, np.nan)
+        if fit:
+            self._feature_medians = np.nanmedian(X, axis=0)
+            self._feature_medians = np.where(
+                np.isfinite(self._feature_medians), self._feature_medians, 0.0
+            )
+        medians = self._feature_medians if self._feature_medians is not None else np.zeros(X.shape[1])
+        inds = np.where(np.isnan(X))
+        X[inds] = np.take(medians, inds[1])
+        return X
+
+    def _scale(self, X: np.ndarray, fit: bool = False) -> np.ndarray:
+        """Standard-scale features."""
+        if fit:
+            self._scaler = StandardScaler()
+            return self._scaler.fit_transform(X).astype(np.float32)
+        if self._scaler is not None:
+            return self._scaler.transform(X).astype(np.float32)
+        return X.astype(np.float32)
+
+    def _prepare(self, X: np.ndarray, fit: bool = False) -> np.ndarray:
+        """Impute + scale."""
+        X = self._impute(X, fit=fit)
+        X = self._scale(X, fit=fit)
+        return X
+
+    def _auto_val_split(
+        self,
+        X: np.ndarray,
+        y: np.ndarray,
+        X_val: Optional[np.ndarray],
+        y_val: Optional[np.ndarray],
+        val_frac: float = 0.15,
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        """If no validation set provided, carve one from the tail (time-ordered)."""
+        if X_val is not None and y_val is not None:
+            return X, y, X_val, y_val
+        split = int(len(X) * (1 - val_frac))
+        return X[:split], y[:split], X[split:], y[split:]
+
+
+# ===========================================================================
+# 1. LSTM Game Sequence Model
+# ===========================================================================
+
+class LSTMSequenceModel(BaseNBAModel):
+    """
+    Bidirectional LSTM over the last *seq_len* games of features per team.
+
+    Input shape: (batch, seq_len, n_features)
+    Architecture: BiLSTM(128) -> BiLSTM(64) -> Dense(32) -> Sigmoid
+
+    For flat input (n_samples, n_features), the model internally reshapes
+    using a sliding window of *seq_len* rows, treating consecutive games as
+    the sequence dimension.  For true per-team sequences, pass 3-D arrays
+    directly.
+    """
+
+    def __init__(
+        self,
+        seq_len: int = 10,
+        hidden1: int = 128,
+        hidden2: int = 64,
+        dense_dim: int = 32,
+        dropout: float = 0.3,
+        lr: float = 1e-3,
+        weight_decay: float = 1e-5,
+        batch_size: int = 256,
+        epochs: int = 120,
+        patience: int = 15,
+        **kw,
+    ):
+        super().__init__(
+            seq_len=seq_len, hidden1=hidden1, hidden2=hidden2,
+            dense_dim=dense_dim, dropout=dropout, lr=lr,
+            weight_decay=weight_decay, batch_size=batch_size,
+            epochs=epochs, patience=patience, **kw,
+        )
+        self.seq_len = seq_len
+        self.hidden1 = hidden1
+        self.hidden2 = hidden2
+        self.dense_dim = dense_dim
+        self.dropout = dropout
+        self.lr = lr
+        self.weight_decay = weight_decay
+        self.batch_size = batch_size
+        self.epochs = epochs
+        self.patience = patience
+        self._net = None
+
+    # --- PyTorch module (defined inside method to keep torch lazy) ----------
+
+    @staticmethod
+    def _build_net(n_features: int, cfg: dict):
+        torch, nn, _, _, _ = _import_torch()
+
+        class BiLSTMNet(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lstm1 = nn.LSTM(
+                    input_size=n_features,
+                    hidden_size=cfg["hidden1"],
+                    batch_first=True,
+                    bidirectional=True,
+                    dropout=cfg["dropout"] if cfg["hidden2"] else 0,
+                )
+                self.lstm2 = nn.LSTM(
+                    input_size=cfg["hidden1"] * 2,  # bidirectional doubles
+                    hidden_size=cfg["hidden2"],
+                    batch_first=True,
+                    bidirectional=True,
+                )
+                self.dropout = nn.Dropout(cfg["dropout"])
+                self.fc1 = nn.Linear(cfg["hidden2"] * 2, cfg["dense_dim"])
+                self.relu = nn.ReLU()
+                self.fc2 = nn.Linear(cfg["dense_dim"], 1)
+
+            def forward(self, x):
+                # x: (batch, seq_len, features)
+                out, _ = self.lstm1(x)
+                out = self.dropout(out)
+                out, _ = self.lstm2(out)
+                # Take last hidden state
+                out = out[:, -1, :]
+                out = self.dropout(out)
+                out = self.relu(self.fc1(out))
+                out = self.dropout(out)
+                return torch.sigmoid(self.fc2(out)).squeeze(-1)
+
+        return BiLSTMNet()
+
+    # --- Sequence construction from flat arrays ----------------------------
+
+    def _make_sequences(
+        self, X: np.ndarray, y: np.ndarray
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Convert flat (n_games, n_features) into (n_sequences, seq_len, n_features).
+        Uses a sliding window — game i maps to window [i-seq_len+1 .. i].
+        The first seq_len-1 games are dropped (not enough history).
+        """
+        if X.ndim == 3:
+            return X, y  # already sequential
+        seqs, labels = [], []
+        for i in range(self.seq_len - 1, len(X)):
+            seqs.append(X[i - self.seq_len + 1 : i + 1])
+            labels.append(y[i])
+        return np.array(seqs, dtype=np.float32), np.array(labels, dtype=np.float32)
+
+    # --- fit / predict -----------------------------------------------------
+
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "LSTMSequenceModel":
+        torch, nn, optim, DataLoader, TensorDataset = _import_torch()
+
+        # Prepare
+        X_train = self._prepare(X_train, fit=True)
+        X_train, y_train, X_val, y_val = self._auto_val_split(X_train, y_train, X_val, y_val)
+        if X_val is not None:
+            X_val = self._prepare(X_val)
+
+        # Build sequences
+        X_tr_seq, y_tr_seq = self._make_sequences(X_train, y_train)
+        X_va_seq, y_va_seq = self._make_sequences(X_val, y_val)
+
+        n_features = X_tr_seq.shape[2]
+        self._net = self._build_net(n_features, {
+            "hidden1": self.hidden1, "hidden2": self.hidden2,
+            "dense_dim": self.dense_dim, "dropout": self.dropout,
+        })
+
+        optimizer = optim.AdamW(
+            self._net.parameters(), lr=self.lr, weight_decay=self.weight_decay
+        )
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+            optimizer, mode="min", factor=0.5, patience=5, min_lr=1e-6
+        )
+        criterion = nn.BCELoss()
+
+        train_ds = TensorDataset(
+            torch.from_numpy(X_tr_seq), torch.from_numpy(y_tr_seq)
+        )
+        train_dl = DataLoader(train_ds, batch_size=self.batch_size, shuffle=True)
+
+        val_X_t = torch.from_numpy(X_va_seq)
+        val_y_t = torch.from_numpy(y_va_seq)
+
+        best_val_loss = float("inf")
+        best_state = None
+        wait = 0
+
+        self._net.train()
+        for epoch in range(self.epochs):
+            epoch_loss = 0.0
+            for xb, yb in train_dl:
+                optimizer.zero_grad()
+                preds = self._net(xb)
+                loss = criterion(preds, yb)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(self._net.parameters(), 1.0)
+                optimizer.step()
+                epoch_loss += loss.item() * len(xb)
+            epoch_loss /= len(train_ds)
+
+            # Validation
+            self._net.eval()
+            with torch.no_grad():
+                val_preds = self._net(val_X_t)
+                val_loss = criterion(val_preds, val_y_t).item()
+            self._net.train()
+
+            scheduler.step(val_loss)
+
+            if val_loss < best_val_loss - 1e-6:
+                best_val_loss = val_loss
+                best_state = copy.deepcopy(self._net.state_dict())
+                wait = 0
+            else:
+                wait += 1
+                if wait >= self.patience:
+                    break
+
+        if best_state is not None:
+            self._net.load_state_dict(best_state)
+        self._net.eval()
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        torch, _, _, _, _ = _import_torch()
+        assert self._is_fitted, "Model not fitted yet"
+
+        X = self._prepare(X)
+        # If flat, create sequences with padding for early games
+        if X.ndim == 2:
+            seqs = []
+            for i in range(len(X)):
+                start = max(0, i - self.seq_len + 1)
+                seq = X[start : i + 1]
+                if len(seq) < self.seq_len:
+                    pad = np.zeros((self.seq_len - len(seq), X.shape[1]), dtype=np.float32)
+                    seq = np.concatenate([pad, seq], axis=0)
+                seqs.append(seq)
+            X_seq = np.array(seqs, dtype=np.float32)
+        else:
+            X_seq = X.astype(np.float32)
+
+        self._net.eval()
+        with torch.no_grad():
+            preds = self._net(torch.from_numpy(X_seq))
+        return preds.numpy()
+
+
+# ===========================================================================
+# 2. Transformer Attention Model
+# ===========================================================================
+
+class TransformerAttentionModel(BaseNBAModel):
+    """
+    Self-attention over team performance history.
+
+    Architecture:
+        Linear projection -> Positional encoding ->
+        TransformerEncoder (2 layers, 4 heads) ->
+        Global average pool -> Dense -> Sigmoid
+
+    For flat input the model treats each game as one token in a
+    sequence of *seq_len* tokens (same sliding-window as LSTM model).
+    """
+
+    def __init__(
+        self,
+        seq_len: int = 10,
+        d_model: int = 128,
+        n_heads: int = 4,
+        n_layers: int = 2,
+        dim_ff: int = 256,
+        dropout: float = 0.2,
+        lr: float = 5e-4,
+        weight_decay: float = 1e-4,
+        batch_size: int = 256,
+        epochs: int = 120,
+        patience: int = 15,
+        **kw,
+    ):
+        super().__init__(
+            seq_len=seq_len, d_model=d_model, n_heads=n_heads,
+            n_layers=n_layers, dim_ff=dim_ff, dropout=dropout,
+            lr=lr, weight_decay=weight_decay, batch_size=batch_size,
+            epochs=epochs, patience=patience, **kw,
+        )
+        self.seq_len = seq_len
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.dim_ff = dim_ff
+        self.dropout = dropout
+        self.lr = lr
+        self.weight_decay = weight_decay
+        self.batch_size = batch_size
+        self.epochs = epochs
+        self.patience = patience
+        self._net = None
+
+    @staticmethod
+    def _build_net(n_features: int, cfg: dict):
+        torch, nn, _, _, _ = _import_torch()
+
+        class PositionalEncoding(nn.Module):
+            """Sinusoidal positional encoding for game order."""
+            def __init__(self, d_model: int, max_len: int = 200):
+                super().__init__()
+                pe = torch.zeros(max_len, d_model)
+                position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+                div_term = torch.exp(
+                    torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
+                )
+                pe[:, 0::2] = torch.sin(position * div_term)
+                pe[:, 1::2] = torch.cos(position * div_term[: d_model // 2])  # handle odd d_model
+                pe = pe.unsqueeze(0)  # (1, max_len, d_model)
+                self.register_buffer("pe", pe)
+
+            def forward(self, x):
+                return x + self.pe[:, : x.size(1), :]
+
+        class TransformerNet(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.input_proj = nn.Linear(n_features, cfg["d_model"])
+                self.pos_enc = PositionalEncoding(cfg["d_model"], max_len=cfg["seq_len"] + 10)
+                self.layer_norm_in = nn.LayerNorm(cfg["d_model"])
+                encoder_layer = nn.TransformerEncoderLayer(
+                    d_model=cfg["d_model"],
+                    nhead=cfg["n_heads"],
+                    dim_feedforward=cfg["dim_ff"],
+                    dropout=cfg["dropout"],
+                    batch_first=True,
+                    activation="gelu",
+                )
+                self.encoder = nn.TransformerEncoder(
+                    encoder_layer, num_layers=cfg["n_layers"]
+                )
+                self.dropout = nn.Dropout(cfg["dropout"])
+                self.fc1 = nn.Linear(cfg["d_model"], cfg["d_model"] // 2)
+                self.gelu = nn.GELU()
+                self.fc2 = nn.Linear(cfg["d_model"] // 2, 1)
+
+            def forward(self, x):
+                # x: (batch, seq_len, n_features)
+                x = self.input_proj(x)
+                x = self.pos_enc(x)
+                x = self.layer_norm_in(x)
+                x = self.encoder(x)
+                # Global average pooling across sequence dim
+                x = x.mean(dim=1)
+                x = self.dropout(x)
+                x = self.gelu(self.fc1(x))
+                x = self.dropout(x)
+                return torch.sigmoid(self.fc2(x)).squeeze(-1)
+
+        return TransformerNet()
+
+    def _make_sequences(self, X: np.ndarray, y: np.ndarray):
+        if X.ndim == 3:
+            return X, y
+        seqs, labels = [], []
+        for i in range(self.seq_len - 1, len(X)):
+            seqs.append(X[i - self.seq_len + 1 : i + 1])
+            labels.append(y[i])
+        return np.array(seqs, dtype=np.float32), np.array(labels, dtype=np.float32)
+
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "TransformerAttentionModel":
+        torch, nn, optim, DataLoader, TensorDataset = _import_torch()
+
+        X_train = self._prepare(X_train, fit=True)
+        X_train, y_train, X_val, y_val = self._auto_val_split(X_train, y_train, X_val, y_val)
+        if X_val is not None:
+            X_val = self._prepare(X_val)
+
+        X_tr_seq, y_tr_seq = self._make_sequences(X_train, y_train)
+        X_va_seq, y_va_seq = self._make_sequences(X_val, y_val)
+
+        n_features = X_tr_seq.shape[2]
+        self._net = self._build_net(n_features, {
+            "d_model": self.d_model, "n_heads": self.n_heads,
+            "n_layers": self.n_layers, "dim_ff": self.dim_ff,
+            "dropout": self.dropout, "seq_len": self.seq_len,
+        })
+
+        optimizer = optim.AdamW(
+            self._net.parameters(), lr=self.lr, weight_decay=self.weight_decay
+        )
+        scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(
+            optimizer, T_0=10, T_mult=2, eta_min=1e-6
+        )
+        criterion = nn.BCELoss()
+
+        train_ds = TensorDataset(
+            torch.from_numpy(X_tr_seq), torch.from_numpy(y_tr_seq)
+        )
+        train_dl = DataLoader(train_ds, batch_size=self.batch_size, shuffle=True)
+
+        val_X_t = torch.from_numpy(X_va_seq)
+        val_y_t = torch.from_numpy(y_va_seq)
+
+        best_val_loss = float("inf")
+        best_state = None
+        wait = 0
+
+        self._net.train()
+        for epoch in range(self.epochs):
+            epoch_loss = 0.0
+            for xb, yb in train_dl:
+                optimizer.zero_grad()
+                preds = self._net(xb)
+                loss = criterion(preds, yb)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(self._net.parameters(), 1.0)
+                optimizer.step()
+                epoch_loss += loss.item() * len(xb)
+            epoch_loss /= len(train_ds)
+            scheduler.step(epoch + epoch_loss)  # warm restart input
+
+            self._net.eval()
+            with torch.no_grad():
+                val_preds = self._net(val_X_t)
+                val_loss = criterion(val_preds, val_y_t).item()
+            self._net.train()
+
+            if val_loss < best_val_loss - 1e-6:
+                best_val_loss = val_loss
+                best_state = copy.deepcopy(self._net.state_dict())
+                wait = 0
+            else:
+                wait += 1
+                if wait >= self.patience:
+                    break
+
+        if best_state is not None:
+            self._net.load_state_dict(best_state)
+        self._net.eval()
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        torch, _, _, _, _ = _import_torch()
+        assert self._is_fitted, "Model not fitted yet"
+
+        X = self._prepare(X)
+        if X.ndim == 2:
+            seqs = []
+            for i in range(len(X)):
+                start = max(0, i - self.seq_len + 1)
+                seq = X[start : i + 1]
+                if len(seq) < self.seq_len:
+                    pad = np.zeros((self.seq_len - len(seq), X.shape[1]), dtype=np.float32)
+                    seq = np.concatenate([pad, seq], axis=0)
+                seqs.append(seq)
+            X_seq = np.array(seqs, dtype=np.float32)
+        else:
+            X_seq = X.astype(np.float32)
+
+        self._net.eval()
+        with torch.no_grad():
+            preds = self._net(torch.from_numpy(X_seq))
+        return preds.numpy()
+
+
+# ===========================================================================
+# 3. TabNet — Attention-based Tabular Model
+# ===========================================================================
+
+class TabNetModel(BaseNBAModel):
+    """
+    TabNet (Arik & Pfister 2021) — SOTA attention-based tabular learning.
+
+    Uses sequential attention to select features at each decision step,
+    providing built-in interpretability via attention masks.
+
+    Wraps pytorch_tabnet.TabNetClassifier with NaN handling and
+    early stopping.
+    """
+
+    def __init__(
+        self,
+        n_d: int = 32,
+        n_a: int = 32,
+        n_steps: int = 5,
+        gamma: float = 1.5,
+        lambda_sparse: float = 1e-4,
+        n_independent: int = 2,
+        n_shared: int = 2,
+        lr: float = 2e-2,
+        batch_size: int = 1024,
+        virtual_batch_size: int = 256,
+        epochs: int = 200,
+        patience: int = 20,
+        mask_type: str = "entmax",
+        **kw,
+    ):
+        super().__init__(
+            n_d=n_d, n_a=n_a, n_steps=n_steps, gamma=gamma,
+            lambda_sparse=lambda_sparse, n_independent=n_independent,
+            n_shared=n_shared, lr=lr, batch_size=batch_size,
+            virtual_batch_size=virtual_batch_size, epochs=epochs,
+            patience=patience, mask_type=mask_type, **kw,
+        )
+        self.n_d = n_d
+        self.n_a = n_a
+        self.n_steps = n_steps
+        self.gamma = gamma
+        self.lambda_sparse = lambda_sparse
+        self.n_independent = n_independent
+        self.n_shared = n_shared
+        self.lr = lr
+        self.batch_size = batch_size
+        self.virtual_batch_size = virtual_batch_size
+        self.epochs = epochs
+        self.patience = patience
+        self.mask_type = mask_type
+        self._clf = None
+        self._feature_importances: Optional[np.ndarray] = None
+
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "TabNetModel":
+        from pytorch_tabnet.tab_model import TabNetClassifier
+
+        X_train = self._impute(X_train, fit=True)
+        X_train, y_train, X_val, y_val = self._auto_val_split(X_train, y_train, X_val, y_val)
+        if X_val is not None:
+            X_val = self._impute(X_val)
+
+        y_train = y_train.astype(np.int64)
+        y_val = y_val.astype(np.int64)
+
+        self._clf = TabNetClassifier(
+            n_d=self.n_d,
+            n_a=self.n_a,
+            n_steps=self.n_steps,
+            gamma=self.gamma,
+            lambda_sparse=self.lambda_sparse,
+            n_independent=self.n_independent,
+            n_shared=self.n_shared,
+            optimizer_fn=None,  # default Adam
+            optimizer_params={"lr": self.lr},
+            mask_type=self.mask_type,
+            scheduler_fn=None,
+            scheduler_params=None,
+            verbose=0,
+            device_name="cpu",
+        )
+
+        self._clf.fit(
+            X_train=X_train,
+            y_train=y_train,
+            eval_set=[(X_val, y_val)],
+            eval_name=["val"],
+            eval_metric=["logloss"],
+            max_epochs=self.epochs,
+            patience=self.patience,
+            batch_size=self.batch_size,
+            virtual_batch_size=min(self.virtual_batch_size, self.batch_size),
+            drop_last=False,
+        )
+
+        self._feature_importances = self._clf.feature_importances_
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        assert self._is_fitted, "Model not fitted yet"
+        X = self._impute(X)
+        proba = self._clf.predict_proba(X)  # shape (n, 2)
+        return proba[:, 1]
+
+    def get_feature_importances(self) -> Optional[np.ndarray]:
+        """Return TabNet attention-based feature importances."""
+        return self._feature_importances
+
+    def explain(self, X: np.ndarray) -> np.ndarray:
+        """Return per-sample feature attention masks."""
+        assert self._is_fitted, "Model not fitted yet"
+        X = self._impute(X)
+        masks, _ = self._clf.explain(X)
+        return masks
+
+
+# ===========================================================================
+# 4. FT-Transformer (Feature Tokenizer + Transformer)
+# ===========================================================================
+
+class FTTransformerModel(BaseNBAModel):
+    """
+    FT-Transformer (Gorishniy et al. 2021) — confirmed SOTA for tabular
+    data in 2025-2026 benchmarks.
+
+    Each numerical feature is projected into a *d_token*-dimensional embedding.
+    A [CLS] token is prepended. Self-attention across all feature tokens
+    captures cross-feature interactions.  The [CLS] representation feeds a
+    classification head.
+
+    Because the full 6000+ features would create 6000+ tokens (too large for
+    self-attention on CPU), we first apply a learned linear bottleneck to
+    reduce to *n_tokens* feature groups.
+    """
+
+    def __init__(
+        self,
+        n_tokens: int = 128,
+        d_token: int = 64,
+        n_heads: int = 4,
+        n_layers: int = 3,
+        dim_ff: int = 256,
+        dropout: float = 0.2,
+        attention_dropout: float = 0.1,
+        lr: float = 1e-4,
+        weight_decay: float = 1e-5,
+        batch_size: int = 512,
+        epochs: int = 120,
+        patience: int = 15,
+        **kw,
+    ):
+        super().__init__(
+            n_tokens=n_tokens, d_token=d_token, n_heads=n_heads,
+            n_layers=n_layers, dim_ff=dim_ff, dropout=dropout,
+            attention_dropout=attention_dropout, lr=lr,
+            weight_decay=weight_decay, batch_size=batch_size,
+            epochs=epochs, patience=patience, **kw,
+        )
+        self.n_tokens = n_tokens
+        self.d_token = d_token
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.dim_ff = dim_ff
+        self.dropout = dropout
+        self.attention_dropout = attention_dropout
+        self.lr = lr
+        self.weight_decay = weight_decay
+        self.batch_size = batch_size
+        self.epochs = epochs
+        self.patience = patience
+        self._net = None
+
+    @staticmethod
+    def _build_net(n_features: int, cfg: dict):
+        torch, nn, _, _, _ = _import_torch()
+
+        class FTTransformerNet(nn.Module):
+            """
+            Feature Tokenizer + Transformer.
+
+            1) Bottleneck: Linear(n_features -> n_tokens)  — group features
+            2) Token embed: each of *n_tokens* scalars -> d_token vector
+            3) Prepend [CLS] token
+            4) TransformerEncoder
+            5) [CLS] output -> classification head
+            """
+
+            def __init__(self):
+                super().__init__()
+                n_tok = cfg["n_tokens"]
+                d_tok = cfg["d_token"]
+
+                # Bottleneck projection: reduce 6000 features to n_tokens groups
+                self.bottleneck = nn.Linear(n_features, n_tok)
+                self.bn_norm = nn.LayerNorm(n_tok)
+
+                # Per-token embedding: each scalar -> d_token vector
+                # Implemented as a shared Linear(1 -> d_token) + per-token bias
+                self.token_weight = nn.Parameter(torch.randn(n_tok, d_tok) * 0.02)
+                self.token_bias = nn.Parameter(torch.zeros(n_tok, d_tok))
+
+                # [CLS] token
+                self.cls_token = nn.Parameter(torch.randn(1, 1, d_tok) * 0.02)
+
+                # Transformer
+                self.layer_norm = nn.LayerNorm(d_tok)
+                encoder_layer = nn.TransformerEncoderLayer(
+                    d_model=d_tok,
+                    nhead=cfg["n_heads"],
+                    dim_feedforward=cfg["dim_ff"],
+                    dropout=cfg["dropout"],
+                    batch_first=True,
+                    activation="gelu",
+                )
+                self.encoder = nn.TransformerEncoder(
+                    encoder_layer, num_layers=cfg["n_layers"]
+                )
+
+                # Head
+                self.head = nn.Sequential(
+                    nn.LayerNorm(d_tok),
+                    nn.Linear(d_tok, d_tok // 2),
+                    nn.GELU(),
+                    nn.Dropout(cfg["dropout"]),
+                    nn.Linear(d_tok // 2, 1),
+                )
+
+            def forward(self, x):
+                # x: (batch, n_features)
+                batch_size = x.size(0)
+
+                # Bottleneck: (batch, n_features) -> (batch, n_tokens)
+                x = self.bn_norm(self.bottleneck(x))
+
+                # Token embedding: (batch, n_tokens) -> (batch, n_tokens, d_token)
+                # x_i * weight_i + bias_i for each token
+                x = x.unsqueeze(-1) * self.token_weight.unsqueeze(0) + self.token_bias.unsqueeze(0)
+
+                # Prepend [CLS]
+                cls = self.cls_token.expand(batch_size, -1, -1)
+                x = torch.cat([cls, x], dim=1)  # (batch, 1 + n_tokens, d_token)
+
+                x = self.layer_norm(x)
+                x = self.encoder(x)
+
+                # Extract [CLS] output
+                cls_out = x[:, 0, :]
+                return torch.sigmoid(self.head(cls_out)).squeeze(-1)
+
+        return FTTransformerNet()
+
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "FTTransformerModel":
+        torch, nn, optim, DataLoader, TensorDataset = _import_torch()
+
+        X_train = self._prepare(X_train, fit=True)
+        X_train, y_train, X_val, y_val = self._auto_val_split(X_train, y_train, X_val, y_val)
+        if X_val is not None:
+            X_val = self._prepare(X_val)
+
+        y_train = y_train.astype(np.float32)
+        y_val = y_val.astype(np.float32)
+
+        n_features = X_train.shape[1]
+        self._net = self._build_net(n_features, {
+            "n_tokens": min(self.n_tokens, n_features),
+            "d_token": self.d_token,
+            "n_heads": self.n_heads,
+            "n_layers": self.n_layers,
+            "dim_ff": self.dim_ff,
+            "dropout": self.dropout,
+        })
+
+        optimizer = optim.AdamW(
+            self._net.parameters(), lr=self.lr, weight_decay=self.weight_decay
+        )
+        scheduler = optim.lr_scheduler.OneCycleLR(
+            optimizer, max_lr=self.lr * 10, total_steps=self.epochs,
+            pct_start=0.1, anneal_strategy="cos",
+        )
+        criterion = nn.BCELoss()
+
+        train_ds = TensorDataset(
+            torch.from_numpy(X_train), torch.from_numpy(y_train)
+        )
+        train_dl = DataLoader(train_ds, batch_size=self.batch_size, shuffle=True)
+
+        val_X_t = torch.from_numpy(X_val)
+        val_y_t = torch.from_numpy(y_val)
+
+        best_val_loss = float("inf")
+        best_state = None
+        wait = 0
+
+        self._net.train()
+        for epoch in range(self.epochs):
+            epoch_loss = 0.0
+            for xb, yb in train_dl:
+                optimizer.zero_grad()
+                preds = self._net(xb)
+                loss = criterion(preds, yb)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(self._net.parameters(), 1.0)
+                optimizer.step()
+                epoch_loss += loss.item() * len(xb)
+            epoch_loss /= len(train_ds)
+            scheduler.step()
+
+            self._net.eval()
+            with torch.no_grad():
+                val_preds = self._net(val_X_t)
+                val_loss = criterion(val_preds, val_y_t).item()
+            self._net.train()
+
+            if val_loss < best_val_loss - 1e-6:
+                best_val_loss = val_loss
+                best_state = copy.deepcopy(self._net.state_dict())
+                wait = 0
+            else:
+                wait += 1
+                if wait >= self.patience:
+                    break
+
+        if best_state is not None:
+            self._net.load_state_dict(best_state)
+        self._net.eval()
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        torch, _, _, _, _ = _import_torch()
+        assert self._is_fitted, "Model not fitted yet"
+
+        X = self._prepare(X)
+        X_t = torch.from_numpy(X)
+
+        self._net.eval()
+        # Batch to avoid OOM on large inputs
+        preds_list = []
+        bs = self.batch_size
+        for i in range(0, len(X_t), bs):
+            with torch.no_grad():
+                p = self._net(X_t[i : i + bs])
+            preds_list.append(p.numpy())
+        return np.concatenate(preds_list)
+
+
+# ===========================================================================
+# 5. Deep Ensemble
+# ===========================================================================
+
+class DeepEnsemble(BaseNBAModel):
+    """
+    Train N independent neural networks with different random seeds.
+
+    Average their predictions for:
+      - Better calibration (ensemble smoothing)
+      - Uncertainty estimation (prediction variance)
+
+    Each member is a simple but effective MLP with skip connections (ResNet-style),
+    which is the 2025 consensus best architecture for tabular deep learning
+    when ensembled (Kadra et al. 2021 "Well-Tuned Simple Nets").
+    """
+
+    def __init__(
+        self,
+        n_members: int = 10,
+        hidden_dims: Tuple[int, ...] = (512, 256, 128),
+        dropout: float = 0.3,
+        lr: float = 1e-3,
+        weight_decay: float = 1e-4,
+        batch_size: int = 512,
+        epochs: int = 100,
+        patience: int = 12,
+        **kw,
+    ):
+        super().__init__(
+            n_members=n_members, hidden_dims=list(hidden_dims),
+            dropout=dropout, lr=lr, weight_decay=weight_decay,
+            batch_size=batch_size, epochs=epochs, patience=patience, **kw,
+        )
+        self.n_members = n_members
+        self.hidden_dims = hidden_dims
+        self.dropout = dropout
+        self.lr = lr
+        self.weight_decay = weight_decay
+        self.batch_size = batch_size
+        self.epochs = epochs
+        self.patience = patience
+        self._members: List = []
+
+    @staticmethod
+    def _build_mlp(n_features: int, hidden_dims: Tuple[int, ...], dropout: float, seed: int):
+        """Build one ResNet-style MLP member."""
+        torch, nn, _, _, _ = _import_torch()
+        torch.manual_seed(seed)
+
+        class ResBlock(nn.Module):
+            """Pre-activation residual block."""
+            def __init__(self, dim: int, drop: float):
+                super().__init__()
+                self.net = nn.Sequential(
+                    nn.LayerNorm(dim),
+                    nn.GELU(),
+                    nn.Linear(dim, dim),
+                    nn.Dropout(drop),
+                    nn.LayerNorm(dim),
+                    nn.GELU(),
+                    nn.Linear(dim, dim),
+                    nn.Dropout(drop),
+                )
+
+            def forward(self, x):
+                return x + self.net(x)
+
+        layers = []
+        in_dim = n_features
+        for h_dim in hidden_dims:
+            layers.append(nn.Linear(in_dim, h_dim))
+            layers.append(nn.GELU())
+            layers.append(nn.Dropout(dropout))
+            # Add residual block at each hidden layer
+            layers.append(ResBlock(h_dim, dropout))
+            in_dim = h_dim
+        layers.append(nn.Linear(in_dim, 1))
+
+        class EnsembleMLP(nn.Module):
+            def __init__(self, layer_list):
+                super().__init__()
+                self.net = nn.Sequential(*layer_list)
+
+            def forward(self, x):
+                return torch.sigmoid(self.net(x)).squeeze(-1)
+
+        return EnsembleMLP(layers)
+
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "DeepEnsemble":
+        torch, nn, optim, DataLoader, TensorDataset = _import_torch()
+
+        X_train = self._prepare(X_train, fit=True)
+        X_train, y_train, X_val, y_val = self._auto_val_split(X_train, y_train, X_val, y_val)
+        if X_val is not None:
+            X_val = self._prepare(X_val)
+
+        y_train = y_train.astype(np.float32)
+        y_val = y_val.astype(np.float32)
+        n_features = X_train.shape[1]
+
+        val_X_t = torch.from_numpy(X_val)
+        val_y_t = torch.from_numpy(y_val)
+        criterion = nn.BCELoss()
+
+        self._members = []
+        for member_idx in range(self.n_members):
+            seed = 42 + member_idx * 1337
+            net = self._build_mlp(n_features, self.hidden_dims, self.dropout, seed)
+
+            # Each member gets a different random seed for data shuffling too
+            torch.manual_seed(seed)
+            np.random.seed(seed)
+
+            optimizer = optim.AdamW(
+                net.parameters(), lr=self.lr, weight_decay=self.weight_decay
+            )
+            scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+                optimizer, mode="min", factor=0.5, patience=5, min_lr=1e-6
+            )
+
+            train_ds = TensorDataset(
+                torch.from_numpy(X_train), torch.from_numpy(y_train)
+            )
+            train_dl = DataLoader(train_ds, batch_size=self.batch_size, shuffle=True)
+
+            best_val_loss = float("inf")
+            best_state = None
+            wait = 0
+
+            net.train()
+            for epoch in range(self.epochs):
+                for xb, yb in train_dl:
+                    optimizer.zero_grad()
+                    preds = net(xb)
+                    loss = criterion(preds, yb)
+                    loss.backward()
+                    torch.nn.utils.clip_grad_norm_(net.parameters(), 1.0)
+                    optimizer.step()
+
+                net.eval()
+                with torch.no_grad():
+                    vp = net(val_X_t)
+                    vl = criterion(vp, val_y_t).item()
+                net.train()
+                scheduler.step(vl)
+
+                if vl < best_val_loss - 1e-6:
+                    best_val_loss = vl
+                    best_state = copy.deepcopy(net.state_dict())
+                    wait = 0
+                else:
+                    wait += 1
+                    if wait >= self.patience:
+                        break
+
+            if best_state is not None:
+                net.load_state_dict(best_state)
+            net.eval()
+            self._members.append(net)
+
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Return mean prediction across ensemble members."""
+        torch, _, _, _, _ = _import_torch()
+        assert self._is_fitted and self._members, "Model not fitted yet"
+
+        X = self._prepare(X)
+        X_t = torch.from_numpy(X)
+
+        all_preds = []
+        for net in self._members:
+            net.eval()
+            with torch.no_grad():
+                p = net(X_t).numpy()
+            all_preds.append(p)
+
+        return np.mean(all_preds, axis=0)
+
+    def predict_uncertainty(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Return (mean_prediction, std_prediction) across ensemble members.
+        High std = high model uncertainty = less confident prediction.
+        """
+        torch, _, _, _, _ = _import_torch()
+        assert self._is_fitted and self._members, "Model not fitted yet"
+
+        X = self._prepare(X)
+        X_t = torch.from_numpy(X)
+
+        all_preds = []
+        for net in self._members:
+            net.eval()
+            with torch.no_grad():
+                p = net(X_t).numpy()
+            all_preds.append(p)
+
+        stacked = np.array(all_preds)  # (n_members, n_samples)
+        return stacked.mean(axis=0), stacked.std(axis=0)
+
+
+# ===========================================================================
+# 6. Conformal Prediction Wrapper
+# ===========================================================================
+
+class ConformalPredictionWrapper(BaseNBAModel):
+    """
+    Wraps ANY model to provide calibrated prediction intervals with
+    guaranteed coverage.
+
+    Uses split conformal prediction:
+      1. Train base model on training set
+      2. Compute non-conformity scores on calibration holdout
+      3. At inference, use quantile of scores to produce prediction sets
+
+    For binary classification:
+      - Returns P(home_win) from base model (point prediction)
+      - Also provides prediction_set() that returns {0}, {1}, or {0,1}
+        with guaranteed marginal coverage >= (1 - alpha)
+    """
+
+    def __init__(
+        self,
+        base_model: BaseNBAModel,
+        alpha: float = 0.10,
+        cal_fraction: float = 0.20,
+        **kw,
+    ):
+        super().__init__(alpha=alpha, cal_fraction=cal_fraction, **kw)
+        self.base_model = base_model
+        self.alpha = alpha
+        self.cal_fraction = cal_fraction
+        self._qhat: Optional[float] = None
+        self._cal_scores: Optional[np.ndarray] = None
+
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "ConformalPredictionWrapper":
+        """
+        Split data into proper-training and calibration sets.
+        Train base model on proper-training, compute conformal scores on calibration.
+        """
+        n = len(X_train)
+        cal_size = int(n * self.cal_fraction)
+        # Use the LAST cal_size samples for calibration (time-ordered)
+        X_proper = X_train[: n - cal_size]
+        y_proper = y_train[: n - cal_size]
+        X_cal = X_train[n - cal_size :]
+        y_cal = y_train[n - cal_size :]
+
+        # Train base model
+        self.base_model.fit(X_proper, y_proper, X_val, y_val)
+
+        # Compute non-conformity scores on calibration set
+        cal_probs = self.base_model.predict_proba(X_cal)
+        # Score = 1 - P(true_class)
+        scores = np.where(y_cal == 1, 1.0 - cal_probs, cal_probs)
+        self._cal_scores = np.sort(scores)
+
+        # Quantile for desired coverage
+        n_cal = len(self._cal_scores)
+        level = np.ceil((1.0 - self.alpha) * (n_cal + 1)) / n_cal
+        level = min(level, 1.0)
+        self._qhat = np.quantile(self._cal_scores, level, method="higher")
+
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Return point predictions from base model."""
+        assert self._is_fitted, "Model not fitted yet"
+        return self.base_model.predict_proba(X)
+
+    def predict_sets(self, X: np.ndarray) -> List[set]:
+        """
+        Return prediction sets with guaranteed (1-alpha) coverage.
+
+        Each set is one of:
+          - {1}    — confident home win
+          - {0}    — confident away win
+          - {0, 1} — uncertain (both plausible)
+        """
+        assert self._is_fitted, "Model not fitted yet"
+        probs = self.base_model.predict_proba(X)
+        sets = []
+        for p in probs:
+            s = set()
+            # Include class 1 if score would be <= qhat
+            if 1.0 - p <= self._qhat:
+                s.add(1)
+            # Include class 0 if score would be <= qhat
+            if p <= self._qhat:
+                s.add(0)
+            if not s:
+                # Shouldn't happen, but include most likely
+                s.add(1 if p >= 0.5 else 0)
+            sets.append(s)
+        return sets
+
+    def predict_intervals(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Return (lower_bound, upper_bound) calibrated probability intervals.
+
+        Width of interval reflects model uncertainty after conformal calibration.
+        """
+        assert self._is_fitted, "Model not fitted yet"
+        probs = self.base_model.predict_proba(X)
+        lower = np.clip(probs - self._qhat, 0.0, 1.0)
+        upper = np.clip(probs + self._qhat, 0.0, 1.0)
+        return lower, upper
+
+    def get_params(self) -> Dict[str, Any]:
+        base_params = self.base_model.get_params()
+        return {
+            "wrapper": "conformal",
+            "alpha": self.alpha,
+            "cal_fraction": self.cal_fraction,
+            "qhat": float(self._qhat) if self._qhat is not None else None,
+            "base_model": base_params,
+        }
+
+
+# ===========================================================================
+# 7. AutoGluon Ensemble
+# ===========================================================================
+
+class AutoGluonEnsemble(BaseNBAModel):
+    """
+    AutoGluon Tabular — auto-search and stack hundreds of model configurations.
+
+    Time-budgeted: runs for *max_time* seconds, tries GBMs, neural nets,
+    linear models, k-NN, then stacks the best ones.
+
+    Presets: "best_quality" = maximum stacking/bagging (slow but best),
+             "good_quality" = reasonable speed/quality trade-off,
+             "medium_quality" = fastest.
+    """
+
+    def __init__(
+        self,
+        max_time: int = 3600,
+        preset: str = "best_quality",
+        eval_metric: str = "log_loss",
+        num_bag_folds: int = 5,
+        num_stack_levels: int = 1,
+        verbosity: int = 1,
+        **kw,
+    ):
+        super().__init__(
+            max_time=max_time, preset=preset, eval_metric=eval_metric,
+            num_bag_folds=num_bag_folds, num_stack_levels=num_stack_levels,
+            verbosity=verbosity, **kw,
+        )
+        self.max_time = max_time
+        self.preset = preset
+        self.eval_metric = eval_metric
+        self.num_bag_folds = num_bag_folds
+        self.num_stack_levels = num_stack_levels
+        self.verbosity = verbosity
+        self._predictor = None
+
+    def fit(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_val: Optional[np.ndarray] = None,
+        y_val: Optional[np.ndarray] = None,
+    ) -> "AutoGluonEnsemble":
+        try:
+            from autogluon.tabular import TabularPredictor
+            import pandas as pd
+        except ImportError:
+            raise ImportError(
+                "autogluon.tabular not installed. Install with: "
+                "pip install autogluon.tabular"
+            )
+
+        X_train = self._impute(X_train, fit=True)
+
+        # Build DataFrame with feature columns + label
+        n_features = X_train.shape[1]
+        col_names = [f"f_{i}" for i in range(n_features)]
+        df_train = pd.DataFrame(X_train, columns=col_names)
+        df_train["label"] = y_train.astype(int)
+
+        # Validation data (optional tuning set)
+        df_val = None
+        if X_val is not None and y_val is not None:
+            X_val = self._impute(X_val)
+            df_val = pd.DataFrame(X_val, columns=col_names)
+            df_val["label"] = y_val.astype(int)
+
+        self._col_names = col_names
+
+        self._predictor = TabularPredictor(
+            label="label",
+            eval_metric=self.eval_metric,
+            problem_type="binary",
+            verbosity=self.verbosity,
+        )
+
+        fit_kwargs = {
+            "train_data": df_train,
+            "time_limit": self.max_time,
+            "presets": self.preset,
+            "num_bag_folds": self.num_bag_folds,
+            "num_stack_levels": self.num_stack_levels,
+        }
+        if df_val is not None:
+            fit_kwargs["tuning_data"] = df_val
+
+        self._predictor.fit(**fit_kwargs)
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        import pandas as pd
+
+        assert self._is_fitted, "Model not fitted yet"
+        X = self._impute(X)
+        df = pd.DataFrame(X, columns=self._col_names)
+        proba = self._predictor.predict_proba(df)
+        # Returns DataFrame with columns 0, 1 — we want P(class=1)
+        if isinstance(proba, pd.DataFrame):
+            return proba[1].values
+        return proba
+
+    def leaderboard(self):
+        """Return AutoGluon model leaderboard."""
+        assert self._is_fitted, "Model not fitted yet"
+        return self._predictor.leaderboard(silent=True)
+
+    def feature_importance(self, X: np.ndarray, y: np.ndarray) -> "pd.DataFrame":
+        """Return permutation feature importance."""
+        import pandas as pd
+
+        X = self._impute(X)
+        df = pd.DataFrame(X, columns=self._col_names)
+        df["label"] = y.astype(int)
+        return self._predictor.feature_importance(df)
+
+    def save(self, path: Union[str, Path]) -> None:
+        """AutoGluon has its own save mechanism."""
+        path = Path(path)
+        path.mkdir(parents=True, exist_ok=True)
+        if self._predictor is not None:
+            self._predictor.save(str(path / "autogluon_predictor"))
+        # Save wrapper state
+        state = {
+            "params": self.params,
+            "_col_names": getattr(self, "_col_names", None),
+            "_feature_medians": self._feature_medians.tolist() if self._feature_medians is not None else None,
+            "_is_fitted": self._is_fitted,
+        }
+        with open(path / "wrapper_state.json", "w") as f:
+            json.dump(state, f)
+
+    @classmethod
+    def load(cls, path: Union[str, Path]) -> "AutoGluonEnsemble":
+        from autogluon.tabular import TabularPredictor
+
+        path = Path(path)
+        with open(path / "wrapper_state.json") as f:
+            state = json.load(f)
+
+        obj = cls(**state["params"])
+        obj._col_names = state["_col_names"]
+        if state["_feature_medians"] is not None:
+            obj._feature_medians = np.array(state["_feature_medians"], dtype=np.float32)
+        obj._predictor = TabularPredictor.load(str(path / "autogluon_predictor"))
+        obj._is_fitted = state["_is_fitted"]
+        return obj
+
+
+# ===========================================================================
+# Utilities
+# ===========================================================================
+
+def _is_jsonable(v: Any) -> bool:
+    """Check if a value is JSON serialisable."""
+    try:
+        json.dumps(v)
+        return True
+    except (TypeError, OverflowError, ValueError):
+        return False
+
+
+# ===========================================================================
+# Model Registry — maps names to classes for the genetic algorithm
+# ===========================================================================
+
+NEURAL_MODEL_REGISTRY: Dict[str, type] = {
+    "lstm": LSTMSequenceModel,
+    "transformer": TransformerAttentionModel,
+    "tabnet": TabNetModel,
+    "ft_transformer": FTTransformerModel,
+    "deep_ensemble": DeepEnsemble,
+    "conformal": ConformalPredictionWrapper,
+    "autogluon": AutoGluonEnsemble,
+}
+
+
+def build_neural_model(model_type: str, **params) -> BaseNBAModel:
+    """
+    Factory function to build a neural model by name.
+
+    Usage:
+        model = build_neural_model("ft_transformer", n_tokens=128, d_token=64)
+        model.fit(X_train, y_train)
+        probs = model.predict_proba(X_test)
+
+    For conformal wrapper, pass base_model_type and base_model_params:
+        model = build_neural_model(
+            "conformal",
+            base_model_type="deep_ensemble",
+            base_model_params={"n_members": 5},
+            alpha=0.1,
+        )
+    """
+    if model_type == "conformal":
+        base_type = params.pop("base_model_type", "deep_ensemble")
+        base_params = params.pop("base_model_params", {})
+        base_model = build_neural_model(base_type, **base_params)
+        return ConformalPredictionWrapper(base_model=base_model, **params)
+
+    cls = NEURAL_MODEL_REGISTRY.get(model_type)
+    if cls is None:
+        raise ValueError(
+            f"Unknown model type '{model_type}'. "
+            f"Available: {list(NEURAL_MODEL_REGISTRY.keys())}"
+        )
+    return cls(**params)
+
+
+# ===========================================================================
+# Quick smoke test (runs if executed directly)
+# ===========================================================================
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("NBA Quant AI — Neural Models Smoke Test")
+    print("=" * 60)
+
+    np.random.seed(42)
+    N_TRAIN, N_TEST, N_FEAT = 500, 100, 200
+
+    X_train = np.random.randn(N_TRAIN, N_FEAT).astype(np.float32)
+    # Inject some NaNs to test imputation
+    mask = np.random.random(X_train.shape) < 0.05
+    X_train[mask] = np.nan
+    y_train = (np.random.random(N_TRAIN) > 0.5).astype(np.float32)
+
+    X_test = np.random.randn(N_TEST, N_FEAT).astype(np.float32)
+    y_test = (np.random.random(N_TEST) > 0.5).astype(np.float32)
+
+    # Test each model (with small configs for speed)
+    tests = [
+        ("FT-Transformer", FTTransformerModel(
+            n_tokens=32, d_token=16, n_heads=2, n_layers=1,
+            epochs=5, patience=3, batch_size=128,
+        )),
+        ("Deep Ensemble (3 members)", DeepEnsemble(
+            n_members=3, hidden_dims=(64, 32),
+            epochs=5, patience=3, batch_size=128,
+        )),
+        ("LSTM Sequence", LSTMSequenceModel(
+            seq_len=5, hidden1=32, hidden2=16, dense_dim=16,
+            epochs=5, patience=3, batch_size=128,
+        )),
+        ("Transformer Attention", TransformerAttentionModel(
+            seq_len=5, d_model=32, n_heads=2, n_layers=1,
+            dim_ff=64, epochs=5, patience=3, batch_size=128,
+        )),
+    ]
+
+    for name, model in tests:
+        print(f"\n--- {name} ---")
+        try:
+            model.fit(X_train, y_train)
+            probs = model.predict_proba(X_test)
+            print(f"  Predictions shape: {probs.shape}")
+            print(f"  Mean pred: {probs.mean():.4f}, Std: {probs.std():.4f}")
+            print(f"  Min: {probs.min():.4f}, Max: {probs.max():.4f}")
+            print(f"  Params: {list(model.get_params().keys())}")
+        except Exception as e:
+            print(f"  ERROR: {e}")
+
+    # Test conformal wrapper
+    print("\n--- Conformal Prediction Wrapper ---")
+    try:
+        base = DeepEnsemble(
+            n_members=2, hidden_dims=(64, 32),
+            epochs=5, patience=3, batch_size=128,
+        )
+        conformal = ConformalPredictionWrapper(base_model=base, alpha=0.1)
+        conformal.fit(X_train, y_train)
+        probs = conformal.predict_proba(X_test)
+        sets = conformal.predict_sets(X_test)
+        lower, upper = conformal.predict_intervals(X_test)
+        print(f"  Point preds shape: {probs.shape}")
+        print(f"  Prediction sets (first 5): {sets[:5]}")
+        print(f"  Intervals: [{lower[:3]}] - [{upper[:3]}]")
+        print(f"  Avg interval width: {(upper - lower).mean():.4f}")
+    except Exception as e:
+        print(f"  ERROR: {e}")
+
+    # Test TabNet (may fail if pytorch_tabnet not installed)
+    print("\n--- TabNet ---")
+    try:
+        tab = TabNetModel(
+            n_d=8, n_a=8, n_steps=3, epochs=5, patience=3, batch_size=128,
+        )
+        tab.fit(X_train, y_train)
+        probs = tab.predict_proba(X_test)
+        print(f"  Predictions shape: {probs.shape}")
+        print(f"  Mean pred: {probs.mean():.4f}")
+        fi = tab.get_feature_importances()
+        if fi is not None:
+            print(f"  Feature importances shape: {fi.shape}")
+    except ImportError:
+        print("  SKIPPED (pytorch_tabnet not installed)")
+    except Exception as e:
+        print(f"  ERROR: {e}")
+
+    # Test factory
+    print("\n--- Factory: build_neural_model ---")
+    try:
+        m = build_neural_model("ft_transformer", n_tokens=32, d_token=16,
+                               n_heads=2, n_layers=1, epochs=3, batch_size=128)
+        m.fit(X_train, y_train)
+        print(f"  Factory FT-Transformer OK, preds mean: {m.predict_proba(X_test).mean():.4f}")
+    except Exception as e:
+        print(f"  ERROR: {e}")
+
+    print("\n" + "=" * 60)
+    print("Smoke test complete.")
+    print("=" * 60)

requirements.txt

@@ -0,0 +1,19 @@
+numpy>=2.0
+scikit-learn>=1.5
+xgboost>=3.0
+lightgbm>=4.0
+nba_api>=1.4
+gradio>=5.0
+uvicorn>=0.30
+catboost>=1.2
+psycopg2-binary>=2.9
+# --- Neural network models (2025-2026 SOTA) ---
+torch>=2.3 --index-url https://download.pytorch.org/whl/cpu
+pytorch_tabnet>=4.1
+mapie>=0.9
+betacal>=0.1
+# autogluon.tabular>=1.2  # OPTIONAL — large install (~2GB), uncomment if needed
+# --- Browser scraping (needs Playwright deps in Docker image, see Dockerfile.browser) ---
+# crawl4ai>=0.4  # OPTIONAL — uncomment when using Dockerfile.browser for browser-based scraping
+html2text>=2024.2  # Lightweight HTML-to-markdown for requests fallback
+beautifulsoup4>=4.12  # CSS selector extraction in requests fallback